/*
 * CiderPress
 * Copyright (C) 2007 by faddenSoft, LLC.  All Rights Reserved.
 * See the file LICENSE for distribution terms.
 */
/*
 * Allow the user to select a disk volume.
 */
#include "stdafx.h"
#include "OpenVolumeDialog.h"
#include "Main.h"
#include "../diskimg/Win32Extra.h"  // need disk geometry calls
#include "../diskimg/ASPI.h"


BEGIN_MESSAGE_MAP(OpenVolumeDialog, CDialog)
    ON_COMMAND(IDHELP, OnHelp)
    //ON_NOTIFY(NM_CLICK, IDC_VOLUME_LIST, OnListClick)
    ON_NOTIFY(LVN_ITEMCHANGED, IDC_VOLUME_LIST, OnListChange)
    ON_NOTIFY(NM_DBLCLK, IDC_VOLUME_LIST, OnListDblClick)
    ON_CBN_SELCHANGE(IDC_VOLUME_FILTER, OnVolumeFilterSelChange)
END_MESSAGE_MAP()


BOOL OpenVolumeDialog::OnInitDialog(void)
{
    /*
     * Sets up the list of drives.
     */

    CDialog::OnInitDialog();        // do any DDX init stuff
    const Preferences* pPreferences = GET_PREFERENCES();
    long defaultFilter;

    /* highlight/select entire line, not just filename */
    CListCtrl* pListView = (CListCtrl*) GetDlgItem(IDC_VOLUME_LIST);
    ASSERT(pListView != NULL);

    ListView_SetExtendedListViewStyleEx(pListView->m_hWnd,
        LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);

    /* disable the OK button until they click on something */
    CButton* pButton = (CButton*) GetDlgItem(IDOK);
    ASSERT(pButton != NULL);

    pButton->EnableWindow(FALSE);

    /* if the read-only state is fixed, don't let them change it */
    if (!fAllowROChange) {
        CButton* pButton;
        pButton = (CButton*) GetDlgItem(IDC_OPENVOL_READONLY);
        ASSERT(pButton != NULL);
        pButton->EnableWindow(FALSE);
    }

    /* prep the combo box */
    CComboBox* pCombo = (CComboBox*) GetDlgItem(IDC_VOLUME_FILTER);
    ASSERT(pCombo != NULL);
    defaultFilter = pPreferences->GetPrefLong(kPrVolumeFilter);
    if (defaultFilter >= kBoth && defaultFilter <= kPhysical)
        pCombo->SetCurSel(defaultFilter);
    else {
        LOGI("GLITCH: invalid defaultFilter in prefs (%d)", defaultFilter);
        pCombo->SetCurSel(kLogical);
    }

    /* two columns */
    CRect rect;
    pListView->GetClientRect(&rect);
    int width;

    width = pListView->GetStringWidth(L"XXVolume or Device NameXXmmmmmm");
    pListView->InsertColumn(0, L"Volume or Device Name", LVCFMT_LEFT, width);
    pListView->InsertColumn(1, L"Remarks", LVCFMT_LEFT,
        rect.Width() - width - ::GetSystemMetrics(SM_CXVSCROLL));

    // Load the drive list.
    LoadDriveList();

    // Kluge the physical drive 0 stuff.
    DiskImg::SetAllowWritePhys0(GET_PREFERENCES()->GetPrefBool(kPrOpenVolumePhys0));

    return TRUE;
}

void OpenVolumeDialog::DoDataExchange(CDataExchange* pDX)
{
    DDX_Check(pDX, IDC_OPENVOL_READONLY, fReadOnly);
    LOGI("DoDataExchange: fReadOnly==%d", fReadOnly);
}

void OpenVolumeDialog::LoadDriveList(void)
{
    CWaitCursor waitc;
    CComboBox* pCombo;
    CListCtrl* pListView;
    int itemIndex = 0;
    int filterSelection;

    pListView = (CListCtrl*) GetDlgItem(IDC_VOLUME_LIST);
    ASSERT(pListView != NULL);
    pCombo = (CComboBox*) GetDlgItem(IDC_VOLUME_FILTER);
    ASSERT(pCombo != NULL);

    pListView->DeleteAllItems();

    /*
     * Load the logical and physical drive sets as needed.  Do the "physical"
     * set first because it's usually what we want.
     */
    filterSelection = pCombo->GetCurSel();
    if (filterSelection == kPhysical || filterSelection == kBoth)
        LoadPhysicalDriveList(pListView, &itemIndex);
    if (filterSelection == kLogical || filterSelection == kBoth)
        LoadLogicalDriveList(pListView, &itemIndex);
}

