BtrfsVolPropSheet Class Reference

#include <volpropsheet.h>

Inheritance diagram for BtrfsVolPropSheet:

Collaboration diagram for BtrfsVolPropSheet:

Public Member Functions
	BtrfsVolPropSheet ()
virtual	~BtrfsVolPropSheet ()
HRESULT __stdcall	QueryInterface (REFIID riid, void **ppObj)
ULONG __stdcall	AddRef ()
ULONG __stdcall	Release ()
virtual HRESULT __stdcall	Initialize (PCIDLIST_ABSOLUTE pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID)
virtual HRESULT __stdcall	AddPages (LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
virtual HRESULT __stdcall	ReplacePage (UINT uPageID, LPFNADDPROPSHEETPAGE pfnReplacePage, LPARAM lParam)
void	FormatUsage (HWND hwndDlg, wstring &s, btrfs_usage *usage)
void	RefreshUsage (HWND hwndDlg)
void	ShowUsage (HWND hwndDlg)
INT_PTR CALLBACK	UsageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	RefreshDevList (HWND devlist)
INT_PTR CALLBACK	DeviceDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	ShowDevices (HWND hwndDlg)
void	ShowScrub (HWND hwndDlg)
void	ShowChangeDriveLetter (HWND hwndDlg)
INT_PTR CALLBACK	StatsDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	ShowStats (HWND hwndDlg, uint64_t devid)
void	ResetStats (HWND hwndDlg)
HRESULT	Initialize ([in] PCIDLIST_ABSOLUTE pidlFolder, [in] IDataObject *pdtobj, [in] HKEY hkeyProgID)
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()

Public Attributes
btrfs_device *	devices
bool	readonly
BtrfsBalance *	balance
BTRFS_UUID	uuid
bool	uuid_set

Private Attributes
LONG	refcount
bool	ignore
STGMEDIUM	stgm
bool	stgm_set
wstring	fn
uint64_t	stats_dev

Additional Inherited Members
Public Types inherited from IShellExtInit
typedef IShellExtInit *	LPSHELLEXTINIT
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Private Types inherited from IShellPropSheetExt
enum	tagSHELLPROPSHEETEXTPAGEID { EXPPS_FILETYPES = 0x1 }
typedef UINT	EXPPS
Private Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Private Member Functions inherited from IShellPropSheetExt
HRESULT	AddPages ([in] LPFNSVADDPROPSHEETPAGE pfnAddPage, [in] LPARAM lParam)
HRESULT	ReplacePage ([in] EXPPS uPageID, [in] LPFNSVADDPROPSHEETPAGE pfnReplaceWith, [in] LPARAM lParam)
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()

Detailed Description

Definition at line 33 of file volpropsheet.h.

Constructor & Destructor Documentation

BtrfsVolPropSheet()

BtrfsVolPropSheet::BtrfsVolPropSheet ( )

inline

Definition at line 35 of file volpropsheet.h.

                        {
        refcount = 0;
        ignore = true;
        stgm_set = false;
        devices = nullptr;
 
        InterlockedIncrement(&objs_loaded);
 
        balance = nullptr;
    }

~BtrfsVolPropSheet()

virtual BtrfsVolPropSheet::~BtrfsVolPropSheet ( )

inlinevirtual

Definition at line 46 of file volpropsheet.h.

                                 {
        if (stgm_set) {
            GlobalUnlock(stgm.hGlobal);
            ReleaseStgMedium(&stgm);
        }
 
        if (devices)
            free(devices);
 
        InterlockedDecrement(&objs_loaded);
 
        if (balance)
            delete balance;
    }

Member Function Documentation

AddPages()

HRESULT __stdcall BtrfsVolPropSheet::AddPages ( LPFNADDPROPSHEETPAGE  pfnAddPage, LPARAM  lParam  )

virtual

Definition at line 1429 of file volpropsheet.cpp.

                                                                                            {
    try {
        PROPSHEETPAGEW psp;
        HPROPSHEETPAGE hPage;
        INITCOMMONCONTROLSEX icex;
 
        if (ignore)
            return S_OK;
 
        icex.dwSize = sizeof(icex);
        icex.dwICC = ICC_LINK_CLASS;
 
        if (!InitCommonControlsEx(&icex))
            throw string_error(IDS_INITCOMMONCONTROLSEX_FAILED);
 
        psp.dwSize = sizeof(psp);
        psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE;
        psp.hInstance = module;
        psp.pszTemplate = MAKEINTRESOURCEW(IDD_VOL_PROP_SHEET);
        psp.hIcon = 0;
        psp.pszTitle = MAKEINTRESOURCEW(IDS_VOL_PROP_SHEET_TITLE);
        psp.pfnDlgProc = (DLGPROC)PropSheetDlgProc;
        psp.pcRefParent = (UINT*)&objs_loaded;
        psp.pfnCallback = nullptr;
        psp.lParam = (LPARAM)this;
 
        hPage = CreatePropertySheetPageW(&psp);
 
        if (hPage) {
            if (pfnAddPage(hPage, lParam)) {
                this->AddRef();
                return S_OK;
            } else
                DestroyPropertySheetPage(hPage);
        } else
            return E_OUTOFMEMORY;
    } catch (const exception& e) {
        error_message(nullptr, e.what());
    }
 
    return E_FAIL;
}

AddRef()

ULONG __stdcall BtrfsVolPropSheet::AddRef ( void  )

inline

Implements IUnknown.

Definition at line 65 of file volpropsheet.h.

                             {
        return InterlockedIncrement(&refcount);
    }

Referenced by AddPages(), and QueryInterface().

DeviceDlgProc()

INT_PTR CALLBACK BtrfsVolPropSheet::DeviceDlgProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 964 of file volpropsheet.cpp.

                                                                                                       {
    try {
        switch (uMsg) {
            case WM_INITDIALOG:
            {
                HWND devlist;
                RECT rect;
                ULONG w;
 
                EnableThemeDialogTexture(hwndDlg, ETDT_ENABLETAB);
 
                devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
 
                GetClientRect(devlist, &rect);
                w = rect.right - rect.left;
 
                add_lv_column(devlist, IDS_DEVLIST_ALLOC_PC, w * 5 / 44);
                add_lv_column(devlist, IDS_DEVLIST_ALLOC, w * 6 / 44);
                add_lv_column(devlist, IDS_DEVLIST_SIZE, w * 6 / 44);
                add_lv_column(devlist, IDS_DEVLIST_READONLY, w * 7 / 44);
                add_lv_column(devlist, IDS_DEVLIST_DESC, w * 16 / 44);
                add_lv_column(devlist, IDS_DEVLIST_ID, w * 4 / 44);
 
                SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_ADD), BCM_SETSHIELD, 0, true);
                SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_REMOVE), BCM_SETSHIELD, 0, true);
                SendMessageW(GetDlgItem(hwndDlg, IDC_DEVICE_RESIZE), BCM_SETSHIELD, 0, true);
 
                RefreshDevList(devlist);
 
                break;
            }
 
            case WM_COMMAND:
                switch (HIWORD(wParam)) {
                    case BN_CLICKED:
                        switch (LOWORD(wParam)) {
                            case IDOK:
                            case IDCANCEL:
                                KillTimer(hwndDlg, 1);
                                EndDialog(hwndDlg, 0);
                            return true;
 
                            case IDC_DEVICE_ADD:
                            {
                                wstring t;
                                WCHAR modfn[MAX_PATH];
                                SHELLEXECUTEINFOW sei;
 
                                GetModuleFileNameW(module, modfn, sizeof(modfn) / sizeof(WCHAR));
 
#ifndef __REACTOS__
                                t = L"\""s + modfn + L"\",AddDevice "s + fn;
#else
                                t = wstring(L"\"") + modfn + wstring(L"\",AddDevice ") + fn;
#endif
 
                                RtlZeroMemory(&sei, sizeof(sei));
 
                                sei.cbSize = sizeof(sei);
                                sei.hwnd = hwndDlg;
                                sei.lpVerb = L"runas";
                                sei.lpFile = L"rundll32.exe";
                                sei.lpParameters = t.c_str();
                                sei.nShow = SW_SHOW;
                                sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
                                if (!ShellExecuteExW(&sei))
                                    throw last_error(GetLastError());
 
                                WaitForSingleObject(sei.hProcess, INFINITE);
                                CloseHandle(sei.hProcess);
 
                                RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
 
                                return true;
                            }
 
                            case IDC_DEVICE_REFRESH:
                                RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
                                return true;
 
                            case IDC_DEVICE_SHOW_STATS:
                            {
                                WCHAR sel[MAX_PATH];
                                HWND devlist;
                                LVITEMW lvi;
 
                                devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
 
                                auto index = SendMessageW(devlist, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
 
                                if (index == -1)
                                    return true;
 
                                RtlZeroMemory(&lvi, sizeof(LVITEMW));
                                lvi.mask = LVIF_TEXT;
                                lvi.iItem = (int)index;
                                lvi.iSubItem = 0;
                                lvi.pszText = sel;
                                lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
                                SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
 
                                ShowStats(hwndDlg, _wtoi(sel));
                                return true;
                            }
 
                            case IDC_DEVICE_REMOVE:
                            {
                                wstring t, mess, mess2, title;
                                WCHAR modfn[MAX_PATH], sel[MAX_PATH], sel2[MAX_PATH];
                                HWND devlist;
                                SHELLEXECUTEINFOW sei;
                                LVITEMW lvi;
 
                                devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
 
                                auto index = SendMessageW(devlist, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
 
                                if (index == -1)
                                    return true;
 
                                RtlZeroMemory(&lvi, sizeof(LVITEMW));
                                lvi.mask = LVIF_TEXT;
                                lvi.iItem = (int)index;
                                lvi.iSubItem = 0;
                                lvi.pszText = sel;
                                lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
                                SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
 
                                lvi.iSubItem = 1;
                                lvi.pszText = sel2;
                                lvi.cchTextMax = sizeof(sel2) / sizeof(WCHAR);
                                SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
 
                                if (!load_string(module, IDS_REMOVE_DEVICE_CONFIRMATION, mess))
                                    throw last_error(GetLastError());
 
                                wstring_sprintf(mess2, mess, sel, sel2);
 
                                if (!load_string(module, IDS_CONFIRMATION_TITLE, title))
                                    throw last_error(GetLastError());
 
                                if (MessageBoxW(hwndDlg, mess2.c_str(), title.c_str(), MB_YESNO) != IDYES)
                                    return true;
 
                                GetModuleFileNameW(module, modfn, sizeof(modfn) / sizeof(WCHAR));
 
#ifndef __REACTOS__
                                t = L"\""s + modfn + L"\",RemoveDevice "s + fn + L"|"s + sel;
#else
                                t = wstring(L"\"") + modfn + wstring(L"\",RemoveDevice ") + fn + wstring(L"|") + sel;
#endif
 
                                RtlZeroMemory(&sei, sizeof(sei));
 
                                sei.cbSize = sizeof(sei);
                                sei.hwnd = hwndDlg;
                                sei.lpVerb = L"runas";
                                sei.lpFile = L"rundll32.exe";
                                sei.lpParameters = t.c_str();
                                sei.nShow = SW_SHOW;
                                sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
                                if (!ShellExecuteExW(&sei))
                                    throw last_error(GetLastError());
 
                                WaitForSingleObject(sei.hProcess, INFINITE);
                                CloseHandle(sei.hProcess);
 
                                RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
 
                                return true;
                            }
 
                            case IDC_DEVICE_RESIZE:
                            {
                                HWND devlist;
                                LVITEMW lvi;
                                wstring t;
                                WCHAR modfn[MAX_PATH], sel[100];
                                SHELLEXECUTEINFOW sei;
 
                                devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
 
                                auto index = SendMessageW(devlist, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
 
                                if (index == -1)
                                    return true;
 
                                RtlZeroMemory(&lvi, sizeof(LVITEMW));
                                lvi.mask = LVIF_TEXT;
                                lvi.iItem = (int)index;
                                lvi.iSubItem = 0;
                                lvi.pszText = sel;
                                lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
                                SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
 
                                GetModuleFileNameW(module, modfn, sizeof(modfn) / sizeof(WCHAR));
 
#ifndef __REACTOS__
                                t = L"\""s + modfn + L"\",ResizeDevice "s + fn + L"|"s + sel;
#else
                                t = wstring(L"\"") + modfn + wstring(L"\",ResizeDevice ") + fn + wstring(L"|") + sel;
#endif
 
                                RtlZeroMemory(&sei, sizeof(sei));
 
                                sei.cbSize = sizeof(sei);
                                sei.hwnd = hwndDlg;
                                sei.lpVerb = L"runas";
                                sei.lpFile = L"rundll32.exe";
                                sei.lpParameters = t.c_str();
                                sei.nShow = SW_SHOW;
                                sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
                                if (!ShellExecuteExW(&sei))
                                    throw last_error(GetLastError());
 
                                WaitForSingleObject(sei.hProcess, INFINITE);
                                CloseHandle(sei.hProcess);
 
                                RefreshDevList(GetDlgItem(hwndDlg, IDC_DEVLIST));
                            }
                        }
                    break;
                }
            break;
 
            case WM_NOTIFY:
                switch (((LPNMHDR)lParam)->code) {
                    case LVN_ITEMCHANGED:
                    {
                        NMLISTVIEW* nmv = (NMLISTVIEW*)lParam;
 
                        EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_SHOW_STATS), nmv->uNewState & LVIS_SELECTED);
 
                        if (nmv->uNewState & LVIS_SELECTED && !readonly) {
                            HWND devlist;
                            btrfs_device* bd;
                            bool device_readonly = false;
                            LVITEMW lvi;
                            WCHAR sel[MAX_PATH];
                            uint64_t devid;
 
                            devlist = GetDlgItem(hwndDlg, IDC_DEVLIST);
 
                            RtlZeroMemory(&lvi, sizeof(LVITEMW));
                            lvi.mask = LVIF_TEXT;
                            lvi.iItem = nmv->iItem;
                            lvi.iSubItem = 0;
                            lvi.pszText = sel;
                            lvi.cchTextMax = sizeof(sel) / sizeof(WCHAR);
                            SendMessageW(devlist, LVM_GETITEMW, 0, (LPARAM)&lvi);
                            devid = _wtoi(sel);
 
                            bd = devices;
 
                            while (true) {
                                if (bd->dev_id == devid) {
                                    device_readonly = bd->readonly;
                                    break;
                                }
 
                                if (bd->next_entry > 0)
                                    bd = (btrfs_device*)((uint8_t*)bd + bd->next_entry);
                                else
                                    break;
                            }
 
                            EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_RESIZE), !device_readonly);
                        } else
                            EnableWindow(GetDlgItem(hwndDlg, IDC_DEVICE_RESIZE), false);
 
                        break;
                    }
                }
            break;
        }
    } catch (const exception& e) {
        error_message(hwndDlg, e.what());
    }
 
    return false;
}

