CVfdShExt Class Reference

#include <vfdshext.h>

Inheritance diagram for CVfdShExt:

Collaboration diagram for CVfdShExt:

Public Member Functions
	CVfdShExt ()
	~CVfdShExt ()
DWORD	DoVfdOpen (HWND hParent)
DWORD	DoVfdNew (HWND hParent)
DWORD	DoVfdClose (HWND hParent)
DWORD	DoVfdSave (HWND hParent)
DWORD	DoVfdProtect (HWND hParent)
DWORD	DoVfdDrop (HWND hParent)
ULONG	GetDevice ()
PCSTR	GetTarget ()
STDMETHODIMP	QueryInterface (REFIID, LPVOID *)
	STDMETHODIMP_ (ULONG) AddRef()
	STDMETHODIMP_ (ULONG) Release()
STDMETHODIMP	Initialize (LPCITEMIDLIST pIDFolder, LPDATAOBJECT pDataObj, HKEY hKeyID)
STDMETHODIMP	QueryContextMenu (HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
STDMETHODIMP	InvokeCommand (LPCMINVOKECOMMANDINFO lpcmi)
STDMETHODIMP	GetCommandString (UINT idCmd, UINT uFlags, UINT *reserved, LPSTR pszName, UINT cchMax)
STDMETHODIMP	AddPages (LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
STDMETHODIMP	ReplacePage (UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam)
Public Member Functions inherited from IContextMenu
HRESULT	QueryContextMenu ([in] HMENU hmenu, [in] UINT indexMenu, [in] UINT idCmdFirst, [in] UINT idCmdLast, [in] UINT uFlags)
HRESULT	InvokeCommand ([in] LPCMINVOKECOMMANDINFO lpici)
HRESULT	GetCommandString ([in] UINT_PTR idCmd, [in] UINT uType, [out] UINT *pwReserved, [out, size_is(cchMax)] LPSTR pszName, [in] UINT cchMax)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()

Protected Attributes
ULONG	m_cRefCnt
LPDATAOBJECT	m_pDataObj
ULONG	m_nDevice
CHAR	m_sTarget [MAX_PATH]
BOOL	m_bDragDrop

Additional Inherited Members
Public Types inherited from IContextMenu
typedef IContextMenu *	LPCONTEXTMENU
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO	CMINVOKECOMMANDINFO
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO *	LPCMINVOKECOMMANDINFO
typedef struct IContextMenu::tagCMInvokeCommandInfoEx	CMINVOKECOMMANDINFOEX
typedef struct IContextMenu::tagCMInvokeCommandInfoEx *	LPCMINVOKECOMMANDINFOEX
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Static Public Attributes inherited from IContextMenu
static const WCHAR	CMDSTR_NEWFOLDERW [] = {'N','e','w','F','o','l','d','e','r',0}
static const WCHAR	CMDSTR_VIEWLISTW [] = {'V','i','e','w','L','i','s','t',0}
static const WCHAR	CMDSTR_VIEWDETAILSW [] = {'V','i','e','w','D','e','t','a','i','l','s',0}
Private Types inherited from IShellExtInit
typedef IShellExtInit *	LPSHELLEXTINIT
Private Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Private Types inherited from IShellPropSheetExt
enum	tagSHELLPROPSHEETEXTPAGEID { EXPPS_FILETYPES = 0x1 }
typedef UINT	EXPPS
Private Member Functions inherited from IShellExtInit
HRESULT	Initialize ([in] PCIDLIST_ABSOLUTE pidlFolder, [in] IDataObject *pdtobj, [in] HKEY hkeyProgID)
Private Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
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)

Detailed Description

Definition at line 18 of file vfdshext.h.

Constructor & Destructor Documentation

CVfdShExt()

CVfdShExt::CVfdShExt

(

)

Definition at line 26 of file vfdshext.cpp.

{
    VFDTRACE(0, ("CVfdShExt::CVfdShExt()\n"));
 
    m_cRefCnt       = 0L;
    m_pDataObj      = NULL;
    m_nDevice       = (ULONG)-1;
    m_sTarget[0]    = '\0';
    m_bDragDrop     = FALSE;
 
    g_cDllRefCnt++;
}

~CVfdShExt()

CVfdShExt::~CVfdShExt

(

)

Definition at line 42 of file vfdshext.cpp.

{
    VFDTRACE(0, ("CVfdShExt::~CVfdShExt()\n"));
 
    if (m_pDataObj) {
        m_pDataObj->Release();
    }
 
    g_cDllRefCnt--;
}

Member Function Documentation

AddPages()

STDMETHODIMP CVfdShExt::AddPages	(	LPFNADDPROPSHEETPAGE	lpfnAddPage,
		LPARAM	lParam
	)

Definition at line 416 of file vfdshprop.cpp.

{
    PROPSHEETPAGE   psp;
    HPROPSHEETPAGE  hpage;
 
    if (!m_pDataObj || m_nDevice == (ULONG)-1) {
        // not a VFD drive
        VFDTRACE(0, ("PropPage: Not a VFD drive\n"));
 
        return NOERROR;
    }
 
    psp.dwSize      = sizeof(psp);  // no extra data.
    psp.dwFlags     = PSP_USEREFPARENT | PSP_USETITLE | PSP_USECALLBACK;
    psp.hInstance   = g_hDllModule;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPDIALOG);
    psp.hIcon       = 0;
    psp.pszTitle    = "VFD";
    psp.pfnDlgProc  = VfdPageDlgProc;
    psp.pcRefParent = &g_cDllRefCnt;
    psp.pfnCallback = VfdPageCallback;
    psp.lParam      = (LPARAM)this;
 
    AddRef();
    hpage = CreatePropertySheetPage(&psp);
 
    if (hpage) {
        if (!lpfnAddPage(hpage, lParam)) {
            DestroyPropertySheetPage(hpage);
            Release();
        }
    }
 
    return NOERROR;
}