bool OpenVolumeDialog::LoadLogicalDriveList(CListCtrl* pListView, int* pItemIndex)
{
    DWORD drivesAvailable;
    bool isWin9x = IsWin9x();
    int itemIndex = *pItemIndex;

    ASSERT(pListView != NULL);

    drivesAvailable = GetLogicalDrives();
    if (drivesAvailable == 0) {
        LOGI("GetLogicalDrives failed, err=0x%08lx", drivesAvailable);
        return false;
    }
    LOGI("GetLogicalDrives returned 0x%08lx", drivesAvailable);

    // SetErrorMode(SEM_FAILCRITICALERRORS)

    /* run through the list, from A-Z */
    int i;
    for (i = 0; i < kMaxLogicalDrives; i++) {
        fVolumeInfo[i].driveType = DRIVE_UNKNOWN;

        if ((drivesAvailable >> i) & 0x01) {
            WCHAR driveName[] = L"_:\\";
            driveName[0] = 'A' + i;

            unsigned int driveType;
            const WCHAR* driveTypeComment = NULL;
            BOOL result;

            driveType = fVolumeInfo[i].driveType = GetDriveType(driveName);
            switch (driveType) {
            case DRIVE_UNKNOWN:
                // The drive type cannot be determined.
                break;
            case DRIVE_NO_ROOT_DIR:
                // The root path is invalid. For example, no volume is mounted at the path.
                break;
            case DRIVE_REMOVABLE:
                // The disk can be removed from the drive.
                driveTypeComment = L"Removable";
                break;
            case DRIVE_FIXED:
                // The disk cannot be removed from the drive.
                driveTypeComment = L"Local Disk";
                break;
            case DRIVE_REMOTE:
                // The drive is a remote (network) drive.
                driveTypeComment = L"Network";
                break;
            case DRIVE_CDROM:
                // The drive is a CD-ROM drive.
                driveTypeComment = L"CD-ROM";
                break;
            case DRIVE_RAMDISK:
                // The drive is a RAM disk.
                break;
            default:
                LOGI("UNKNOWN DRIVE TYPE %d", driveType);
                break;
            }

            if (driveType == DRIVE_CDROM && !DiskImgLib::Global::GetHasSPTI()) {
                /* use "physical" device via ASPI instead */
                LOGI("Not including CD-ROM '%ls' in logical drive list",
                    driveName);
                continue;
            }

            WCHAR volNameBuf[256];
            WCHAR fsNameBuf[64];
            const WCHAR* errorComment = NULL;
            //DWORD fsFlags;
            CString entryName, entryRemarks;

            result = ::GetVolumeInformation(driveName, volNameBuf,
                NELEM(volNameBuf), NULL, NULL, NULL /*&fsFlags*/, fsNameBuf,
                NELEM(fsNameBuf));
            if (result == FALSE) {
                DWORD err = GetLastError();
                if (err == ERROR_UNRECOGNIZED_VOLUME) {
                    // Win2K: media exists but format not recognized
                    errorComment = L"Non-Windows format";
                } else if (err == ERROR_NOT_READY) {
                    // Win2K: device exists but no media loaded
                    if (isWin9x) {
                        LOGI("Not showing drive '%ls': not ready",
                            driveName);
                        continue;   // safer not to show it
                    } else
                        errorComment = L"Not ready";
                } else if (err == ERROR_PATH_NOT_FOUND /*Win2K*/ ||
                           err == ERROR_INVALID_DATA /*Win98*/)
                {
                    // Win2K/Win98: device letter not in use
                    LOGI("GetVolumeInformation '%ls': nothing there",
                        driveName);
                    continue;
                } else if (err == ERROR_INVALID_PARAMETER) {
                    // Win2K: device is already open
                    //LOGI("GetVolumeInformation '%ls': currently open??",
                    //  driveName);
                    errorComment = L"(currently open?)";
                    //continue;
                } else if (err == ERROR_ACCESS_DENIED) {
                    // Win2K: disk is open no-read-sharing elsewhere
                    errorComment = L"(already open read-write)";
                } else if (err == ERROR_GEN_FAILURE) {
                    // Win98: floppy format not recognzied
                    // --> we don't want to access ProDOS floppies via A: in
                    //     Win98, so we skip it here
                    LOGI("GetVolumeInformation '%ls': general failure",
                        driveName);
                    continue;
                } else if (err == ERROR_INVALID_FUNCTION) {
                    // Win2K: CD-ROM with HFS
                    if (driveType == DRIVE_CDROM)
                        errorComment = L"Non-Windows format";
                    else
                        errorComment = L"(invalid disc?)";
                } else {
                    LOGI("GetVolumeInformation '%ls' failed: %ld",
                        driveName, GetLastError());
                    continue;
                }
                ASSERT(errorComment != NULL);

                entryName.Format(L"(%c:)", 'A' + i);
                if (driveTypeComment != NULL)
                    entryRemarks.Format(L"%ls - %ls", driveTypeComment,
                        errorComment);
                else
                    entryRemarks.Format(L"%ls", errorComment);
            } else {
                entryName.Format(L"%ls (%c:)", volNameBuf, 'A' + i);
                if (driveTypeComment != NULL)
                    entryRemarks.Format(L"%ls", driveTypeComment);
                else
                    entryRemarks = "";
            }

            pListView->InsertItem(itemIndex, entryName);
            pListView->SetItemText(itemIndex, 1, entryRemarks);
            pListView->SetItemData(itemIndex, (DWORD) i + 'A');
//LOGI("%%%% added logical %d", itemIndex);
            itemIndex++;
        } else {
            LOGI(" (drive %c not available)", i + 'A');
        }
    }

    *pItemIndex = itemIndex;

    return true;
}