Referenced by stub_DeviceDlgProc().

FormatUsage()

void BtrfsVolPropSheet::FormatUsage	(	HWND	hwndDlg,
		wstring &	s,
		btrfs_usage *	usage
	)

Definition at line 165 of file volpropsheet.cpp.

                                                                                {
    uint8_t i, j;
    uint64_t num_devs, dev_size, dev_alloc, data_size, data_alloc, metadata_size, metadata_alloc;
    btrfs_device* bd;
    vector<dev> devs;
    btrfs_usage* bue;
    wstring t, u, v;
 
    static const uint64_t types[] = { BLOCK_FLAG_DATA, BLOCK_FLAG_DATA | BLOCK_FLAG_METADATA, BLOCK_FLAG_METADATA, BLOCK_FLAG_SYSTEM };
    static const ULONG typestrings[] = { IDS_USAGE_DATA, IDS_USAGE_MIXED, IDS_USAGE_METADATA, IDS_USAGE_SYSTEM };
    static const uint64_t duptypes[] = { 0, BLOCK_FLAG_DUPLICATE, BLOCK_FLAG_RAID0, BLOCK_FLAG_RAID1, BLOCK_FLAG_RAID10, BLOCK_FLAG_RAID5,
                                         BLOCK_FLAG_RAID6, BLOCK_FLAG_RAID1C3, BLOCK_FLAG_RAID1C4 };
    static const ULONG dupstrings[] = { IDS_SINGLE, IDS_DUP, IDS_RAID0, IDS_RAID1, IDS_RAID10, IDS_RAID5, IDS_RAID6, IDS_RAID1C3, IDS_RAID1C4 };
 
    static const uint64_t raid_types = BLOCK_FLAG_DUPLICATE | BLOCK_FLAG_RAID0 | BLOCK_FLAG_RAID1 | BLOCK_FLAG_RAID10 | BLOCK_FLAG_RAID5 |
                                       BLOCK_FLAG_RAID6 | BLOCK_FLAG_RAID1C3 | BLOCK_FLAG_RAID1C4;
 
    s = L"";
 
    num_devs = 0;
    bd = devices;
 
    while (true) {
        num_devs++;
 
        if (bd->next_entry > 0)
            bd = (btrfs_device*)((uint8_t*)bd + bd->next_entry);
        else
            break;
    }
 
    bd = devices;
 
    dev_size = 0;
 
    while (true) {
        dev d;
 
        if (bd->missing) {
            if (!load_string(module, IDS_MISSING, d.name))
                throw last_error(GetLastError());
        } else if (bd->device_number == 0xffffffff)
            d.name = wstring(bd->name, bd->namelen / sizeof(WCHAR));
        else if (bd->partition_number == 0) {
            if (!load_string(module, IDS_DISK_NUM, u))
                throw last_error(GetLastError());
 
            wstring_sprintf(d.name, u, bd->device_number);
        } else {
            if (!load_string(module, IDS_DISK_PART_NUM, u))
                throw last_error(GetLastError());
 
            wstring_sprintf(d.name, u, bd->device_number, bd->partition_number);
        }
 
        d.dev_id = bd->dev_id;
        d.alloc = 0;
        d.size = bd->size;
 
        devs.push_back(d);
 
        dev_size += bd->size;
 
        if (bd->next_entry > 0)
            bd = (btrfs_device*)((uint8_t*)bd + bd->next_entry);
        else
            break;
    }
 
    dev_alloc = 0;
    data_size = data_alloc = 0;
    metadata_size = metadata_alloc = 0;
 
    bue = usage;
    while (true) {
        for (uint64_t k = 0; k < bue->num_devices; k++) {
            dev_alloc += bue->devices[k].alloc;
 
            if (bue->type & BLOCK_FLAG_DATA) {
                data_alloc += bue->devices[k].alloc;
            }
 
            if (bue->type & BLOCK_FLAG_METADATA) {
                metadata_alloc += bue->devices[k].alloc;
            }
        }
 
        if (bue->type & BLOCK_FLAG_DATA)
            data_size += bue->size;
 
        if (bue->type & BLOCK_FLAG_METADATA)
            metadata_size += bue->size;
 
        if (bue->next_entry > 0)
            bue = (btrfs_usage*)((uint8_t*)bue + bue->next_entry);
        else
            break;
    }
 
    // device size
 
    if (!load_string(module, IDS_USAGE_DEV_SIZE, u))
        throw last_error(GetLastError());
 
    format_size(dev_size, v, false);
 
    wstring_sprintf(t, u, v.c_str());
 
    s += t + L"\r\n";
 
    // device allocated
 
    if (!load_string(module, IDS_USAGE_DEV_ALLOC, u))
        throw last_error(GetLastError());
 
    format_size(dev_alloc, v, false);
 
    wstring_sprintf(t, u, v.c_str());
 
#ifndef __REACTOS__
    s += t + L"\r\n"s;
#else
    s += t + L"\r\n";
#endif
 
    // device unallocated
 
    if (!load_string(module, IDS_USAGE_DEV_UNALLOC, u))
        throw last_error(GetLastError());
 
    format_size(dev_size - dev_alloc, v, false);
 
    wstring_sprintf(t, u, v.c_str());
 
#ifndef __REACTOS__
    s += t + L"\r\n"s;
#else
    s += t + L"\r\n";
#endif
 
    // data ratio
 
    if (data_alloc > 0) {
        if (!load_string(module, IDS_USAGE_DATA_RATIO, u))
            throw last_error(GetLastError());
 
        wstring_sprintf(t, u, (float)data_alloc / (float)data_size);
 
#ifndef __REACTOS__
        s += t + L"\r\n"s;
#else
        s += t + L"\r\n";
#endif
    }
 
    // metadata ratio
 
    if (!load_string(module, IDS_USAGE_METADATA_RATIO, u))
        throw last_error(GetLastError());
 
    wstring_sprintf(t, u, (float)metadata_alloc / (float)metadata_size);
 
    s += t + L"\r\n\r\n";
 
    for (i = 0; i < sizeof(types) / sizeof(types[0]); i++) {
        for (j = 0; j < sizeof(duptypes) / sizeof(duptypes[0]); j++) {
            bue = usage;
 
            while (true) {
                if ((bue->type & types[i]) == types[i] && ((duptypes[j] == 0 && (bue->type & raid_types) == 0) || bue->type & duptypes[j])) {
                    wstring sizestring, usedstring, typestring, dupstring;
 
                    if (bue->type & BLOCK_FLAG_DATA && bue->type & BLOCK_FLAG_METADATA && (types[i] == BLOCK_FLAG_DATA || types[i] == BLOCK_FLAG_METADATA))
                        break;
 
                    if (!load_string(module, typestrings[i], typestring))
                        throw last_error(GetLastError());
 
                    if (!load_string(module, dupstrings[j], dupstring))
                        throw last_error(GetLastError());
 
                    format_size(bue->size, sizestring, false);
                    format_size(bue->used, usedstring, false);
 
                    wstring_sprintf(t, typestring, dupstring.c_str(), sizestring.c_str(), usedstring.c_str());
 
                    s += t + L"\r\n";
 
                    for (uint64_t k = 0; k < bue->num_devices; k++) {
                        bool found = false;
 
                        format_size(bue->devices[k].alloc, sizestring, false);
 
                        for (size_t l = 0; l < min((uint64_t)SIZE_MAX, num_devs); l++) {
                            if (devs[l].dev_id == bue->devices[k].dev_id) {
                                s += devs[l].name + L"\t" + sizestring + L"\r\n";
 
                                devs[l].alloc += bue->devices[k].alloc;
 
                                found = true;
                                break;
                            }
                        }
 
                        if (!found) {
                            if (!load_string(module, IDS_UNKNOWN_DEVICE, typestring))
                                throw last_error(GetLastError());
 
                            wstring_sprintf(t, typestring, bue->devices[k].dev_id);
 
#ifndef __REACTOS__
                            s += t + L"\t"s + sizestring + L"\r\n"s;
#else
                            s += t + L"\t" + sizestring + L"\r\n";
#endif
                        }
                    }
 
                    s += L"\r\n";
 
                    break;
                }
 
                if (bue->next_entry > 0)
                    bue = (btrfs_usage*)((uint8_t*)bue + bue->next_entry);
                else
                    break;
            }
        }
    }
 
    if (!load_string(module, IDS_USAGE_UNALLOC, t))
        throw last_error(GetLastError());
 
#ifndef __REACTOS__
    s += t + L"\r\n"s;
#else
    s += t + L"\r\n";
#endif
 
    for (size_t k = 0; k < min((uint64_t)SIZE_MAX, num_devs); k++) {
        wstring sizestring;
 
        format_size(devs[k].size - devs[k].alloc, sizestring, false);
 
        s += devs[k].name + L"\t" + sizestring + L"\r\n";
    }
}

