vfdshprop.cpp File Reference

#include <windows.h>
#include <shellapi.h>
#include <shlobj.h>
#include <stdio.h>
#include "vfdtypes.h"
#include "vfdapi.h"
#include "vfdlib.h"
#include "vfdver.h"
#include "vfdmsg.h"
#include "vfdguirc.h"
#include "vfdshext.h"

Include dependency graph for vfdshprop.cpp:

Go to the source code of this file.

Macros
#define	WIN32_LEAN_AND_MEAN
#define	VFD_PROPERTY_ID   "VFD"

Functions
static BOOL CALLBACK	VfdPageDlgProc (HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
static UINT CALLBACK	VfdPageCallback (HWND hWnd, UINT uMessage, LPPROPSHEETPAGE ppsp)
static void	OnPropInit (HWND hDlg)
static void	OnControl (HWND hDlg)
static void	UpdateImageInfo (HWND hDlg, ULONG nDevice)

Macro Definition Documentation

VFD_PROPERTY_ID

#define VFD_PROPERTY_ID   "VFD"

Definition at line 33 of file vfdshprop.cpp.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 11 of file vfdshprop.cpp.

Function Documentation

OnControl()

void OnControl ( HWND  hDlg )

static

Definition at line 234 of file vfdshprop.cpp.

{
    CHAR            module_path[MAX_PATH];
    CHAR            full_path[MAX_PATH];
    PSTR            file_name;
#ifndef __REACTOS__
    DWORD           ret;
#else
    DWORD_PTR       ret;
#endif
 
    ret = GetModuleFileName(
        g_hDllModule, module_path, sizeof(module_path));
 
    if (ret == 0 || ret >= sizeof(module_path)) {
        file_name = full_path;
    }
    else {
        ret = GetFullPathName(
            module_path, sizeof(full_path), full_path, &file_name);
 
        if (ret == 0 || ret >= sizeof(full_path)) {
            file_name = full_path;
        }
    }
 
    strcpy(file_name, "vfdwin.exe");
 
    VFDTRACE(0, ("Starting %s\n", full_path));
 
#ifndef __REACTOS__
    ret = (DWORD)ShellExecute(
        hDlg, NULL, full_path, NULL, NULL, SW_SHOW);
#else
    ret = (DWORD_PTR)ShellExecute(
        hDlg, NULL, full_path, NULL, NULL, SW_SHOW);
#endif
 
    if (ret > 32) {
        PropSheet_PressButton(GetParent(hDlg), PSBTN_CANCEL);
    }
    else {
        MessageBox(hDlg, SystemMessage(ret),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
    }
}

Referenced by VfdPageDlgProc().

OnPropInit()

void OnPropInit ( HWND  hDlg )

static

Definition at line 211 of file vfdshprop.cpp.

{
    //  set up control text
 
    SetDlgItemText(hDlg, IDC_PROPERTY_TITLE,    VFD_PRODUCT_DESC);
    SetDlgItemText(hDlg, IDC_COPYRIGHT_STR,     VFD_COPYRIGHT_STR);
 
    SetControlText(hDlg, IDC_IMAGEFILE_LABEL,   MSG_IMAGEFILE_LABEL);
    SetControlText(hDlg, IDC_IMAGEDESC_LABEL,   MSG_DESCRIPTION_LABEL);
    SetControlText(hDlg, IDC_DISKTYPE_LABEL,    MSG_DISKTYPE_LABEL);
    SetControlText(hDlg, IDC_MEDIATYPE_LABEL,   MSG_MEDIATYPE_LABEL);
    SetControlText(hDlg, IDC_WRITE_PROTECTED,   MSG_MENU_PROTECT);
    SetControlText(hDlg, IDC_OPEN,              MSG_OPEN_BUTTON);
    SetControlText(hDlg, IDC_SAVE,              MSG_SAVE_BUTTON);
    SetControlText(hDlg, IDC_CLOSE,             MSG_CLOSE_BUTTON);
    SetControlText(hDlg, IDC_FORMAT,            MSG_FORMAT_BUTTON);
    SetControlText(hDlg, IDC_CONTROL,           MSG_CONTROL_BUTTON);
}

Referenced by VfdPageDlgProc().

UpdateImageInfo()

void UpdateImageInfo ( HWND  hDlg, ULONG  nDevice  )

static

Definition at line 285 of file vfdshprop.cpp.

{
    HANDLE          hDevice;
    CHAR            buf[MAX_PATH];
    VFD_DISKTYPE    disk_type;
    VFD_MEDIA       media_type;
    VFD_FLAGS       media_flags;
    VFD_FILETYPE    file_type;
    ULONG           image_size;
    DWORD           attrib;
    ULONG           ret;
 
    hDevice = VfdOpenDevice(nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        MessageBox(hDlg,
            SystemMessage(GetLastError()),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
        return;
    }
 
    //  get current image information
 
    ret = VfdGetImageInfo(
        hDevice,
        buf,
        &disk_type,
        &media_type,
        &media_flags,
        &file_type,
        &image_size);
 
    CloseHandle(hDevice);
 
    if (ret != ERROR_SUCCESS) {
        MessageBox(hDlg,
            SystemMessage(ret),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
        return;
    }
 
    if (media_type == VFD_MEDIA_NONE) {
 
        //  drive is empty
 
        SetDlgItemText(hDlg, IDC_IMAGEFILE, NULL);
        SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, NULL);
        SetDlgItemText(hDlg, IDC_DISKTYPE, NULL);
        SetDlgItemText(hDlg, IDC_MEDIATYPE, NULL);
 
        EnableWindow(GetDlgItem(hDlg, IDC_WRITE_PROTECTED), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_OPEN),    TRUE);
        EnableWindow(GetDlgItem(hDlg, IDC_SAVE),    FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_CLOSE),   FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_FORMAT),  FALSE);
 
        SendMessage(GetDlgItem(hDlg, IDC_OPEN),
            BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
 
        SetFocus(GetDlgItem(hDlg, IDC_OPEN));
 
        return;
    }
 
    //  display image file name
 
    if (buf[0]) {
        attrib = GetFileAttributes(buf);
 
        if (attrib == INVALID_FILE_ATTRIBUTES) {
            attrib = 0;
        }
    }
    else {
        if (disk_type != VFD_DISKTYPE_FILE) {
            strcpy(buf, "<RAM>");
        }
        attrib = 0;
    }
 
    SetDlgItemText(hDlg, IDC_IMAGEFILE, buf);
 
    //  display image description
 
    VfdMakeFileDesc(buf, sizeof(buf),
        file_type, image_size, attrib);
 
    SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, buf);
 
    //  display disk type
 
    if (disk_type == VFD_DISKTYPE_FILE) {
        SetDlgItemText(hDlg, IDC_DISKTYPE, "FILE");
    }
    else {
        SetDlgItemText(hDlg, IDC_DISKTYPE, "RAM");
    }
 
    //  display media type
 
    SetDlgItemText(hDlg, IDC_MEDIATYPE,
        VfdMediaTypeName(media_type));
 
    //  set write protect check box
 
    if (media_flags & VFD_FLAG_WRITE_PROTECTED) {
        CheckDlgButton(hDlg, IDC_WRITE_PROTECTED, BST_CHECKED);
    }
    else {
        CheckDlgButton(hDlg, IDC_WRITE_PROTECTED, BST_UNCHECKED);
    }
 
    EnableWindow(GetDlgItem(hDlg, IDC_WRITE_PROTECTED), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_OPEN),    FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_SAVE),    TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_CLOSE),   TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_FORMAT),  TRUE);
 
    SendMessage(GetDlgItem(hDlg, IDC_CLOSE),
        BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
 
    SetFocus(GetDlgItem(hDlg, IDC_CLOSE));
}