bool OpenVolumeDialog::LoadPhysicalDriveList(CListCtrl* pListView, int* pItemIndex)
{
    /*
     * I don't see a clever way to do this in Win2K except to open the first 8
     * or so devices and see what happens.
     *
     * Win9x isn't much better, though you can be reasonably confident that there
     * are at most 4 floppy drives and 4 hard drives.
     *
     * TODO: check again for a better way
     */

    bool isWin9x = IsWin9x();
    int itemIndex = *pItemIndex;
    int i;

    if (isWin9x) {
        // fairly arbitrary choices
        const int kMaxFloppies = 4;
        const int kMaxHardDrives = 8;

        for (i = 0; i < kMaxFloppies; i++) {
            CString driveName, remark;
            bool result;

            result = HasPhysicalDriveWin9x(i, &remark);
            if (result) {
                driveName.Format(L"Floppy disk %d", i);
                pListView->InsertItem(itemIndex, driveName);
                pListView->SetItemText(itemIndex, 1, remark);
                pListView->SetItemData(itemIndex, (DWORD) i);
//LOGI("%%%% added floppy %d", itemIndex);
                itemIndex++;
            }
        }
        for (i = 0; i < kMaxHardDrives; i++) {
            CString driveName, remark;
            bool result;

            result = HasPhysicalDriveWin9x(i + 128, &remark);
            if (result) {
                driveName.Format(L"Hard drive %d", i);
                pListView->InsertItem(itemIndex, driveName);
                pListView->SetItemText(itemIndex, 1, remark);
                pListView->SetItemData(itemIndex, (DWORD) i + 128);
//LOGI("%%%% added HD %d", itemIndex);
                itemIndex++;
            }
        }
    } else {
        for (i = 0; i < kMaxPhysicalDrives; i++) {
            CString driveName, remark;
            bool result;

            result = HasPhysicalDriveWin2K(i + 128, &remark);
            if (result) {
                driveName.Format(L"Physical disk %d", i);
                pListView->InsertItem(itemIndex, driveName);
                pListView->SetItemText(itemIndex, 1, remark);
                pListView->SetItemData(itemIndex, (DWORD) i + 128); // HD volume
                itemIndex++;
            }
        }
    }

    if (DiskImgLib::Global::GetHasASPI()) {
        LOGI("IGNORING ASPI");
#if 0   // can we remove this?
        DIError dierr;
        DiskImgLib::ASPI* pASPI = DiskImgLib::Global::GetASPI();
        ASPIDevice* deviceArray = NULL;
        int numDevices;

        dierr = pASPI->GetAccessibleDevices(
                    ASPI::kDevMaskCDROM | ASPI::kDevMaskHardDrive,
                    &deviceArray, &numDevices);
        if (dierr == kDIErrNone) {
            LOGI("Adding %d ASPI CD-ROM devices", numDevices);
            for (i = 0; i < numDevices; i++) {
                CString driveName, remark;
                CString addr, vendor, product;
                DWORD aspiAddr;

                addr.Format("ASPI %d:%d:%d",
                    deviceArray[i].GetAdapter(),
                    deviceArray[i].GetTarget(),
                    deviceArray[i].GetLun());
                vendor = deviceArray[i].GetVendorID();
                vendor.TrimRight();
                product = deviceArray[i].GetProductID();
                product.TrimRight();

                driveName.Format("%s %s", vendor, product);
                if (deviceArray[i].GetDeviceType() == ASPIDevice::kTypeCDROM)
                    remark = "CD-ROM";
                else if (deviceArray[i].GetDeviceType() == ASPIDevice::kTypeDASD)
                    remark = "Direct-access device";
                if (!deviceArray[i].GetDeviceReady())
                    remark += " - Not ready";

                aspiAddr =  (DWORD) 0xaa << 24 |
                            (DWORD) deviceArray[i].GetAdapter() << 16 |
                            (DWORD) deviceArray[i].GetTarget() << 8 |
                            (DWORD) deviceArray[i].GetLun();
                //LOGI("ADDR for '%s' is 0x%08lx",
                //  (const char*) driveName, aspiAddr);

                pListView->InsertItem(itemIndex, driveName);
                pListView->SetItemText(itemIndex, 1, remark);
                pListView->SetItemData(itemIndex, aspiAddr);
                itemIndex++;
            }
        }

        delete[] deviceArray;
#endif
    }

    *pItemIndex = itemIndex;
    return true;
}