Referenced by RefreshUsage(), and UsageDlgProc().

Initialize()

HRESULT __stdcall BtrfsVolPropSheet::Initialize ( PCIDLIST_ABSOLUTE  pidlFolder, IDataObject *  pdtobj, HKEY  hkeyProgID  )

virtual

Implements IShellExtInit.

Definition at line 66 of file volpropsheet.cpp.

                                                                                                                  {
    ULONG num_files;
    FORMATETC format = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
    HDROP hdrop;
    WCHAR fnbuf[MAX_PATH];
 
    if (pidlFolder)
        return E_FAIL;
 
    if (!pdtobj)
        return E_FAIL;
 
    stgm.tymed = TYMED_HGLOBAL;
 
    if (FAILED(pdtobj->GetData(&format, &stgm)))
        return E_INVALIDARG;
 
    stgm_set = true;
 
    hdrop = (HDROP)GlobalLock(stgm.hGlobal);
 
    if (!hdrop) {
        ReleaseStgMedium(&stgm);
        stgm_set = false;
        return E_INVALIDARG;
    }
 
    num_files = DragQueryFileW((HDROP)stgm.hGlobal, 0xFFFFFFFF, nullptr, 0);
 
    if (num_files > 1) {
        GlobalUnlock(hdrop);
        return E_FAIL;
    }
 
    if (DragQueryFileW((HDROP)stgm.hGlobal, 0, fnbuf, sizeof(fnbuf) / sizeof(WCHAR))) {
        fn = fnbuf;
 
        win_handle h = CreateFileW(fn.c_str(), FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                                   OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
 
        if (h != INVALID_HANDLE_VALUE) {
            NTSTATUS Status;
            IO_STATUS_BLOCK iosb;
            ULONG devsize, i;
 
            i = 0;
            devsize = 1024;
 
            devices = (btrfs_device*)malloc(devsize);
 
            while (true) {
                Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_DEVICES, nullptr, 0, devices, devsize);
                if (Status == STATUS_BUFFER_OVERFLOW) {
                    if (i < 8) {
                        devsize += 1024;
 
                        free(devices);
                        devices = (btrfs_device*)malloc(devsize);
 
                        i++;
                    } else {
                        GlobalUnlock(hdrop);
                        return E_FAIL;
                    }
                } else
                    break;
            }
 
            if (!NT_SUCCESS(Status)) {
                GlobalUnlock(hdrop);
                return E_FAIL;
            }
 
            Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_UUID, nullptr, 0, &uuid, sizeof(BTRFS_UUID));
            uuid_set = NT_SUCCESS(Status);
 
            ignore = false;
            balance = new BtrfsBalance(fn);
        } else {
            GlobalUnlock(hdrop);
            return E_FAIL;
        }
    } else {
        GlobalUnlock(hdrop);
        return E_FAIL;
    }
 
    GlobalUnlock(hdrop);
 
    return S_OK;
}