DoVfdClose()

DWORD CVfdShExt::DoVfdClose

(

HWND

hParent

)

Definition at line 489 of file vfdshmenu.cpp.

{
    return VfdGuiClose(hParent, m_nDevice);
}

Referenced by DoVfdDrop(), InvokeCommand(), and VfdPageDlgProc().

DoVfdDrop()

DWORD CVfdShExt::DoVfdDrop

(

HWND

hParent

)

Definition at line 534 of file vfdshmenu.cpp.

{
    HANDLE          hDevice;
    DWORD           file_attr;
    ULONG           file_size;
    VFD_FILETYPE    file_type;
 
    VFD_DISKTYPE    disk_type;
    VFD_MEDIA       media_type;
 
    DWORD           ret;
 
    VFDTRACE(0, ("CVfdShExt::DoVfdDropOpen()\n"));
 
    //  check if dropped file is a valid image
 
    ret = VfdCheckImageFile(
        m_sTarget, &file_attr, &file_type, &file_size);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //  check file size
    media_type = VfdLookupMedia(file_size);
 
    if (!media_type) {
        PSTR msg = ModuleMessage(MSG_FILE_TOO_SMALL);
 
        MessageBox(hParent, msg ? msg : "Bad size",
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
 
        if (msg) {
            LocalFree(msg);
        }
 
        return ERROR_CANCELLED;
    }
 
    if ((file_type == VFD_FILETYPE_ZIP) ||
        (file_attr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED))) {
 
        disk_type = VFD_DISKTYPE_RAM;
    }
    else {
        disk_type = VFD_DISKTYPE_FILE;
    }
 
    //  close current image (if opened)
 
    ret = DoVfdClose(hParent);
 
    if (ret != ERROR_SUCCESS &&
        ret != ERROR_NOT_READY) {
        return ret;
    }
 
    //  open dropped file
 
    hDevice = VfdOpenDevice(m_nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }
 
    ret = VfdOpenImage(
        hDevice, m_sTarget, disk_type, media_type, FALSE);
 
    CloseHandle(hDevice);
 
    return ret;
}

Referenced by InvokeCommand().

DoVfdNew()

DWORD CVfdShExt::DoVfdNew

(

HWND

hParent

)

DoVfdOpen()

DWORD CVfdShExt::DoVfdOpen

(

HWND

hParent

)

Definition at line 464 of file vfdshmenu.cpp.