bool OpenVolumeDialog::HasPhysicalDriveWin9x(int unit, CString* pRemark)
{
    HANDLE handle = NULL;
    const int VWIN32_DIOC_DOS_INT13 = 4;
    const int CARRY_FLAG = 1;
    BOOL result;
    typedef struct _DIOC_REGISTERS {
        DWORD reg_EBX;
        DWORD reg_EDX;
        DWORD reg_ECX;
        DWORD reg_EAX;
        DWORD reg_EDI;
        DWORD reg_ESI;
        DWORD reg_Flags;
    } DIOC_REGISTERS, *PDIOC_REGISTERS;
    DIOC_REGISTERS reg = {0};
    DWORD lastError, cb;
    unsigned char buf[512];

    if (unit > 4)
        return false;   // floppy drives only

    handle = CreateFile(L"\\\\.\\vwin32", 0, 0, NULL,
                OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE, NULL);
    if (handle == INVALID_HANDLE_VALUE) {
        LOGI(" Unable to open vwin32: %ld", ::GetLastError());
        return false;
    }

#if 0   // didn't do what I wanted
    reg.reg_EAX = MAKEWORD(0, 0x00);    // func 0x00 == reset controller
    reg.reg_EDX = MAKEWORD(unit, 0);    // specify driver
    result = DeviceIoControl(handle, VWIN32_DIOC_DOS_INT13, &reg,
                sizeof(reg), &reg, sizeof(reg), &cb, 0);
    LOGI("  DriveReset(drive=0x%02x) result=%d carry=%d",
        unit, result, reg.reg_Flags & CARRY_FLAG);
#endif

    reg.reg_EAX = MAKEWORD(1, 0x02);    // read 1 sector
    reg.reg_EBX = (DWORD) buf;
    reg.reg_ECX = MAKEWORD(1, 0);       // sector 0 (+1), cylinder 0
    reg.reg_EDX = MAKEWORD(unit, 0);    // head

    result = DeviceIoControl(handle, VWIN32_DIOC_DOS_INT13, &reg,
                sizeof(reg) /*bytes*/, &reg, sizeof(reg) /*bytes*/, &cb, 0);
    lastError = GetLastError();
    ::CloseHandle(handle);

    if (result == 0 || (reg.reg_Flags & CARRY_FLAG)) {
        int ah = HIBYTE(reg.reg_EAX);
        LOGI(" DevIoCtrl(unit=%02xh) failed: result=%d lastErr=%d Flags=0x%08lx",
            unit, result, lastError, reg.reg_Flags);
        LOGI("   AH=%d (EAX=0x%08lx) byte=0x%02x", ah, reg.reg_EAX, buf[0]);
        if (ah != 1) {
            // failure code 1 means "invalid parameter", drive doesn't exist
            // mine returns 128, "timeout", when no disk is in the drive
            *pRemark = "Not ready";
            return true;
        } else
            return false;
    }

    *pRemark = "Removable";

    return true;
}