QueryInterface()

HRESULT __stdcall BtrfsVolPropSheet::QueryInterface	(	REFIID	riid,
		void **	ppObj
	)

Implements IUnknown.

Definition at line 51 of file volpropsheet.cpp.

                                                                             {
    if (riid == IID_IUnknown || riid == IID_IShellPropSheetExt) {
        *ppObj = static_cast<IShellPropSheetExt*>(this);
        AddRef();
        return S_OK;
    } else if (riid == IID_IShellExtInit) {
        *ppObj = static_cast<IShellExtInit*>(this);
        AddRef();
        return S_OK;
    }
 
    *ppObj = nullptr;
    return E_NOINTERFACE;
}

Referenced by Factory::CreateInstance().

RefreshDevList()

void BtrfsVolPropSheet::RefreshDevList

(

HWND

devlist

)

Definition at line 632 of file volpropsheet.cpp.

                                                   {
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    ULONG usagesize, devsize;
    btrfs_usage* usage;
    btrfs_device* bd;
    int i;
    uint64_t num_rw_devices;
    {
        win_handle h = CreateFileW(fn.c_str(), FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                                   OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
 
        if (h == INVALID_HANDLE_VALUE)
            throw last_error(GetLastError());
 
        i = 0;
        devsize = 1024;
 
        if (devices)
            free(devices);
 
        devices = (btrfs_device*)malloc(devsize);
 
        while (true) {
            Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_DEVICES, nullptr, 0, devices, devsize);
            if (Status == STATUS_BUFFER_OVERFLOW) {
                if (i < 8) {
                    devsize += 1024;
 
                    free(devices);
                    devices = (btrfs_device*)malloc(devsize);
 
                    i++;
                } else
                    return;
            } else
                break;
        }
 
        if (!NT_SUCCESS(Status))
            return;
 
        bd = devices;
 
        i = 0;
        usagesize = 1024;
 
        usage = (btrfs_usage*)malloc(usagesize);
 
        while (true) {
            Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_USAGE, nullptr, 0, usage, usagesize);
            if (Status == STATUS_BUFFER_OVERFLOW) {
                if (i < 8) {
                    usagesize += 1024;
 
                    free(usage);
                    usage = (btrfs_usage*)malloc(usagesize);
 
                    i++;
                } else {
                    free(usage);
                    return;
                }
            } else
                break;
        }
 
        if (!NT_SUCCESS(Status)) {
            free(usage);
            return;
        }
    }
 
    SendMessageW(devlist, LVM_DELETEALLITEMS, 0, 0);
 
    num_rw_devices = 0;
 
    i = 0;
    while (true) {
        LVITEMW lvi;
        wstring s, u;
        uint64_t alloc;
 
        // ID
 
        RtlZeroMemory(&lvi, sizeof(LVITEMW));
        lvi.mask = LVIF_TEXT | LVIF_PARAM;
        lvi.iItem = (int)SendMessageW(devlist, LVM_GETITEMCOUNT, 0, 0);
        lvi.lParam = (LPARAM)bd->dev_id;
 
        s = to_wstring(bd->dev_id);
        lvi.pszText = (LPWSTR)s.c_str();
 
        SendMessageW(devlist, LVM_INSERTITEMW, 0, (LPARAM)&lvi);
 
        // description
 
        lvi.mask = LVIF_TEXT;
        lvi.iSubItem = 1;
 
        if (bd->missing) {
            if (!load_string(module, IDS_MISSING, s))
                throw last_error(GetLastError());
        } else if (bd->device_number == 0xffffffff)
            s = wstring(bd->name, bd->namelen / sizeof(WCHAR));
        else if (bd->partition_number == 0) {
            if (!load_string(module, IDS_DISK_NUM, u))
                throw last_error(GetLastError());
 
            wstring_sprintf(s, u, bd->device_number);
        } else {
            if (!load_string(module, IDS_DISK_PART_NUM, u))
                throw last_error(GetLastError());
 
            wstring_sprintf(s, u, bd->device_number, bd->partition_number);
        }
 
        lvi.pszText = (LPWSTR)s.c_str();
 
        SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
 
        // readonly
 
        lvi.iSubItem = 2;
        load_string(module, bd->readonly ? IDS_DEVLIST_READONLY_YES : IDS_DEVLIST_READONLY_NO, s);
        lvi.pszText = (LPWSTR)s.c_str();
        SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
 
        if (!bd->readonly)
            num_rw_devices++;
 
        // size
 
        lvi.iSubItem = 3;
        format_size(bd->size, s, false);
        lvi.pszText = (LPWSTR)s.c_str();
        SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
 
        // alloc
 
        alloc = find_dev_alloc(bd->dev_id, usage);
 
        lvi.iSubItem = 4;
        format_size(alloc, s, false);
        lvi.pszText = (LPWSTR)s.c_str();
        SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
 
        // alloc %
 
        wstring_sprintf(s, L"%1.1f%%", (float)alloc * 100.0f / (float)bd->size);
        lvi.iSubItem = 5;
        lvi.pszText = (LPWSTR)s.c_str();
        SendMessageW(devlist, LVM_SETITEMW, 0, (LPARAM)&lvi);
 
        i++;
 
        if (bd->next_entry > 0)
            bd = (btrfs_device*)((uint8_t*)bd + bd->next_entry);
        else
            break;
    }
 
    free(usage);
 
    SendMessageW(devlist, LVM_SORTITEMS, 0, (LPARAM)lv_sort);
 
    EnableWindow(GetDlgItem(GetParent(devlist), IDC_DEVICE_ADD), num_rw_devices > 0);
    EnableWindow(GetDlgItem(GetParent(devlist), IDC_DEVICE_REMOVE), num_rw_devices > 1);
}