{
    DWORD ret = VfdGuiOpen(hParent, m_nDevice);
 
    if (ret != ERROR_SUCCESS && ret != ERROR_CANCELLED) {
        MessageBox(hParent, SystemMessage(ret),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
    }
 
    return ret;
}

Referenced by InvokeCommand(), and VfdPageDlgProc().

DoVfdProtect()

DWORD CVfdShExt::DoVfdProtect

(

HWND

hParent

)

Definition at line 498 of file vfdshmenu.cpp.

{
    HANDLE          hDevice;
    DWORD           ret;
 
    UNREFERENCED_PARAMETER(hParent);
    VFDTRACE(0, ("CVfdShExt::DoVfdProtect()\n"));
 
    hDevice = VfdOpenDevice(m_nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }
 
    ret = VfdGetMediaState(hDevice);
 
    if (ret == ERROR_SUCCESS) {
        ret = VfdWriteProtect(hDevice, TRUE);
    }
    else if (ret == ERROR_WRITE_PROTECT) {
        ret = VfdWriteProtect(hDevice, FALSE);
    }
 
    if (ret == ERROR_SUCCESS) {
        ret = VfdGetMediaState(hDevice);
    }
 
    CloseHandle(hDevice);
 
    return ret;
}

Referenced by InvokeCommand(), and VfdPageDlgProc().

DoVfdSave()

DWORD CVfdShExt::DoVfdSave

(

HWND

hParent

)

Definition at line 480 of file vfdshmenu.cpp.

{
    return VfdGuiSave(hParent, m_nDevice);
}

Referenced by InvokeCommand(), and VfdPageDlgProc().

GetCommandString()

STDMETHODIMP CVfdShExt::GetCommandString	(	UINT	idCmd,
		UINT	uFlags,
		UINT *	reserved,
		LPSTR	pszName,
		UINT	cchMax
	)

Definition at line 269 of file vfdshmenu.cpp.

{
    VFDTRACE(0,
        ("CVfdShExt::GetCommandString(%u,...)\n", idCmd));
 
    UNREFERENCED_PARAMETER(reserved);
 
    if (idCmd >= sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0])) {
        return S_FALSE;
    }
 
    switch (uFlags) {
    case GCS_HELPTEXTA:
        FormatMessageA(
            FORMAT_MESSAGE_FROM_HMODULE |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            g_hDllModule, g_VfdMenu[idCmd].helpid,
            0, pszName, cchMax, NULL);
 
        VFDTRACE(0, ("HELPTEXTA: %s\n", pszName));
        break;
 
    case GCS_HELPTEXTW:
        FormatMessageW(
            FORMAT_MESSAGE_FROM_HMODULE |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            g_hDllModule, g_VfdMenu[idCmd].helpid,
            0, (LPWSTR)pszName, cchMax, NULL);
 
        VFDTRACE(0, ("HELPTEXTW: %ws\n", pszName));
        break;
 
    case GCS_VERBA:
        lstrcpynA(pszName, g_VfdMenu[idCmd].verbA, cchMax);
        break;
 
    case GCS_VERBW:
        lstrcpynW((LPWSTR)pszName, g_VfdMenu[idCmd].verbW, cchMax);
        break;
    }
 
    return NOERROR;
}

GetDevice()

ULONG CVfdShExt::GetDevice ( )

inline

Definition at line 44 of file vfdshext.h.

{ return m_nDevice; }

Referenced by VfdPageDlgProc().

GetTarget()

PCSTR CVfdShExt::GetTarget ( )

inline

Definition at line 45 of file vfdshext.h.

{ return m_sTarget; }

Initialize()

STDMETHODIMP CVfdShExt::Initialize	(	LPCITEMIDLIST	pIDFolder,
		LPDATAOBJECT	pDataObj,
		HKEY	hKeyID
	)

Definition at line 121 of file vfdshext.cpp.