bool OpenVolumeDialog::HasPhysicalDriveWin2K(int unit, CString* pRemark)
{
    HANDLE hDevice;         // handle to the drive to be examined 
    DISK_GEOMETRY dg;       // disk drive geometry structure
    DISK_GEOMETRY_EX dge;   // extended geometry request buffer
    BOOL result;            // results flag
    DWORD junk;             // discard results
    LONGLONG diskSize;      // size of the drive, in bytes
    CString fileName;
    DWORD err;

    /*
     * See if the drive is there.
     */
    ASSERT(unit >= 128 && unit < 160);      // arbitrary max
    fileName.Format(L"\\\\.\\PhysicalDrive%d", unit - 128);

    hDevice = ::CreateFile(fileName,  // drive to open
                0,                  // no access to the drive
                FILE_SHARE_READ | FILE_SHARE_WRITE, // share mode
                NULL,               // default security attributes
                OPEN_EXISTING,      // disposition
                0,                  // file attributes
                NULL);              // do not copy file attributes

    if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
        return false;

    /*
     * Try to get the drive geometry.  First try with the fancy WinXP call,
     * then fall back to the Win2K call if it doesn't exist.
     */
    result = ::DeviceIoControl(hDevice,
                IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
                NULL, 0,                // input buffer
                &dge, sizeof(dge),      // output buffer + size in bytes
                &junk,                  // # bytes returned
                (LPOVERLAPPED) NULL);   // synchronous I/O
    if (result) {
        diskSize = dge.DiskSize.QuadPart;
        LOGI(" EX results for device %02xh", unit);
        LOGI("  Disk size = %I64d (bytes) = %I64d (MB)",
            diskSize, diskSize / (1024*1024));
        if (diskSize > 1024*1024*1024)
            pRemark->Format(L"Size is %.2fGB",
                (double) diskSize / (1024.0 * 1024.0 * 1024.0));
        else
            pRemark->Format(L"Size is %.2fMB",
                (double) diskSize / (1024.0 * 1024.0));
    } else {
        // Win2K shows ERROR_INVALID_FUNCTION or ERROR_NOT_SUPPORTED
        LOGI("IOCTL_DISK_GET_DRIVE_GEOMETRY_EX failed, error was %ld",
            GetLastError());
        result = ::DeviceIoControl(hDevice, // device to be queried
                    IOCTL_DISK_GET_DRIVE_GEOMETRY,  // operation to perform
                    NULL, 0,                // no input buffer
                    &dg, sizeof(dg),        // output buffer + size in bytes
                    &junk,                  // # bytes returned
                    (LPOVERLAPPED) NULL);   // synchronous I/O

        if (result) {
            LOGI(" Results for device %02xh", unit);
            LOGI("  Cylinders = %I64d", dg.Cylinders.QuadPart);
            LOGI("  Tracks per cylinder = %ld", (ULONG) dg.TracksPerCylinder);
            LOGI("  Sectors per track = %ld", (ULONG) dg.SectorsPerTrack);
            LOGI("  Bytes per sector = %ld", (ULONG) dg.BytesPerSector);

            diskSize = dg.Cylinders.QuadPart * (ULONG)dg.TracksPerCylinder *
                        (ULONG)dg.SectorsPerTrack * (ULONG)dg.BytesPerSector;
            LOGI("Disk size = %I64d (bytes) = %I64d (MB)", diskSize,
                    diskSize / (1024 * 1024));
            if (diskSize > 1024*1024*1024)
                pRemark->Format(L"Size is %.2fGB",
                    (double) diskSize / (1024.0 * 1024.0 * 1024.0));
            else
                pRemark->Format(L"Size is %.2fMB",
                    (double) diskSize / (1024.0 * 1024.0));
        } else {
            err = GetLastError();
        }
    }

    ::CloseHandle(hDevice);

    if (!result) {
        LOGI("DeviceIoControl(IOCTL_DISK_GET_DRIVE_GEOMETRY) failed (err=%ld)",
            err);
        *pRemark = "Not ready";
    }

    return true;
}

void OpenVolumeDialog::OnListChange(NMHDR*, LRESULT* pResult)
{
    CListCtrl* pListView = (CListCtrl*) GetDlgItem(IDC_VOLUME_LIST);
    CButton* pButton = (CButton*) GetDlgItem(IDOK);
    pButton->EnableWindow(pListView->GetSelectedCount() != 0);
    //LOGI("ENABLE %d", pListView->GetSelectedCount() != 0);

    *pResult = 0;
}