Referenced by DeviceDlgProc().

RefreshUsage()

void BtrfsVolPropSheet::RefreshUsage

(

HWND

hwndDlg

)

Definition at line 414 of file volpropsheet.cpp.

                                                 {
    wstring s;
    btrfs_usage* usage;
 
    win_handle h = CreateFileW(fn.c_str(), FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                               OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
 
    if (h != INVALID_HANDLE_VALUE) {
        NTSTATUS Status;
        IO_STATUS_BLOCK iosb;
        ULONG devsize, usagesize, i;
 
        i = 0;
        devsize = 1024;
 
        devices = (btrfs_device*)malloc(devsize);
 
        while (true) {
            Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_DEVICES, nullptr, 0, devices, devsize);
            if (Status == STATUS_BUFFER_OVERFLOW) {
                if (i < 8) {
                    devsize += 1024;
 
                    free(devices);
                    devices = (btrfs_device*)malloc(devsize);
 
                    i++;
                } else
                    return;
            } else
                break;
        }
 
        if (!NT_SUCCESS(Status))
            return;
 
        i = 0;
        usagesize = 1024;
 
        usage = (btrfs_usage*)malloc(usagesize);
 
        while (true) {
            Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_USAGE, nullptr, 0, usage, usagesize);
            if (Status == STATUS_BUFFER_OVERFLOW) {
                if (i < 8) {
                    usagesize += 1024;
 
                    free(usage);
                    usage = (btrfs_usage*)malloc(usagesize);
 
                    i++;
                } else
                    return;
            } else
                break;
        }
 
        if (!NT_SUCCESS(Status)) {
            free(usage);
            return;
        }
 
        ignore = false;
    } else
        return;
 
    FormatUsage(hwndDlg, s, usage);
 
    SetDlgItemTextW(hwndDlg, IDC_USAGE_BOX, s.c_str());
 
    free(usage);
}