{
    CHAR drive = '\0';
 
    VFDTRACE(0, ("CVfdShExt::Initialize()\n"));
 
    UNREFERENCED_PARAMETER(hRegKey);
 
    // Initialize can be called more than once
 
    if (m_pDataObj) {
        m_pDataObj->Release();
        m_pDataObj = NULL;
    }
 
    m_nDevice = (ULONG)-1;
    m_sTarget[0] = '\0';
 
    //  Get the folder name
    if (SHGetPathFromIDList(pIDFolder, m_sTarget)) {
 
        //  act as a Drag-and-Drop Handler
 
        VFDTRACE(0, ("Drag-Drop: %s\n", m_sTarget));
 
        if (GetDriveType(m_sTarget) != DRIVE_REMOVABLE) {
            VFDTRACE(0, ("Not a VFD drive\n"));
            return NOERROR;
        }
 
        drive = m_sTarget[0];
        m_bDragDrop = TRUE;
    }
    else {
 
        //  act as a context menu handler
 
        VFDTRACE(0, ("Context menu:\n"));
        m_bDragDrop = FALSE;
    }
 
    // Extract the target object name
 
    if (pDataObj) {
 
        STGMEDIUM medium;
        FORMATETC fmt = {
            CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL
        };
 
        if (SUCCEEDED(pDataObj->GetData(&fmt, &medium))) {
            if (DragQueryFile((HDROP)medium.hGlobal, (UINT)-1, NULL, 0)) {
 
                DragQueryFile((HDROP)medium.hGlobal,
                    0, m_sTarget, sizeof(m_sTarget));
            }
 
            ReleaseStgMedium(&medium);
        }
    }
 
    VFDTRACE(0, ("Target %s\n", m_sTarget));
 
    if (!drive) {
        //  Contect menu handler
        //  -- Data object is the target drive
        drive = m_sTarget[0];
    }
 
    HANDLE hDevice = VfdOpenDevice(drive);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        VFDTRACE(0, ("Not a VFD drive\n"));
        return NOERROR;
    }
 
    ULONG ret = VfdGetDeviceNumber(hDevice, &m_nDevice);
 
    CloseHandle(hDevice);
 
    if (ret != ERROR_SUCCESS) {
        m_nDevice = (ULONG)-1;
        return NOERROR;
    }
 
    VFDTRACE(0, ("VFD device %d\n", m_nDevice));
    //  Store the data object
 
    m_pDataObj = pDataObj;
    m_pDataObj->AddRef();
 
    return NOERROR;
}

InvokeCommand()

STDMETHODIMP CVfdShExt::InvokeCommand

(

LPCMINVOKECOMMANDINFO

lpcmi

)

Implements IContextMenu.

Definition at line 332 of file vfdshmenu.cpp.

{
    VFDTRACE(0, ("CVfdShExt::InvokeCommand()\n"));
 
    BOOL    unicode = FALSE;
    UINT    id;
    DWORD   ret;
    CMINVOKECOMMANDINFOEX *excmi = (CMINVOKECOMMANDINFOEX *)lpcmi;
 
#ifdef __REACTOS__
    unicode = lpcmi->cbSize >= FIELD_OFFSET(CMINVOKECOMMANDINFOEX, ptInvoke) &&
              (lpcmi->fMask & CMIC_MASK_UNICODE);
#else
    if (lpcmi->cbSize >= sizeof(CMINVOKECOMMANDINFOEX) &&
        (lpcmi->fMask & CMIC_MASK_UNICODE)) {
 
        unicode = TRUE;
    }
#endif
 
 
    if (!unicode && HIWORD(lpcmi->lpVerb)) {
 
        VFDTRACE(0, ("ANSI: %s\n", lpcmi->lpVerb));
 
        // ANSI verb
        for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
            if (!lstrcmpi(lpcmi->lpVerb, g_VfdMenu[id].verbA)) {
                break;
            }
        }
    }
    else if (unicode && HIWORD(excmi->lpVerbW)) {
 
        VFDTRACE(0, ("UNICODE: %ws\n", excmi->lpVerbW));
 
        // UNICODE verb
        for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
            if (!lstrcmpiW(excmi->lpVerbW, g_VfdMenu[id].verbW)) {
                break;
            }
        }
    }
    else {
 
        VFDTRACE(0, ("Command: %u\n", LOWORD(lpcmi->lpVerb)));
 
        // Command ID
        id = LOWORD(lpcmi->lpVerb);
    }
 
    VFDTRACE(0, ("MenuItem: %u\n", id));
 
    switch (id) {
    case VFD_CMD_OPEN:
        ret = DoVfdOpen(lpcmi->hwnd);
 
        if (ret == ERROR_SUCCESS) {
            VfdImageTip(lpcmi->hwnd, m_nDevice);
        }
        break;
 
    case VFD_CMD_SAVE:
        ret = DoVfdSave(lpcmi->hwnd);
        break;
 
    case VFD_CMD_CLOSE:
        ret = DoVfdClose(lpcmi->hwnd);
        break;
 
    case VFD_CMD_PROTECT:
        ret = DoVfdProtect(lpcmi->hwnd);
 
        if (ret == ERROR_SUCCESS) {
            VfdImageTip(lpcmi->hwnd, m_nDevice);
        }
        else if (ret == ERROR_WRITE_PROTECT) {
            VfdImageTip(lpcmi->hwnd, m_nDevice);
            ret = ERROR_SUCCESS;
        }
        break;
 
    case VFD_CMD_DROP:
        ret = DoVfdDrop(lpcmi->hwnd);
 
        if (ret == ERROR_SUCCESS) {
            VfdImageTip(lpcmi->hwnd, m_nDevice);
        }
        break;
 
    case VFD_CMD_PROP:
        {
            SHOBJECTPROPERTIES pSHObjectProperties;
            WCHAR path[4] = L" :\\";
 
            pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
                LoadLibrary("shell32"), "SHObjectProperties");
 
            if (!pSHObjectProperties) {
                pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
                    LoadLibrary("shell32"), (LPCSTR)SHOP_EXPORT_ORDINAL);
            }
 
            if (pSHObjectProperties) {
                path[0] = m_sTarget[0];
 
                pSHObjectProperties(lpcmi->hwnd,
                    SHOP_FILEPATH, path, L"VFD");
            }
        }
        ret = ERROR_SUCCESS;
        break;
 
    default:
        return E_INVALIDARG;
    }
 
    if (ret != ERROR_SUCCESS &&
        ret != ERROR_CANCELLED) {
 
        MessageBox(lpcmi->hwnd,
            SystemMessage(ret), VFD_MSGBOX_TITLE, MB_ICONSTOP);
    }
 
    return NOERROR;
}

