vfdguisave.c

Go to the documentation of this file.

/*
    vfdguisave.c

    Virtual Floppy Drive for Windows
    Driver control library
    Save image GUI utility function

    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>
#ifdef _MSC_VER
#pragma warning(push,3)
#endif
#include <commdlg.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif

#include "vfdtypes.h"
#include "vfdapi.h"
#include "vfdlib.h"
#ifndef __REACTOS__
#include "vfdmsg.h"
#else
#include "vfdmsg_lib.h"
#endif
#include "vfdguirc.h"

//
//  local functions
//
#ifndef __REACTOS__
static INT CALLBACK SaveDialogProc(
#else
static INT_PTR CALLBACK SaveDialogProc(
#endif
    HWND            hDlg,
    UINT            uMsg,
    WPARAM          wParam,
    LPARAM          lParam);

static void OnInit(HWND hDlg, PCSAVE_PARAM pParam);
static void OnTarget(HWND hDlg, HWND hEdit);
static void OnBrowse(HWND hDlg);
static void OnOverwrite(HWND hDlg, HWND hCheck);
static void OnTruncate(HWND hDlg, HWND hCheck);
static DWORD OnOK(HWND hDlg);

//
//  Show Save Image dialog box
//
DWORD WINAPI VfdGuiSave(
    HWND            hParent,
    ULONG           nDevice)
{
    SAVE_PARAM      param;
    CHAR            path[MAX_PATH];
    DWORD           ret;

    //  open the source device

    param.hDevice = VfdOpenDevice(nDevice);

    if (param.hDevice == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }

    //  get current image information

    param.ImageName = path;

    ret = VfdGetImageInfo(
        param.hDevice,
        param.ImageName,
        &param.DiskType,
        &param.MediaType,
        &param.MediaFlags,
        &param.FileType,
        &param.ImageSize);

    if (ret == ERROR_SUCCESS) {

        //  show dialog box

        ret = GuiSaveParam(hParent, &param);
    }

    //  close the source device

    CloseHandle(param.hDevice);

    return ret;
}

DWORD GuiSaveParam(
    HWND            hParent,
    PCSAVE_PARAM    pParam)
{
    switch (DialogBoxParam(
        g_hDllModule,
        MAKEINTRESOURCE(IDD_SAVEDIALOG),
        hParent,
        SaveDialogProc,
        (LPARAM)pParam))
    {
    case IDOK:
        return ERROR_SUCCESS;

    case IDCANCEL:
        return ERROR_CANCELLED;

    default:
        return GetLastError();
    }
}

//
// The dialog procedure
//
#ifndef __REACTOS__
INT CALLBACK SaveDialogProc(
#else
INT_PTR CALLBACK SaveDialogProc(
#endif
    HWND            hDlg,
    UINT            uMsg,
    WPARAM          wParam,
    LPARAM          lParam)
{
    switch (uMsg) {
    case WM_INITDIALOG:
        OnInit(hDlg, (PCSAVE_PARAM)lParam);
        return TRUE;

    case WM_COMMAND:
        switch (wParam) {
        case MAKELONG(IDC_TARGETFILE, EN_CHANGE):
            OnTarget(hDlg, (HWND)lParam);
            return TRUE;

        case IDC_BROWSE:
            OnBrowse(hDlg);
            return TRUE;

        case IDC_OVERWRITE:
            OnOverwrite(hDlg, (HWND)lParam);
            return TRUE;

        case IDC_TRUNCATE:
            OnTruncate(hDlg, (HWND)lParam);
            return TRUE;

        case IDOK:
            if (OnOK(hDlg) == ERROR_SUCCESS) {
                EndDialog(hDlg, IDOK);
            }
            return TRUE;

        case IDCANCEL:
            EndDialog(hDlg, IDCANCEL);
            return TRUE;
        }
        break;

    case WM_CONTEXTMENU:
        ShowContextMenu(hDlg, (HWND)wParam, lParam);
        break;

    case WM_HELP:
        {
            LPHELPINFO info = (LPHELPINFO)lParam;

            if (info->iContextType == HELPINFO_WINDOW) {
                ShowHelpWindow(hDlg, info->iCtrlId);
            }
        }
        return TRUE;
    }

    return FALSE;
}

//
//  Initialize the dialog
//
void OnInit(
    HWND            hDlg,
    PCSAVE_PARAM    pParam)
{
    //  Store parameters

    SetWindowLongPtr(hDlg, GWLP_USERDATA, (ULONG_PTR)pParam);

    //  clear the target existence flag

    SetWindowLong(hDlg, DWL_USER, 0);

    // Set dialog window title

    SetControlText(hDlg, 0, MSG_SAVE_TITLE);

    // Set control captions

    SetControlText(hDlg, IDC_IMAGEFILE_LABEL,   MSG_IMAGEFILE_LABEL);
    SetControlText(hDlg, IDC_DISKTYPE_LABEL,    MSG_DISKTYPE_LABEL);
    SetControlText(hDlg, IDC_MEDIATYPE_LABEL,   MSG_MEDIATYPE_LABEL);
    SetControlText(hDlg, IDC_TARGETFILE_LABEL,  MSG_TARGETFILE_LABEL);
    SetControlText(hDlg, IDC_IMAGEDESC_LABEL,   MSG_DESCRIPTION_LABEL);
    SetControlText(hDlg, IDC_BROWSE,            MSG_BROWSE_BUTTON);
    SetControlText(hDlg, IDC_OVERWRITE,         MSG_OVERWRITE_CHECK);
    SetControlText(hDlg, IDC_TRUNCATE,          MSG_TRUNCATE_CHECK);
    SetControlText(hDlg, IDOK,                  MSG_SAVE_BUTTON);
    SetControlText(hDlg, IDCANCEL,              MSG_CANCEL_BUTTON);

    //  set disk type

    if (pParam->DiskType == VFD_DISKTYPE_FILE) {
        SetDlgItemText(hDlg, IDC_DISKTYPE, "FILE");
    }
    else {
        SetDlgItemText(hDlg, IDC_DISKTYPE, "RAM");
    }

    //  display media type

    SetDlgItemText(hDlg, IDC_MEDIATYPE,
        VfdMediaTypeName(pParam->MediaType));

    //  set current image and initial target

    if (pParam->ImageName[0]) {
        SetDlgItemText(hDlg, IDC_IMAGEFILE, pParam->ImageName);
        SetDlgItemText(hDlg, IDC_TARGETFILE, pParam->ImageName);
    }
    else if (pParam->DiskType != VFD_DISKTYPE_FILE) {
        SetDlgItemText(hDlg, IDC_IMAGEFILE, "<RAM>");
        OnTarget(hDlg, GetDlgItem(hDlg, IDC_TARGETFILE));
    }
}

//
//  Path is changed -- check specified target file
//
void OnTarget(
    HWND            hDlg,
    HWND            hEdit)
{
    PCSAVE_PARAM    param;
    CHAR            buf[MAX_PATH];
    ULONG           file_size;
    VFD_FILETYPE    file_type;
    DWORD           file_attr;
    DWORD           ret;

    //  clear the target existence flag

    SetWindowLong(hDlg, DWL_USER, 0);

    //  clear the description and hint text

    SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, NULL);
    SetDlgItemText(hDlg, IDC_IMAGEFILE_HINT, NULL);

    //  get the target file name

    if (GetWindowText(hEdit, buf, sizeof(buf)) == 0) {

        //  target file is blank

        EnableWindow(GetDlgItem(hDlg, IDC_OVERWRITE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);

        return;
    }
    else {
        CHAR full[MAX_PATH];
        PSTR file;

        //  convert into a full path

        if (GetFullPathName(buf, sizeof(full), full, &file)) {
            strcpy(buf, full);
        }
    }

    //
    //  get the current image info
    //
    param = (PCSAVE_PARAM)GetWindowLongPtr(hDlg, GWLP_USERDATA);

    if (_stricmp(param->ImageName, buf) == 0) {

        //  target is the current file

        char desc[MAX_PATH];

        VfdMakeFileDesc(desc, sizeof(desc),
            param->FileType, param->ImageSize,
            GetFileAttributes(param->ImageName));

        SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, desc);
        SetControlText(hDlg, IDC_IMAGEFILE_HINT, MSG_CURRENT_FILE);

        if (param->DiskType == VFD_DISKTYPE_FILE) {

            //  cannot overwrite the current FILE disk image

            EnableWindow(GetDlgItem(hDlg, IDC_OVERWRITE), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
            return;
        }
    }

    //
    //  check target image file
    //
    ret = VfdCheckImageFile(
        buf, &file_attr, &file_type, &file_size);

    if (ret == ERROR_FILE_NOT_FOUND) {
        //  file does not exist
        SetControlText(hDlg, IDC_IMAGEFILE_DESC, MSG_DESC_NEW_FILE);
        EnableWindow(GetDlgItem(hDlg, IDC_OVERWRITE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
        return;
    }
    else if (ret != ERROR_SUCCESS) {
        SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, SystemMessage(ret));
        EnableWindow(GetDlgItem(hDlg, IDC_OVERWRITE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
        return;
    }

    //  set target file description

    VfdMakeFileDesc(buf, sizeof(buf),
        file_type, file_size, file_attr);

    SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, buf);

    //  check target file type

    if (file_type == VFD_FILETYPE_ZIP) {
        SetControlText(hDlg, IDC_IMAGEFILE_HINT, MSG_TARGET_IS_ZIP);
        EnableWindow(GetDlgItem(hDlg, IDC_OVERWRITE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
        return;
    }

    //  the target is an existing raw file

    EnableWindow(GetDlgItem(hDlg, IDC_OVERWRITE), TRUE);

    //  set truncate box

    if (file_size > VfdGetMediaSize(param->MediaType)) {
        EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), TRUE);
        SetControlText(hDlg, IDC_IMAGEFILE_HINT, MSG_SIZE_MISMATCH);
    }
    else {
        EnableWindow(GetDlgItem(hDlg, IDC_TRUNCATE), FALSE);
    }

    //  check overwrite setting

    if (IsDlgButtonChecked(hDlg, IDC_OVERWRITE) != BST_CHECKED) {
        EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
    }
    else {
        EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
    }

    //  target file exists and overwritable

    SetWindowLong(hDlg, DWL_USER, 1);
}


//
//  Show save file dialog box
//
void OnBrowse(
    HWND            hDlg)
{
    OPENFILENAME    ofn;
    PSTR            title;
    CHAR            file[MAX_PATH];
    CHAR            dir[MAX_PATH];
    DWORD           len;

    title = ModuleMessage(MSG_SAVE_TITLE);

    ZeroMemory(&ofn, sizeof(ofn));
    ZeroMemory(file, sizeof(file));
    ZeroMemory(dir, sizeof(dir));

    len = GetDlgItemText(hDlg, IDC_TARGETFILE, file, sizeof(file));

    if (len && file[len - 1] == '\\') {
        strcpy(dir, file);
        ZeroMemory(file, sizeof(file));
    }

    // Different structure sizes must be used for NT and 2K/XP
    ofn.lStructSize = IS_WINDOWS_NT() ?
        OPENFILENAME_SIZE_VERSION_400 : sizeof(ofn);

    ofn.hwndOwner   = hDlg;
    ofn.lpstrFile   = file;
    ofn.nMaxFile    = sizeof(file);
    ofn.lpstrInitialDir = dir;
    ofn.lpstrTitle  = title ? title : "Save Image";
    ofn.lpstrFilter = "*.*\0*.*\0";
    ofn.Flags       = OFN_ENABLESIZING | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;

    if (GetSaveFileName(&ofn)) {
        SetDlgItemText(hDlg, IDC_TARGETFILE, file);
        SetFocus(GetDlgItem(hDlg, IDC_TARGETFILE));
    }

    if (title) {
        LocalFree(title);
    }
}

void OnOverwrite(
    HWND            hDlg,
    HWND            hCheck)
{
    if (GetWindowLong(hDlg, DWL_USER)) {
        //  the target file exists and overwritable
        if (SendMessage(hCheck, BM_GETCHECK, 0, 0) != BST_CHECKED) {
            EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
        }
        else {
            EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
        }
    }
}

void OnTruncate(
    HWND            hDlg,
    HWND            hCheck)
{
    UNREFERENCED_PARAMETER(hDlg);
    UNREFERENCED_PARAMETER(hCheck);
}

//
//  Save image
//
DWORD OnOK(
    HWND            hDlg)
{
    PCSAVE_PARAM    param;
    CHAR            path[MAX_PATH];
    BOOL            overwrite;
    BOOL            truncate;
    DWORD           ret;

    param = (PCSAVE_PARAM)GetWindowLongPtr(hDlg, GWLP_USERDATA);

    if (!param) {
        return ERROR_INVALID_FUNCTION;
    }

    //  get the target image name

    if (GetDlgItemText(hDlg, IDC_TARGETFILE, path, sizeof(path)) == 0) {
        return ERROR_INVALID_FUNCTION;
    }

    if (GetWindowLong(hDlg, DWL_USER)) {
        //  the target file exists and overwritable
        overwrite = (IsDlgButtonChecked(hDlg, IDC_OVERWRITE) == BST_CHECKED);
        truncate = (IsDlgButtonChecked(hDlg, IDC_TRUNCATE) == BST_CHECKED);
    }
    else {
        overwrite = FALSE;
        truncate = TRUE;
    }

retry:
    ret = VfdDismountVolume(param->hDevice, FALSE);

    if (ret == ERROR_ACCESS_DENIED) {
        PSTR msg = ModuleMessage(MSG_UNMOUNT_CONFIRM);

        int reply = MessageBox(
            hDlg, msg ? msg : "retry", VFD_MSGBOX_TITLE,
            MB_ICONEXCLAMATION | MB_CANCELTRYCONTINUE);

        if (msg) {
            LocalFree(msg);
        }

        if (reply == IDRETRY) {
            goto retry;
        }
        else if (reply == IDCANCEL) {
            return ERROR_CANCELLED;
        }
        else {
            VfdDismountVolume(param->hDevice, TRUE);
        }
    }
    else if (ret != ERROR_SUCCESS) {

        MessageBox(hDlg, SystemMessage(ret),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);

        return ret;
    }

    ret = VfdSaveImage(param->hDevice, path, overwrite, truncate);

    if (ret != ERROR_SUCCESS) {

        //  show error message

        MessageBox(hDlg, SystemMessage(ret),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
    }

    return ret;
}