Referenced by UsageDlgProc().

Release()

ULONG __stdcall BtrfsVolPropSheet::Release ( void  )

inline

Implements IUnknown.

Definition at line 69 of file volpropsheet.h.

                              {
        LONG rc = InterlockedDecrement(&refcount);
 
        if (rc == 0)
            delete this;
 
        return rc;
    }

ReplacePage()

HRESULT __stdcall BtrfsVolPropSheet::ReplacePage ( UINT  uPageID, LPFNADDPROPSHEETPAGE  pfnReplacePage, LPARAM  lParam  )

virtual

Definition at line 1472 of file volpropsheet.cpp.

                                                                                                                 {
    return S_OK;
}

ResetStats()

void BtrfsVolPropSheet::ResetStats

(

HWND

hwndDlg

)

Definition at line 802 of file volpropsheet.cpp.

                                               {
    wstring t, sel;
    WCHAR modfn[MAX_PATH];
    SHELLEXECUTEINFOW sei;
 
    sel = to_wstring(stats_dev);
 
    GetModuleFileNameW(module, modfn, sizeof(modfn) / sizeof(WCHAR));
 
#ifndef __REACTOS__
    t = L"\""s + modfn + L"\",ResetStats " + fn + L"|" + sel;
#else
    t = wstring(L"\"") + modfn + wstring(L"\",ResetStats ") + fn + wstring(L"|") + sel;
#endif
 
    RtlZeroMemory(&sei, sizeof(sei));
 
    sei.cbSize = sizeof(sei);
    sei.hwnd = hwndDlg;
    sei.lpVerb = L"runas";
    sei.lpFile = L"rundll32.exe";
    sei.lpParameters = t.c_str();
    sei.nShow = SW_SHOW;
    sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
    if (!ShellExecuteExW(&sei))
        throw last_error(GetLastError());
 
    WaitForSingleObject(sei.hProcess, INFINITE);
    CloseHandle(sei.hProcess);
 
    win_handle h = CreateFileW(fn.c_str(), FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                               OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
 
    if (h != INVALID_HANDLE_VALUE) {
        NTSTATUS Status;
        IO_STATUS_BLOCK iosb;
        ULONG devsize, i;
 
        i = 0;
        devsize = 1024;
 
        free(devices);
        devices = (btrfs_device*)malloc(devsize);
 
        while (true) {
            Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_DEVICES, nullptr, 0, devices, devsize);
            if (Status == STATUS_BUFFER_OVERFLOW) {
                if (i < 8) {
                    devsize += 1024;
 
                    free(devices);
                    devices = (btrfs_device*)malloc(devsize);
 
                    i++;
                } else
                    break;
            } else
                break;
        }
    }
 
    EndDialog(hwndDlg, 0);
}