Referenced by VfdPageDlgProc().

VfdPageCallback()

UINT CALLBACK VfdPageCallback ( HWND  hWnd, UINT  uMessage, LPPROPSHEETPAGE  ppsp  )

static

Definition at line 60 of file vfdshprop.cpp.

{
    UNREFERENCED_PARAMETER(hWnd);
 
    switch(uMessage) {
    case PSPCB_CREATE:
        return TRUE;
 
    case PSPCB_RELEASE:
        if (ppsp->lParam) {
            ((LPCVFDSHEXT)(ppsp->lParam))->Release();
        }
        return TRUE;
    }
    return TRUE;
}

Referenced by CVfdShExt::AddPages().

VfdPageDlgProc()

BOOL CALLBACK VfdPageDlgProc ( HWND  hDlg, UINT  uMessage, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 84 of file vfdshprop.cpp.

{
    LPPROPSHEETPAGE psp;
    LPCVFDSHEXT     lpcs;
 
    switch (uMessage) {
    case WM_INITDIALOG:
#ifndef __REACTOS__
        SetWindowLong(hDlg, DWL_USER, lParam);
#else
        SetWindowLongPtr(hDlg, DWLP_USER, lParam);
#endif
 
        if (lParam) {
            lpcs = (LPCVFDSHEXT)((LPPROPSHEETPAGE)lParam)->lParam;
 
            OnPropInit(hDlg);
            UpdateImageInfo(hDlg, lpcs->GetDevice());
        }
        return TRUE;
 
    case WM_COMMAND:
#ifndef __REACTOS__
        psp = (LPPROPSHEETPAGE)GetWindowLong(hDlg, DWL_USER);
#else
        psp = (LPPROPSHEETPAGE)GetWindowLongPtr(hDlg, DWLP_USER);
#endif
 
        if (!psp) {
            break;
        }
 
        lpcs = (LPCVFDSHEXT)psp->lParam;
 
        if (!lpcs) {
            break;
        }
 
        switch (wParam) {
        case IDC_OPEN:
            if (lpcs->DoVfdOpen(hDlg) == ERROR_SUCCESS) {
                SendMessage((HWND)lParam,
                    BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
            }
            UpdateImageInfo(hDlg, lpcs->GetDevice());
            break;
 
        case IDC_SAVE:
            if (lpcs->DoVfdSave(hDlg) == ERROR_SUCCESS) {
                SendMessage((HWND)lParam,
                    BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
            }
            UpdateImageInfo(hDlg, lpcs->GetDevice());
            break;
 
        case IDC_CLOSE:
            if (lpcs->DoVfdClose(hDlg) == ERROR_SUCCESS) {
                SendMessage((HWND)lParam,
                    BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
            }
            UpdateImageInfo(hDlg, lpcs->GetDevice());
            break;
 
        case IDC_WRITE_PROTECTED:
            lpcs->DoVfdProtect(hDlg);
            break;
 
        case IDC_FORMAT:
            VfdGuiFormat(hDlg, lpcs->GetDevice());
            break;
 
        case IDC_CONTROL:
            OnControl(hDlg);
            break;
        }
        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;
 
    default:
        if (uMessage == g_nNotifyMsg) {
#ifndef __REACTOS__
            psp = (LPPROPSHEETPAGE)GetWindowLong(hDlg, DWL_USER);
#else
            psp = (LPPROPSHEETPAGE)GetWindowLongPtr(hDlg, DWLP_USER);
#endif
 
            if (!psp) {
                break;
            }
 
            lpcs = (LPCVFDSHEXT)psp->lParam;
 
            if (!lpcs) {
                break;
            }
 
            UpdateImageInfo(hDlg, lpcs->GetDevice());
        }
        break;
    }
 
    return FALSE;
}

Referenced by CVfdShExt::AddPages().