vfdguiut.c

Go to the documentation of this file.

/*
    vfdguiut.c
 
    Virtual Floppy Drive for Windows
    Driver control library
    open / close / format GUI utility functions
 
    Copyright (c) 2003-2005 Ken Kato
*/
 
#ifdef __cplusplus
#pragma message(__FILE__": Compiled as C++ for testing purpose.")
#endif  // __cplusplus
 
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
 
#include "vfdtypes.h"
#include "vfdapi.h"
#include "vfdlib.h"
#ifndef __REACTOS__
#include "vfdmsg.h"
#else
#include "vfdmsg_lib.h"
#endif
#include "vfdguirc.h"
 
//
//  message box constants added since Win2K
//
 
#ifndef MB_CANCELTRYCONTINUE
#define MB_CANCELTRYCONTINUE    0x00000006L
#endif
 
#ifndef IDTRYAGAIN
#define IDTRYAGAIN              10
#endif
 
#ifndef IDCONTINUE
#define IDCONTINUE              11
#endif
 
//
//  local funcitons
//
static PSTR FormatSizeBytes(ULONG size, PSTR buf)
{
    ULONG comma = 1;
    int len;
 
    while ((comma * 1000) < size) {
        comma *= 1000;
    }
 
    len = sprintf(buf, "%lu", size / comma);
 
    while (comma > 1) {
        size %= comma;
        comma /= 1000;
        len += sprintf(buf + len, ",%03lu", size / comma);
    }
 
    return buf;
}
 
static PSTR FormatSizeUnits(ULONG size, PSTR buf)
{
    static const char *name[3] = {
        " KB", " MB", " GB"
    };
    int unit;
    double dsize;
 
    if (size < 1000) {
#ifndef __REACTOS__
        sprintf(buf, "%u", size);
#else
        sprintf(buf, "%lu", size);
#endif
        return buf;
    }
 
    dsize = size;
    dsize /= 1024;
    unit = 0;
 
    while (unit < 2 && dsize >= 1000) {
        dsize /= 1000;
        unit++;
    }
 
    if (dsize < 10) {
        sprintf(buf, "%3.2f%s", dsize, name[unit]);
    }
    else if (dsize < 100) {
        sprintf(buf, "%3.1f%s", dsize, name[unit]);
    }
    else if (dsize < 1000) {
        sprintf(buf, "%3.0f%s", dsize, name[unit]);
    }
    else {
        FormatSizeBytes((ULONG)dsize, buf);
        strcat(buf, name[unit]);
    }
 
    return buf;
}
 
//
//  Close the current image
//
DWORD WINAPI VfdGuiClose(
    HWND            hParent,    //  parent window
    ULONG           nDevice)    //  device number
{
    HANDLE          hDevice;
    SAVE_PARAM      param;
    CHAR            path[MAX_PATH];
    HCURSOR         hourglass;
    DWORD           ret;
    int             reply;
 
    VFDTRACE(0, ("VfdGuiClose()\n"));
 
    hDevice = VfdOpenDevice(nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }
 
    //  get current image information
 
    ret = VfdGetImageInfo(
        hDevice,
        path,
        &param.DiskType,
        &param.MediaType,
        &param.MediaFlags,
        &param.FileType,
        &param.ImageSize);
 
    if (ret != ERROR_SUCCESS) {
        CloseHandle(hDevice);
        return ret;
    }
 
    param.hDevice = hDevice;
    param.ImageName = path;
 
    //  check if RAM image is modified
 
    if (param.MediaFlags & VFD_FLAG_DATA_MODIFIED) {
        PSTR msg = ModuleMessage(MSG_MEDIA_MODIFIED);
 
        for (;;) {
            reply = MessageBox(hParent, msg ? msg : "save?",
                VFD_MSGBOX_TITLE, MB_ICONQUESTION | MB_YESNOCANCEL);
 
            if (reply != IDYES) {
                break;
            }
 
            if (GuiSaveParam(hParent, &param) == ERROR_SUCCESS) {
                break;
            }
        }
 
        if (msg) {
            LocalFree(msg);
        }
 
        if (reply == IDCANCEL) {
            CloseHandle(hDevice);
            return ERROR_CANCELLED;
        }
    }
 
    //  close the image
 
    hourglass = LoadCursor(NULL, IDC_WAIT);
 
    for (;;) {
 
        //  show the hourglass cursor
 
        HCURSOR original = SetCursor(hourglass);
 
        //  close the current image
 
        ret = VfdCloseImage(hDevice, FALSE);
 
        //  restore the original cursor
 
        SetCursor(original);
 
        if (ret != ERROR_ACCESS_DENIED) {
            //  success or errors other than access denied
            break;
        }
 
        if (IS_WINDOWS_NT()) {
 
            //  Windows NT -- cannot force close
            //  show retry / cancel message box
 
            PSTR msg = ModuleMessage(MSG_UNMOUNT_FAILED);
 
            reply = MessageBox(
                hParent, msg ? msg : "retry", VFD_MSGBOX_TITLE,
                MB_ICONEXCLAMATION | MB_RETRYCANCEL);
 
            if (msg) {
                LocalFree(msg);
            }
        }
        else {
 
            //  Windows 2000 and later -- possible to force
            //  show cancel / retry / continue message box
 
            PSTR msg = ModuleMessage(MSG_UNMOUNT_CONFIRM);
 
            reply = MessageBox(
                hParent, msg ? msg : "retry", VFD_MSGBOX_TITLE,
                MB_ICONEXCLAMATION | MB_CANCELTRYCONTINUE);
 
            if (msg) {
                LocalFree(msg);
            }
 
            if (reply == IDCONTINUE) {
 
                //  try forced close
 
                ret = VfdCloseImage(hDevice, TRUE);
            }
        }
 
        if (reply == IDCANCEL) {
            ret = ERROR_CANCELLED;
            break;
        }
        else if (reply == IDCONTINUE) {
 
            //  try forced close
 
            ret = VfdCloseImage(hDevice, TRUE);
            break;
        }
    }
 
    CloseHandle(hDevice);
 
    return ret;
}
 