Referenced by StatsDlgProc().

ShowChangeDriveLetter()

void BtrfsVolPropSheet::ShowChangeDriveLetter

(

HWND

hwndDlg

)

Definition at line 1299 of file volpropsheet.cpp.

                                                          {
    wstring t;
    WCHAR modfn[MAX_PATH];
    SHELLEXECUTEINFOW sei;
 
    GetModuleFileNameW(module, modfn, sizeof(modfn) / sizeof(WCHAR));
 
#ifndef __REACTOS__
    t = L"\""s + modfn + L"\",ShowChangeDriveLetter "s + fn;
#else
    t = wstring(L"\"") + modfn + wstring(L"\",ShowChangeDriveLetter ") + fn;
#endif
 
    RtlZeroMemory(&sei, sizeof(sei));
 
    sei.cbSize = sizeof(sei);
    sei.hwnd = hwndDlg;
    sei.lpVerb = L"runas";
    sei.lpFile = L"rundll32.exe";
    sei.lpParameters = t.c_str();
    sei.nShow = SW_SHOW;
    sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
    if (!ShellExecuteExW(&sei))
        throw last_error(GetLastError());
 
    WaitForSingleObject(sei.hProcess, INFINITE);
    CloseHandle(sei.hProcess);
}

Referenced by PropSheetDlgProc().

ShowDevices()

void BtrfsVolPropSheet::ShowDevices

(

HWND

hwndDlg

)

Definition at line 1265 of file volpropsheet.cpp.

                                                {
   DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DEVICES), hwndDlg, stub_DeviceDlgProc, (LPARAM)this);
}

Referenced by PropSheetDlgProc().

ShowScrub()

void BtrfsVolPropSheet::ShowScrub

(

HWND

hwndDlg

)

Definition at line 1269 of file volpropsheet.cpp.

                                              {
    wstring t;
    WCHAR modfn[MAX_PATH];
    SHELLEXECUTEINFOW sei;
 
    GetModuleFileNameW(module, modfn, sizeof(modfn) / sizeof(WCHAR));
 
#ifndef __REACTOS__
    t = L"\""s + modfn + L"\",ShowScrub "s + fn;
#else
    t = wstring(L"\"") + modfn + wstring(L"\",ShowScrub ") + fn;
#endif
 
    RtlZeroMemory(&sei, sizeof(sei));
 
    sei.cbSize = sizeof(sei);
    sei.hwnd = hwndDlg;
    sei.lpVerb = L"runas";
    sei.lpFile = L"rundll32.exe";
    sei.lpParameters = t.c_str();
    sei.nShow = SW_SHOW;
    sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
    if (!ShellExecuteExW(&sei))
        throw last_error(GetLastError());
 
    WaitForSingleObject(sei.hProcess, INFINITE);
    CloseHandle(sei.hProcess);
}

Referenced by PropSheetDlgProc().

ShowStats()

void BtrfsVolPropSheet::ShowStats	(	HWND	hwndDlg,
		uint64_t	devid
	)

Definition at line 958 of file volpropsheet.cpp.

                                                              {
    stats_dev = devid;
 
    DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_DEVICE_STATS), hwndDlg, stub_StatsDlgProc, (LPARAM)this);
}

Referenced by DeviceDlgProc().

ShowUsage()

void BtrfsVolPropSheet::ShowUsage

(

HWND

hwndDlg

)

Definition at line 582 of file volpropsheet.cpp.

                                              {
   DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_VOL_USAGE), hwndDlg, stub_UsageDlgProc, (LPARAM)this);
}

Referenced by PropSheetDlgProc().

StatsDlgProc()

INT_PTR CALLBACK BtrfsVolPropSheet::StatsDlgProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 867 of file volpropsheet.cpp.

                                                                                                      {
    try {
        switch (uMsg) {
            case WM_INITDIALOG:
            {
                WCHAR s[255];
                wstring t;
                btrfs_device *bd, *dev = nullptr;
                int i;
 
                static int stat_ids[] = { IDC_WRITE_ERRS, IDC_READ_ERRS, IDC_FLUSH_ERRS, IDC_CORRUPTION_ERRS, IDC_GENERATION_ERRS };
 
                bd = devices;
 
                while (true) {
                    if (bd->dev_id == stats_dev) {
                        dev = bd;
                        break;
                    }
 
                    if (bd->next_entry > 0)
                        bd = (btrfs_device*)((uint8_t*)bd + bd->next_entry);
                    else
                        break;
                }
 
                if (!dev) {
                    EndDialog(hwndDlg, 0);
                    throw string_error(IDS_CANNOT_FIND_DEVICE);
                }
 
                GetDlgItemTextW(hwndDlg, IDC_DEVICE_ID, s, sizeof(s) / sizeof(WCHAR));
 
                wstring_sprintf(t, s, dev->dev_id);
 
                SetDlgItemTextW(hwndDlg, IDC_DEVICE_ID, t.c_str());
 
                for (i = 0; i < 5; i++) {
                    GetDlgItemTextW(hwndDlg, stat_ids[i], s, sizeof(s) / sizeof(WCHAR));
 
                    wstring_sprintf(t, s, dev->stats[i]);
 
                    SetDlgItemTextW(hwndDlg, stat_ids[i], t.c_str());
                }
 
                SendMessageW(GetDlgItem(hwndDlg, IDC_RESET_STATS), BCM_SETSHIELD, 0, true);
                EnableWindow(GetDlgItem(hwndDlg, IDC_RESET_STATS), !readonly);
 
                break;
            }
 
            case WM_COMMAND:
                switch (HIWORD(wParam)) {
                    case BN_CLICKED:
                        switch (LOWORD(wParam)) {
                            case IDOK:
                            case IDCANCEL:
                                EndDialog(hwndDlg, 0);
                            return true;
 
                            case IDC_RESET_STATS:
                                ResetStats(hwndDlg);
                            return true;
                        }
                    break;
                }
            break;
        }
    } catch (const exception& e) {
        error_message(hwndDlg, e.what());
    }
 
    return false;
}