void OpenVolumeDialog::OnListDblClick(NMHDR* pNotifyStruct, LRESULT* pResult)
{
    CListCtrl* pListView = (CListCtrl*) GetDlgItem(IDC_VOLUME_LIST);
    CButton* pButton = (CButton*) GetDlgItem(IDOK);

    if (pListView->GetSelectedCount() != 0) {
        pButton->EnableWindow();
        OnOK();
    }

    *pResult = 0;
}

void OpenVolumeDialog::OnVolumeFilterSelChange(void)
{
    CComboBox* pCombo = (CComboBox*) GetDlgItem(IDC_VOLUME_FILTER);
    ASSERT(pCombo != NULL);
    LOGI("+++ SELECTION IS NOW %d", pCombo->GetCurSel());
    LoadDriveList();
}

void OpenVolumeDialog::OnOK(void)
{
    /*
     * Figure out the (zero-based) drive letter.
     */
    CListCtrl* pListView = (CListCtrl*) GetDlgItem(IDC_VOLUME_LIST);
    ASSERT(pListView != NULL);

    if (pListView->GetSelectedCount() != 1) {
        CString msg, failed;
        CheckedLoadString(&failed, IDS_FAILED);
        CheckedLoadString(&msg, IDS_VOLUME_SELECT_ONE);
        MessageBox(msg, failed, MB_OK);
        return;
    }

    POSITION posn;
    posn = pListView->GetFirstSelectedItemPosition();
    if (posn == NULL) {
        ASSERT(false);
        return;
    }
    int num = pListView->GetNextSelectedItem(posn);
    DWORD driveID = pListView->GetItemData(num);
    UINT formatID = 0;

    if (HIBYTE(HIWORD(driveID)) == 0xaa) {
        // TODO: remove this?
        fChosenDrive.Format(L"%hs%d:%d:%d\\",
            DiskImgLib::kASPIDev,
            LOBYTE(HIWORD(driveID)),
            HIBYTE(LOWORD(driveID)),
            LOBYTE(LOWORD(driveID)));
        //ForceReadOnly(true);
    } else if (driveID >= 'A' && driveID <= 'Z') {
        /*
         * Do we want to let them do this?  We show some logical drives
         * that we don't want them to actually use.
         */
        switch (fVolumeInfo[driveID-'A'].driveType) {
        case DRIVE_REMOVABLE:
        case DRIVE_FIXED:
            break;              // allow
        case DRIVE_CDROM:       //formatID = IDS_VOLUME_NO_CDROM;
            ForceReadOnly(true);
            break;
        case DRIVE_REMOTE:      formatID = IDS_VOLUME_NO_REMOTE;
            break;
        case DRIVE_RAMDISK:     formatID = IDS_VOLUME_NO_RAMDISK;
            break;
        case DRIVE_UNKNOWN:
        case DRIVE_NO_ROOT_DIR:
        default:                formatID = IDS_VOLUME_NO_GENERIC;
            break;
        }

        fChosenDrive.Format(L"%c:\\", driveID);
    } else if ((driveID >= 0 && driveID < 4) ||
               (driveID >= 0x80 && driveID < 0x88))
    {
        fChosenDrive.Format(L"%02x:\\", driveID);
    } else {
        ASSERT(false);
        return;
    }

    if (formatID != 0) {
        CString msg, notAllowed;

        CheckedLoadString(&notAllowed, IDS_NOT_ALLOWED);
        CheckedLoadString(&msg, formatID);
        MessageBox(msg, notAllowed, MB_OK);
    } else {
        Preferences* pPreferences = GET_PREFERENCES_WR();
        CComboBox* pCombo = (CComboBox*) GetDlgItem(IDC_VOLUME_FILTER);
        pPreferences->SetPrefLong(kPrVolumeFilter, pCombo->GetCurSel());
        LOGI("SETTING PREF TO %ld", pCombo->GetCurSel());

        CDialog::OnOK();
    }
}

void OpenVolumeDialog::ForceReadOnly(bool readOnly) const
{
    CButton* pButton = (CButton*) GetDlgItem(IDC_OPENVOL_READONLY);
    ASSERT(pButton != NULL);

    if (readOnly)
        pButton->SetCheck(BST_CHECKED);
    else
        pButton->SetCheck(BST_UNCHECKED);
    LOGW("FORCED READ ONLY %d", readOnly);
}