//
//  Format the current media
//
DWORD WINAPI VfdGuiFormat(
    HWND            hParent,    //  parent window
    ULONG           nDevice)    //  device number
{
    HANDLE          hDevice;
    ULONG           ret;
    PSTR            msg;
 
    msg = ModuleMessage(MSG_FORMAT_WARNING);
 
    ret = MessageBox(hParent,
        msg ? msg : "Format?",
        VFD_MSGBOX_TITLE,
        MB_ICONEXCLAMATION | MB_OKCANCEL);
 
    if (msg) {
        LocalFree(msg);
    }
 
    if (ret == IDCANCEL) {
        MessageBox(hParent,
            SystemMessage(ERROR_CANCELLED),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
 
        return ERROR_CANCELLED;
    }
 
    hDevice = VfdOpenDevice(nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        ret = GetLastError();
    }
    else {
        HCURSOR original;
 
retry:
        original = SetCursor(LoadCursor(NULL, IDC_WAIT));
 
        ret = VfdDismountVolume(hDevice, FALSE);
 
        if (ret == ERROR_ACCESS_DENIED) {
            PSTR msg;
            int reply;
 
            SetCursor(original);
 
            msg = ModuleMessage(MSG_UNMOUNT_CONFIRM);
 
            reply = MessageBox(
                hParent, msg ? msg : "retry", VFD_MSGBOX_TITLE,
                MB_ICONEXCLAMATION | MB_CANCELTRYCONTINUE);
 
            if (msg) {
                LocalFree(msg);
            }
 
            if (reply == IDRETRY) {
                goto retry;
            }
            else if (reply == IDCANCEL) {
                ret = ERROR_CANCELLED;
            }
            else {
                VfdDismountVolume(hDevice, TRUE);
                ret = ERROR_SUCCESS;
            }
        }
 
        if (ret == ERROR_SUCCESS) {
            ret = VfdFormatMedia(hDevice);
        }
 
        SetCursor(original);
 
        CloseHandle(hDevice);
    }
 
    MessageBox(hParent,
        SystemMessage(ret),
        VFD_MSGBOX_TITLE,
        ret == ERROR_SUCCESS ? MB_ICONINFORMATION : MB_ICONSTOP);
 
    return ret;
}
 
//
//  Set a text to a dialog control
//
void SetControlText(
    HWND            hWnd,
    UINT            nCtrl,
    DWORD           nMsg)
{
    PSTR p = NULL;
 
    if (nMsg) {
        p = ModuleMessage(nMsg);
    }
 
    if (nCtrl) {
        SetDlgItemText(hWnd, nCtrl, p);
    }
    else {
        SetWindowText(hWnd, p);
    }
 
    if (p) {
        LocalFree(p);
    }
}
 
//
//  Make file description text
//
void WINAPI VfdMakeFileDesc(
    PSTR            pBuffer,
    ULONG           nBufSize,
    VFD_FILETYPE    nFileType,
    ULONG           nFileSize,
    DWORD           nFileAttr)
{
    PSTR            type_str;
    PSTR            size_str;
    PSTR            attr_ro;
    PSTR            attr_enc;
    PSTR            attr_cmp;
 
    ZeroMemory(pBuffer, nBufSize);
 
    switch (nFileType) {
    case VFD_FILETYPE_RAW:
        type_str = ModuleMessage(MSG_FILETYPE_RAW);
        break;
 
    case VFD_FILETYPE_ZIP:
        type_str = ModuleMessage(MSG_FILETYPE_ZIP);
        break;
 
    default:
        type_str = NULL;
    }
 
    if (nFileSize == INVALID_FILE_SIZE) {
        size_str = ModuleMessage(MSG_DESC_NEW_FILE);
    }
    else {
        CHAR buf[20], buf2[20];
        size_str = ModuleMessage(MSG_DESC_FILESIZE, 
            FormatSizeBytes(nFileSize, buf),
            FormatSizeUnits(nFileSize, buf2));
    }
 
    attr_ro = NULL;
    attr_cmp = NULL;
    attr_enc = NULL;
 
    if (nFileAttr != INVALID_FILE_ATTRIBUTES) {
        if (nFileAttr & FILE_ATTRIBUTE_READONLY) {
            attr_ro = ModuleMessage(MSG_ATTR_READONLY);
        }
 
        if (nFileAttr & FILE_ATTRIBUTE_COMPRESSED) {
            attr_cmp = ModuleMessage(MSG_ATTR_COMPRESSED);
        }
 
        if (nFileAttr & FILE_ATTRIBUTE_ENCRYPTED) {
            attr_enc = ModuleMessage(MSG_ATTR_ENCRYPTED);
        }
    }
 
    _snprintf(pBuffer, nBufSize - 1, "%s %s %s %s %s",
        type_str ? type_str : "",
        size_str ? size_str : "",
        attr_ro  ? attr_ro  : "",
        attr_cmp ? attr_cmp : "",
        attr_enc ? attr_enc : "");
 
    if (type_str) {
        LocalFree(type_str);
    }
    if (size_str) {
        LocalFree(size_str);
    }
    if (attr_ro) {
        LocalFree(attr_ro);
    }
    if (attr_cmp) {
        LocalFree(attr_cmp);
    }
    if (attr_enc) {
        LocalFree(attr_enc);
    }
}
 
void ShowContextMenu(
    HWND            hDlg,
    HWND            hCtl,
    LPARAM          lParam)
{
    POINT           pt;
    UINT            id;
    HMENU           hMenu;
 
    pt.x = ((int)(short)LOWORD(lParam));
    pt.y = ((int)(short)HIWORD(lParam));
 
    if (pt.x == -1 || pt.y == -1) {
        RECT rc;
 
        GetWindowRect(hCtl, &rc);
        pt.x = (rc.left + rc.right) / 2;
        pt.y = (rc.top + rc.bottom) / 2;
 
        id = GetDlgCtrlID(hCtl);
    }
    else {
        POINT pt2 = pt;
 
        ScreenToClient(hDlg, &pt2);
 
        id = GetDlgCtrlID(
            ChildWindowFromPoint(hDlg, pt2));
    }
 
    if (id < IDC_IMAGEFILE_LABEL ||
        id > IDC_TRUNCATE) {
        return;
    }
 
    hMenu = CreatePopupMenu();
 
    AppendMenu(hMenu, MF_STRING, 1, "&What's This");
 
    if (TrackPopupMenu(hMenu, TPM_RETURNCMD,
        pt.x, pt.y, 0, hDlg, NULL))
    {
        ShowHelpWindow(hDlg, id);
    }
 
    DestroyMenu(hMenu);
}
 
//
//  Show tool tip help
//
void ShowHelpWindow(
    HWND            hDlg,
    UINT            nCtl)
{
    UINT            msg;
    RECT            rc;
    PSTR            help;
 
    switch (nCtl) {
    case IDC_IMAGEFILE_LABEL:
    case IDC_IMAGEFILE:
        msg = MSG_HELP_IMAGEFILE;
        break;
    case IDC_IMAGEDESC_LABEL:
    case IDC_IMAGEFILE_DESC:
        msg = MSG_HELP_IMAGEDESC;
        break;
    case IDC_TARGETFILE_LABEL:
    case IDC_TARGETFILE:
        msg = MSG_HELP_TARGETFILE;
        break;
    case IDC_DISKTYPE_LABEL:
    case IDC_DISKTYPE:
    case IDC_DISKTYPE_FILE:
    case IDC_DISKTYPE_RAM:
        msg = MSG_HELP_DISKTYPE;
        break;
    case IDC_MEDIATYPE_LABEL:
    case IDC_MEDIATYPE:
        msg = MSG_HELP_MEDIATYPE;
        break;
    case IDC_WRITE_PROTECTED:
        msg = MSG_HELP_PROTECT_NOW;
        break;
    case IDC_OPEN_PROTECTED:
        msg = MSG_HELP_PROTECT_OPEN;
        break;
    case IDC_BROWSE:
        msg = MSG_HELP_BROWSE;
        break;
    case IDC_OPEN:
        msg = MSG_HELP_OPEN;
        break;
    case IDC_SAVE:
        msg = MSG_HELP_SAVE;
        break;
    case IDC_CLOSE:
        msg = MSG_HELP_CLOSE;
        break;
    case IDC_FORMAT:
        msg = MSG_HELP_FORMAT;
        break;
    case IDC_CONTROL:
        msg = MSG_HELP_CONTROL;
        break;
    case IDC_OVERWRITE:
        msg = MSG_HELP_OVERWRITE;
        break;
    case IDC_TRUNCATE:
        msg = MSG_HELP_TRUNCATE;
        break;
    default:
        return;
    }
 
    GetWindowRect(GetDlgItem(hDlg, nCtl), &rc);
 
    help = ModuleMessage(msg);
 
    if (help) {
        VfdToolTip(hDlg, help, rc.left, (rc.top + rc.bottom) / 2, TRUE);
        LocalFree(help);
    }
}