Referenced by stub_StatsDlgProc().

UsageDlgProc()

INT_PTR CALLBACK BtrfsVolPropSheet::UsageDlgProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 487 of file volpropsheet.cpp.

                                                                                                      {
    try {
        switch (uMsg) {
            case WM_INITDIALOG:
            {
                wstring s;
                int i;
                ULONG usagesize;
                NTSTATUS Status;
                IO_STATUS_BLOCK iosb;
 
                EnableThemeDialogTexture(hwndDlg, ETDT_ENABLETAB);
 
                win_handle h = CreateFileW(fn.c_str(), FILE_TRAVERSE | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                                        OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
 
                if (h != INVALID_HANDLE_VALUE) {
                    btrfs_usage* usage;
 
                    i = 0;
                    usagesize = 1024;
 
                    usage = (btrfs_usage*)malloc(usagesize);
 
                    while (true) {
                        Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_USAGE, nullptr, 0, usage, usagesize);
                        if (Status == STATUS_BUFFER_OVERFLOW) {
                            if (i < 8) {
                                usagesize += 1024;
 
                                free(usage);
                                usage = (btrfs_usage*)malloc(usagesize);
 
                                i++;
                            } else
                                break;
                        } else
                            break;
                    }
 
                    if (!NT_SUCCESS(Status)) {
                        free(usage);
                        break;
                    }
 
                    FormatUsage(hwndDlg, s, usage);
 
                    SetDlgItemTextW(hwndDlg, IDC_USAGE_BOX, s.c_str());
 
                    free(usage);
                }
 
                break;
            }
 
            case WM_COMMAND:
                switch (HIWORD(wParam)) {
                    case BN_CLICKED:
                        switch (LOWORD(wParam)) {
                            case IDOK:
                            case IDCANCEL:
                                EndDialog(hwndDlg, 0);
                            return true;
 
                            case IDC_USAGE_REFRESH:
                                RefreshUsage(hwndDlg);
                            return true;
                        }
                    break;
                }
            break;
        }
    } catch (const exception& e) {
        error_message(hwndDlg, e.what());
    }
 
    return false;
}

Referenced by stub_UsageDlgProc().

Member Data Documentation

balance

BtrfsBalance* BtrfsVolPropSheet::balance

Definition at line 102 of file volpropsheet.h.

Referenced by BtrfsVolPropSheet(), Initialize(), PropSheetDlgProc(), and ~BtrfsVolPropSheet().

devices

btrfs_device* BtrfsVolPropSheet::devices

Definition at line 100 of file volpropsheet.h.

Referenced by BtrfsVolPropSheet(), DeviceDlgProc(), FormatUsage(), Initialize(), PropSheetDlgProc(), RefreshDevList(), RefreshUsage(), ResetStats(), StatsDlgProc(), and ~BtrfsVolPropSheet().

fn

wstring BtrfsVolPropSheet::fn

private

Definition at line 111 of file volpropsheet.h.

Referenced by DeviceDlgProc(), Initialize(), RefreshDevList(), RefreshUsage(), ResetStats(), ShowChangeDriveLetter(), ShowScrub(), and UsageDlgProc().

ignore

bool BtrfsVolPropSheet::ignore

private

Definition at line 108 of file volpropsheet.h.

Referenced by AddPages(), BtrfsVolPropSheet(), Initialize(), and RefreshUsage().

readonly

bool BtrfsVolPropSheet::readonly

Definition at line 101 of file volpropsheet.h.

Referenced by DeviceDlgProc(), PropSheetDlgProc(), and StatsDlgProc().

refcount

LONG BtrfsVolPropSheet::refcount

private

Definition at line 107 of file volpropsheet.h.

Referenced by AddRef(), BtrfsVolPropSheet(), and Release().

stats_dev

uint64_t BtrfsVolPropSheet::stats_dev

private

Definition at line 112 of file volpropsheet.h.

Referenced by ResetStats(), ShowStats(), and StatsDlgProc().

stgm

STGMEDIUM BtrfsVolPropSheet::stgm

private

Definition at line 109 of file volpropsheet.h.

Referenced by Initialize(), and ~BtrfsVolPropSheet().

stgm_set

bool BtrfsVolPropSheet::stgm_set

private

Definition at line 110 of file volpropsheet.h.

Referenced by BtrfsVolPropSheet(), Initialize(), and ~BtrfsVolPropSheet().

uuid

BTRFS_UUID BtrfsVolPropSheet::uuid

Definition at line 103 of file volpropsheet.h.

Referenced by PropSheetDlgProc().

uuid_set

bool BtrfsVolPropSheet::uuid_set

Definition at line 104 of file volpropsheet.h.

Referenced by Initialize(), and PropSheetDlgProc().

---

The documentation for this class was generated from the following files:

• dll/shellext/shellbtrfs/volpropsheet.h
• dll/shellext/shellbtrfs/volpropsheet.cpp