QueryContextMenu()

STDMETHODIMP CVfdShExt::QueryContextMenu	(	HMENU	hMenu,
		UINT	indexMenu,
		UINT	idCmdFirst,
		UINT	idCmdLast,
		UINT	uFlags
	)

Implements IContextMenu.

Definition at line 106 of file vfdshmenu.cpp.

{
    UNREFERENCED_PARAMETER(idCmdLast);
    VFDTRACE(0, ("CVfdShExt::QueryContextMenu()\n"));
 
    //
    //  Check if menu items should be added
    //
    if ((CMF_DEFAULTONLY & uFlags) ||
        !m_pDataObj || m_nDevice == (ULONG)-1) {
 
        VFDTRACE(0, ("Don't add any items.\n"));
        return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
    }
 
    //
    //  Drag & Drop handler?
    //
    if (m_bDragDrop) {
 
        VFDTRACE(0, ("Invoked as the Drop handler.\n"));
 
        if (GetFileAttributes(m_sTarget) & FILE_ATTRIBUTE_DIRECTORY) {
 
            // if the dropped item is a directory, nothing to do here
            VFDTRACE(0, ("Dropped object is a directory.\n"));
 
            return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
        }
 
        //  Add a drop context menu item
        AddMenuItem(
            hMenu,
            indexMenu,
            MF_BYPOSITION | MF_STRING,
            idCmdFirst + VFD_CMD_DROP,
            g_VfdMenu[VFD_CMD_DROP].textid);
 
        return MAKE_HRESULT(SEVERITY_SUCCESS, 0, VFD_CMD_DROP + 1);
    }
 
    //
    //  Context menu handler
    //
    VFDTRACE(0, ("Invoked as the context menu handler.\n"));
 
    //
    //  Get the VFD media state
    //
    HANDLE hDevice = VfdOpenDevice(m_nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        VFDTRACE(0, ("device open failed.\n"));
        return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
    }
 
    DWORD status = VfdGetMediaState(hDevice);
 
    CloseHandle(hDevice);
 
    //
    //  Add context menu items
    //
 
    InsertMenu(hMenu, indexMenu++,
        MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
 
    if (status == ERROR_SUCCESS ||
        status == ERROR_WRITE_PROTECT) {
 
        //  An image is opened
 
        //  insert the "save" menu item
 
        AddMenuItem(
            hMenu,
            indexMenu++,
            MF_BYPOSITION | MF_STRING,
            idCmdFirst + VFD_CMD_SAVE,
            g_VfdMenu[VFD_CMD_SAVE].textid);
 
        //  insert the "close" menu item
 
        AddMenuItem(
            hMenu,
            indexMenu++,
            MF_BYPOSITION | MF_STRING,
            idCmdFirst + VFD_CMD_CLOSE,
            g_VfdMenu[VFD_CMD_CLOSE].textid);
 
        //  insert the "protect" menu item
 
        AddMenuItem(
            hMenu,
            indexMenu++,
            MF_BYPOSITION | MF_STRING,
            idCmdFirst + VFD_CMD_PROTECT,
            g_VfdMenu[VFD_CMD_PROTECT].textid);
 
        //  check "protect" menu item
 
        if (status == ERROR_WRITE_PROTECT) {
            CheckMenuItem(hMenu, indexMenu - 1,
                MF_BYPOSITION | MF_CHECKED);
        }
    }
    else {
        //  The drive is empty
 
        //  insert the "open" menu item
 
        AddMenuItem(
            hMenu,
            indexMenu++,
            MF_BYPOSITION | MF_STRING,
            idCmdFirst + VFD_CMD_OPEN,
            g_VfdMenu[VFD_CMD_OPEN].textid);
    }
 
    //  Insert the "proterty" menu item
 
    AddMenuItem(
        hMenu,
        indexMenu++,
        MF_BYPOSITION | MF_STRING,
        idCmdFirst + VFD_CMD_PROP,
        g_VfdMenu[VFD_CMD_PROP].textid);
 
    //  Insert a separator
 
    InsertMenu(hMenu, indexMenu,
        MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
 
    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, VFD_CMD_PROP + 1);
}

QueryInterface()

STDMETHODIMP CVfdShExt::QueryInterface	(	REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 55 of file vfdshext.cpp.

{
    *ppv = NULL;
 
    if (IsEqualIID(riid, IID_IShellExtInit) ||
        IsEqualIID(riid, IID_IUnknown)) {
        VFDTRACE(0,
            ("CVfdShExt::QueryInterface()==>IID_IShellExtInit\n"));
 
        *ppv = (LPSHELLEXTINIT)this;
    }
    else if (IsEqualIID(riid, IID_IContextMenu)) {
        VFDTRACE(0,
            ("CVfdShExt::QueryInterface()==>IID_IContextMenu\n"));
 
        *ppv = (LPCONTEXTMENU)this;
    }
    else if (IsEqualIID(riid, IID_IShellPropSheetExt)) {
        VFDTRACE(0,
            ("CVfdShExt::QueryInterface()==>IID_IShellPropSheetExt\n"));
 
        *ppv = (LPSHELLPROPSHEETEXT)this;
    }
 
    if (*ppv) {
        AddRef();
 
        return NOERROR;
    }
 
    VFDTRACE(0,
        ("CVfdShExt::QueryInterface()==>Unknown Interface!\n"));
 
    return E_NOINTERFACE;
}

Referenced by CVfdFactory::CreateInstance().

ReplacePage()

STDMETHODIMP CVfdShExt::ReplacePage	(	UINT	uPageID,
		LPFNADDPROPSHEETPAGE	lpfnReplaceWith,
		LPARAM	lParam
	)

Definition at line 454 of file vfdshprop.cpp.

{
    UNREFERENCED_PARAMETER(uPageID);
    UNREFERENCED_PARAMETER(lpfnReplaceWith);
    UNREFERENCED_PARAMETER(lParam);
    return E_FAIL;
}

STDMETHODIMP_() [1/2]

CVfdShExt::STDMETHODIMP_

(

ULONG

)

STDMETHODIMP_() [2/2]

CVfdShExt::STDMETHODIMP_

(

ULONG

)

Member Data Documentation

m_bDragDrop

BOOL CVfdShExt::m_bDragDrop

protected

Definition at line 28 of file vfdshext.h.

Referenced by CVfdShExt(), Initialize(), and QueryContextMenu().

m_cRefCnt

ULONG CVfdShExt::m_cRefCnt

protected

Definition at line 24 of file vfdshext.h.

Referenced by CVfdShExt(), and STDMETHODIMP_().

m_nDevice

ULONG CVfdShExt::m_nDevice

protected

Definition at line 26 of file vfdshext.h.

Referenced by AddPages(), CVfdShExt(), DoVfdClose(), DoVfdDrop(), DoVfdOpen(), DoVfdProtect(), DoVfdSave(), GetDevice(), Initialize(), InvokeCommand(), and QueryContextMenu().

m_pDataObj

LPDATAOBJECT CVfdShExt::m_pDataObj

protected

Definition at line 25 of file vfdshext.h.

Referenced by AddPages(), CVfdShExt(), Initialize(), QueryContextMenu(), and ~CVfdShExt().

m_sTarget

CHAR CVfdShExt::m_sTarget[MAX_PATH]

protected

Definition at line 27 of file vfdshext.h.

Referenced by CVfdShExt(), DoVfdDrop(), GetTarget(), Initialize(), InvokeCommand(), and QueryContextMenu().

---

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

• modules/rosapps/lib/vfdlib/vfdshext.h
• modules/rosapps/lib/vfdlib/vfdshext.cpp
• modules/rosapps/lib/vfdlib/vfdshmenu.cpp
• modules/rosapps/lib/vfdlib/vfdshprop.cpp