ReactOS 0.4.15-dev-8419-g7f0e8a3
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 IContextMenuLPCONTEXTMENU
 
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO CMINVOKECOMMANDINFO
 
typedef struct IContextMenu::tagCMINVOKECOMMANDINFOLPCMINVOKECOMMANDINFO
 
typedef struct IContextMenu::tagCMInvokeCommandInfoEx CMINVOKECOMMANDINFOEX
 
typedef struct IContextMenu::tagCMInvokeCommandInfoExLPCMINVOKECOMMANDINFOEX
 
- Public Types inherited from IUnknown
typedef IUnknownLPUNKNOWN
 
- 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 IShellExtInitLPSHELLEXTINIT
 
- Private Types inherited from IUnknown
typedef IUnknownLPUNKNOWN
 
- 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.

27{
28 VFDTRACE(0, ("CVfdShExt::CVfdShExt()\n"));
29
30 m_cRefCnt = 0L;
32 m_nDevice = (ULONG)-1;
33 m_sTarget[0] = '\0';
35
37}
ULONG m_cRefCnt
Definition: vfdshext.h:24
LPDATAOBJECT m_pDataObj
Definition: vfdshext.h:25
CHAR m_sTarget[MAX_PATH]
Definition: vfdshext.h:27
BOOL m_bDragDrop
Definition: vfdshext.h:28
ULONG m_nDevice
Definition: vfdshext.h:26
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define L(x)
Definition: ntvdm.h:50
uint32_t ULONG
Definition: typedefs.h:59
#define VFDTRACE(LEVEL, STRING)
Definition: vfddbg.h:72
UINT g_cDllRefCnt

◆ ~CVfdShExt()

CVfdShExt::~CVfdShExt ( )

Definition at line 42 of file vfdshext.cpp.

43{
44 VFDTRACE(0, ("CVfdShExt::~CVfdShExt()\n"));
45
46 if (m_pDataObj) {
47 m_pDataObj->Release();
48 }
49
51}

Member Function Documentation

◆ AddPages()

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

Definition at line 416 of file vfdshprop.cpp.

419{
420 PROPSHEETPAGE psp;
421 HPROPSHEETPAGE hpage;
422
423 if (!m_pDataObj || m_nDevice == (ULONG)-1) {
424 // not a VFD drive
425 VFDTRACE(0, ("PropPage: Not a VFD drive\n"));
426
427 return NOERROR;
428 }
429
430 psp.dwSize = sizeof(psp); // no extra data.
432 psp.hInstance = g_hDllModule;
433 psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPDIALOG);
434 psp.hIcon = 0;
435 psp.pszTitle = "VFD";
436 psp.pfnDlgProc = VfdPageDlgProc;
437 psp.pcRefParent = &g_cDllRefCnt;
438 psp.pfnCallback = VfdPageCallback;
439 psp.lParam = (LPARAM)this;
440
441 AddRef();
442 hpage = CreatePropertySheetPage(&psp);
443
444 if (hpage) {
445 if (!lpfnAddPage(hpage, lParam)) {
447 Release();
448 }
449 }
450
451 return NOERROR;
452}
LPARAM lParam
Definition: combotst.c:139
BOOL WINAPI DestroyPropertySheetPage(HPROPSHEETPAGE hPropPage)
Definition: propsheet.c:3152
ULONG AddRef()
ULONG Release()
struct _PSP * HPROPSHEETPAGE
Definition: mstask.idl:90
#define CreatePropertySheetPage
Definition: prsht.h:399
#define PSP_USEREFPARENT
Definition: prsht.h:29
#define PSP_USETITLE
Definition: prsht.h:26
#define PSP_USECALLBACK
Definition: prsht.h:30
#define PROPSHEETPAGE
Definition: prsht.h:389
#define IDD_PROPDIALOG
Definition: vfdguirc.h:5
HINSTANCE g_hDllModule
static BOOL CALLBACK VfdPageDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
Definition: vfdshprop.cpp:84
static UINT CALLBACK VfdPageCallback(HWND hWnd, UINT uMessage, LPPROPSHEETPAGE ppsp)
Definition: vfdshprop.cpp:60
LONG_PTR LPARAM
Definition: windef.h:208
#define NOERROR
Definition: winerror.h:2354
#define MAKEINTRESOURCE
Definition: winuser.h:591

◆ DoVfdClose()

DWORD CVfdShExt::DoVfdClose ( HWND  hParent)

Definition at line 488 of file vfdshmenu.cpp.

490{
491 return VfdGuiClose(hParent, m_nDevice);
492}
DWORD WINAPI VfdGuiClose(HWND hParent, ULONG nDevice)
Definition: vfdguiut.c:114

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

◆ DoVfdDrop()

DWORD CVfdShExt::DoVfdDrop ( HWND  hParent)

Definition at line 533 of file vfdshmenu.cpp.

535{
536 HANDLE hDevice;
537 DWORD file_attr;
540
541 VFD_DISKTYPE disk_type;
542 VFD_MEDIA media_type;
543
544 DWORD ret;
545
546 VFDTRACE(0, ("CVfdShExt::DoVfdDropOpen()\n"));
547
548 // check if dropped file is a valid image
549
551 m_sTarget, &file_attr, &file_type, &file_size);
552
553 if (ret != ERROR_SUCCESS) {
554 return ret;
555 }
556
557 // check file size
558 media_type = VfdLookupMedia(file_size);
559
560 if (!media_type) {
561 PSTR msg = ModuleMessage(MSG_FILE_TOO_SMALL);
562
563 MessageBox(hParent, msg ? msg : "Bad size",
565
566 if (msg) {
567 LocalFree(msg);
568 }
569
570 return ERROR_CANCELLED;
571 }
572
573 if ((file_type == VFD_FILETYPE_ZIP) ||
575
576 disk_type = VFD_DISKTYPE_RAM;
577 }
578 else {
579 disk_type = VFD_DISKTYPE_FILE;
580 }
581
582 // close current image (if opened)
583
584 ret = DoVfdClose(hParent);
585
586 if (ret != ERROR_SUCCESS &&
587 ret != ERROR_NOT_READY) {
588 return ret;
589 }
590
591 // open dropped file
592
593 hDevice = VfdOpenDevice(m_nDevice);
594
595 if (hDevice == INVALID_HANDLE_VALUE) {
596 return GetLastError();
597 }
598
600 hDevice, m_sTarget, disk_type, media_type, FALSE);
601
602 CloseHandle(hDevice);
603
604 return ret;
605}
#define msg(x)
Definition: auth_time.c:54
DWORD DoVfdClose(HWND hParent)
Definition: vfdshmenu.cpp:488
#define ERROR_SUCCESS
Definition: deptool.c:10
#define CloseHandle
Definition: compat.h:739
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
unsigned long DWORD
Definition: ntddk_ex.h:95
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define FILE_ATTRIBUTE_COMPRESSED
Definition: nt_native.h:711
#define FILE_ATTRIBUTE_ENCRYPTED
Definition: ntifs_ex.h:385
static unsigned int file_size
Definition: regtests2xml.c:47
FD_TYPE file_type(FDSC **curr, char *fixed)
Definition: file.c:221
char * PSTR
Definition: typedefs.h:51
VFD_MEDIA WINAPI VfdLookupMedia(ULONG nSize)
Definition: vfdctl.c:3256
HANDLE WINAPI VfdOpenDevice(ULONG nTarget)
Definition: vfdctl.c:1215
DWORD WINAPI VfdCheckImageFile(PCSTR sFileName, PDWORD pAttributes, PVFD_FILETYPE pFileType, PULONG pImageSize)
Definition: vfdctl.c:3035
NTSTATUS VfdOpenImage(IN PDEVICE_EXTENSION DeviceExtension, IN PVFD_IMAGE_INFO ImageInfo)
Definition: vfdimg.c:104
PSTR ModuleMessage(DWORD nFormat,...)
Definition: vfdlib.c:124
#define VFD_MSGBOX_TITLE
Definition: vfdlib.h:53
UCHAR VFD_FILETYPE
Definition: vfdtypes.h:62
UCHAR VFD_MEDIA
Definition: vfdtypes.h:61
UCHAR VFD_DISKTYPE
Definition: vfdtypes.h:60
@ VFD_DISKTYPE_FILE
Definition: vfdtypes.h:18
@ VFD_DISKTYPE_RAM
Definition: vfdtypes.h:19
@ VFD_FILETYPE_ZIP
Definition: vfdtypes.h:53
int ret
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define ERROR_NOT_READY
Definition: winerror.h:124
#define ERROR_CANCELLED
Definition: winerror.h:726
#define MessageBox
Definition: winuser.h:5831
#define MB_ICONSTOP
Definition: winuser.h:803

Referenced by InvokeCommand().

◆ DoVfdNew()

DWORD CVfdShExt::DoVfdNew ( HWND  hParent)

◆ DoVfdOpen()

DWORD CVfdShExt::DoVfdOpen ( HWND  hParent)

Definition at line 463 of file vfdshmenu.cpp.

465{
466 DWORD ret = VfdGuiOpen(hParent, m_nDevice);
467
468 if (ret != ERROR_SUCCESS && ret != ERROR_CANCELLED) {
469 MessageBox(hParent, SystemMessage(ret),
471 }
472
473 return ret;
474}
DWORD WINAPI VfdGuiOpen(HWND hParent, ULONG nDevice)
Definition: vfdguiopen.c:71
PCSTR SystemMessage(DWORD nError)
Definition: vfdlib.c:147

Referenced by InvokeCommand(), and VfdPageDlgProc().

◆ DoVfdProtect()

DWORD CVfdShExt::DoVfdProtect ( HWND  hParent)

Definition at line 497 of file vfdshmenu.cpp.

499{
500 HANDLE hDevice;
501 DWORD ret;
502
503 UNREFERENCED_PARAMETER(hParent);
504 VFDTRACE(0, ("CVfdShExt::DoVfdProtect()\n"));
505
506 hDevice = VfdOpenDevice(m_nDevice);
507
508 if (hDevice == INVALID_HANDLE_VALUE) {
509 return GetLastError();
510 }
511
512 ret = VfdGetMediaState(hDevice);
513
514 if (ret == ERROR_SUCCESS) {
515 ret = VfdWriteProtect(hDevice, TRUE);
516 }
517 else if (ret == ERROR_WRITE_PROTECT) {
518 ret = VfdWriteProtect(hDevice, FALSE);
519 }
520
521 if (ret == ERROR_SUCCESS) {
522 ret = VfdGetMediaState(hDevice);
523 }
524
525 CloseHandle(hDevice);
526
527 return ret;
528}
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
DWORD WINAPI VfdWriteProtect(HANDLE hDevice, BOOL bProtect)
Definition: vfdctl.c:2484
DWORD WINAPI VfdGetMediaState(HANDLE hDevice)
Definition: vfdctl.c:1949
#define ERROR_WRITE_PROTECT
Definition: winerror.h:122

Referenced by InvokeCommand(), and VfdPageDlgProc().

◆ DoVfdSave()

DWORD CVfdShExt::DoVfdSave ( HWND  hParent)

Definition at line 479 of file vfdshmenu.cpp.

481{
482 return VfdGuiSave(hParent, m_nDevice);
483}
DWORD WINAPI VfdGuiSave(HWND hParent, ULONG nDevice)
Definition: vfdguisave.c:58

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.

279{
280 VFDTRACE(0,
281 ("CVfdShExt::GetCommandString(%u,...)\n", idCmd));
282
284
285 if (idCmd >= sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0])) {
286 return S_FALSE;
287 }
288
289 switch (uFlags) {
290 case GCS_HELPTEXTA:
294 g_hDllModule, g_VfdMenu[idCmd].helpid,
295 0, pszName, cchMax, NULL);
296
297 VFDTRACE(0, ("HELPTEXTA: %s\n", pszName));
298 break;
299
300 case GCS_HELPTEXTW:
304 g_hDllModule, g_VfdMenu[idCmd].helpid,
305 0, (LPWSTR)pszName, cchMax, NULL);
306
307 VFDTRACE(0, ("HELPTEXTW: %ws\n", pszName));
308 break;
309
310 case GCS_VERBA:
311 lstrcpynA(pszName, g_VfdMenu[idCmd].verbA, cchMax);
312 break;
313
314 case GCS_VERBW:
315 lstrcpynW((LPWSTR)pszName, g_VfdMenu[idCmd].verbW, cchMax);
316 break;
317 }
318
319 return NOERROR;
320}
UINT cchMax
UINT uFlags
Definition: api.c:59
#define lstrcpynA
Definition: compat.h:751
#define lstrcpynW
Definition: compat.h:738
DWORD WINAPI FormatMessageW(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:583
DWORD WINAPI FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:483
r reserved
Definition: btrfs.c:3006
static const WCHAR verbW[]
Definition: main.c:64
static struct _vfd_menu g_VfdMenu[VFD_CMD_MAX]
#define FORMAT_MESSAGE_IGNORE_INSERTS
Definition: winbase.h:420
#define FORMAT_MESSAGE_FROM_HMODULE
Definition: winbase.h:422
#define S_FALSE
Definition: winerror.h:2357
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ GetDevice()

ULONG CVfdShExt::GetDevice ( )
inline

Definition at line 44 of file vfdshext.h.

44{ return m_nDevice; }

Referenced by VfdPageDlgProc().

◆ GetTarget()

PCSTR CVfdShExt::GetTarget ( )
inline

Definition at line 45 of file vfdshext.h.

45{ return m_sTarget; }

◆ Initialize()

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

Definition at line 121 of file vfdshext.cpp.

125{
126 CHAR drive = '\0';
127
128 VFDTRACE(0, ("CVfdShExt::Initialize()\n"));
129
130 UNREFERENCED_PARAMETER(hRegKey);
131
132 // Initialize can be called more than once
133
134 if (m_pDataObj) {
135 m_pDataObj->Release();
137 }
138
139 m_nDevice = (ULONG)-1;
140 m_sTarget[0] = '\0';
141
142 // Get the folder name
143 if (SHGetPathFromIDList(pIDFolder, m_sTarget)) {
144
145 // act as a Drag-and-Drop Handler
146
147 VFDTRACE(0, ("Drag-Drop: %s\n", m_sTarget));
148
150 VFDTRACE(0, ("Not a VFD drive\n"));
151 return NOERROR;
152 }
153
154 drive = m_sTarget[0];
156 }
157 else {
158
159 // act as a context menu handler
160
161 VFDTRACE(0, ("Context menu:\n"));
163 }
164
165 // Extract the target object name
166
167 if (pDataObj) {
168
169 STGMEDIUM medium;
170 FORMATETC fmt = {
171 CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL
172 };
173
174 if (SUCCEEDED(pDataObj->GetData(&fmt, &medium))) {
175 if (DragQueryFile((HDROP)medium.hGlobal, (UINT)-1, NULL, 0)) {
176
177 DragQueryFile((HDROP)medium.hGlobal,
178 0, m_sTarget, sizeof(m_sTarget));
179 }
180
181 ReleaseStgMedium(&medium);
182 }
183 }
184
185 VFDTRACE(0, ("Target %s\n", m_sTarget));
186
187 if (!drive) {
188 // Contect menu handler
189 // -- Data object is the target drive
190 drive = m_sTarget[0];
191 }
192
193 HANDLE hDevice = VfdOpenDevice(drive);
194
195 if (hDevice == INVALID_HANDLE_VALUE) {
196 VFDTRACE(0, ("Not a VFD drive\n"));
197 return NOERROR;
198 }
199
201
202 CloseHandle(hDevice);
203
204 if (ret != ERROR_SUCCESS) {
205 m_nDevice = (ULONG)-1;
206 return NOERROR;
207 }
208
209 VFDTRACE(0, ("VFD device %d\n", m_nDevice));
210 // Store the data object
211
212 m_pDataObj = pDataObj;
213 m_pDataObj->AddRef();
214
215 return NOERROR;
216}
#define CF_HDROP
Definition: constants.h:410
void WINAPI ReleaseStgMedium(STGMEDIUM *pmedium)
Definition: ole2.c:2033
#define SUCCEEDED(hr)
Definition: intsafe.h:50
unsigned int UINT
Definition: ndis.h:50
#define DragQueryFile
Definition: shellapi.h:686
#define SHGetPathFromIDList
Definition: shlobj.h:244
Definition: dsound.c:943
DWORD WINAPI VfdGetDeviceNumber(HANDLE hDevice, PULONG pNumber)
Definition: vfdctl.c:2359
#define GetDriveType
Definition: winbase.h:3812
#define DRIVE_REMOVABLE
Definition: winbase.h:251
char CHAR
Definition: xmlstorage.h:175

◆ InvokeCommand()

STDMETHODIMP CVfdShExt::InvokeCommand ( LPCMINVOKECOMMANDINFO  lpcmi)

Implements IContextMenu.

Definition at line 332 of file vfdshmenu.cpp.

334{
335 VFDTRACE(0, ("CVfdShExt::InvokeCommand()\n"));
336
337 BOOL unicode = FALSE;
338 UINT id;
339 DWORD ret;
341
342#ifdef __REACTOS__
343 unicode = lpcmi->cbSize >= FIELD_OFFSET(CMINVOKECOMMANDINFOEX, ptInvoke) &&
344 (lpcmi->fMask & CMIC_MASK_UNICODE);
345#else
346 if (lpcmi->cbSize >= sizeof(CMINVOKECOMMANDINFOEX) &&
347 (lpcmi->fMask & CMIC_MASK_UNICODE)) {
348
349 unicode = TRUE;
350 }
351#endif
352
353 if (!unicode && HIWORD(lpcmi->lpVerb)) {
354
355 VFDTRACE(0, ("ANSI: %s\n", lpcmi->lpVerb));
356
357 // ANSI verb
358 for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
359 if (!lstrcmpi(lpcmi->lpVerb, g_VfdMenu[id].verbA)) {
360 break;
361 }
362 }
363 }
364 else if (unicode && HIWORD(excmi->lpVerbW)) {
365
366 VFDTRACE(0, ("UNICODE: %ws\n", excmi->lpVerbW));
367
368 // UNICODE verb
369 for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
370 if (!lstrcmpiW(excmi->lpVerbW, g_VfdMenu[id].verbW)) {
371 break;
372 }
373 }
374 }
375 else {
376
377 VFDTRACE(0, ("Command: %u\n", LOWORD(lpcmi->lpVerb)));
378
379 // Command ID
380 id = LOWORD(lpcmi->lpVerb);
381 }
382
383 VFDTRACE(0, ("MenuItem: %u\n", id));
384
385 switch (id) {
386 case VFD_CMD_OPEN:
387 ret = DoVfdOpen(lpcmi->hwnd);
388
389 if (ret == ERROR_SUCCESS) {
390 VfdImageTip(lpcmi->hwnd, m_nDevice);
391 }
392 break;
393
394 case VFD_CMD_SAVE:
395 ret = DoVfdSave(lpcmi->hwnd);
396 break;
397
398 case VFD_CMD_CLOSE:
399 ret = DoVfdClose(lpcmi->hwnd);
400 break;
401
402 case VFD_CMD_PROTECT:
403 ret = DoVfdProtect(lpcmi->hwnd);
404
405 if (ret == ERROR_SUCCESS) {
406 VfdImageTip(lpcmi->hwnd, m_nDevice);
407 }
408 else if (ret == ERROR_WRITE_PROTECT) {
409 VfdImageTip(lpcmi->hwnd, m_nDevice);
411 }
412 break;
413
414 case VFD_CMD_DROP:
415 ret = DoVfdDrop(lpcmi->hwnd);
416
417 if (ret == ERROR_SUCCESS) {
418 VfdImageTip(lpcmi->hwnd, m_nDevice);
419 }
420 break;
421
422 case VFD_CMD_PROP:
423 {
424 SHOBJECTPROPERTIES pSHObjectProperties;
425 WCHAR path[4] = L" :\\";
426
427 pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
428 LoadLibrary("shell32"), "SHObjectProperties");
429
430 if (!pSHObjectProperties) {
431 pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
433 }
434
435 if (pSHObjectProperties) {
436 path[0] = m_sTarget[0];
437
438 pSHObjectProperties(lpcmi->hwnd,
439 SHOP_FILEPATH, path, L"VFD");
440 }
441 }
443 break;
444
445 default:
446 return E_INVALIDARG;
447 }
448
449 if (ret != ERROR_SUCCESS &&
450 ret != ERROR_CANCELLED) {
451
452 MessageBox(lpcmi->hwnd,
454 }
455
456 return NOERROR;
457}
DWORD DoVfdProtect(HWND hParent)
Definition: vfdshmenu.cpp:497
DWORD DoVfdDrop(HWND hParent)
Definition: vfdshmenu.cpp:533
DWORD DoVfdOpen(HWND hParent)
Definition: vfdshmenu.cpp:463
DWORD DoVfdSave(HWND hParent)
Definition: vfdshmenu.cpp:479
#define E_INVALIDARG
Definition: ddrawi.h:101
#define GetProcAddress(x, y)
Definition: compat.h:753
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4261
unsigned int BOOL
Definition: ntddk_ex.h:94
GLuint id
Definition: glext.h:5910
struct IContextMenu::tagCMInvokeCommandInfoEx CMINVOKECOMMANDINFOEX
#define LOWORD(l)
Definition: pedump.c:82
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define HIWORD(l)
Definition: typedefs.h:247
void WINAPI VfdImageTip(HWND hParent, ULONG nDevice)
Definition: vfdguitip.c:266
BOOL(WINAPI * SHOBJECTPROPERTIES)(HWND hwnd, DWORD dwType, LPCWSTR lpObject, LPCWSTR lpPage)
Definition: vfdshmenu.cpp:32
#define SHOP_EXPORT_ORDINAL
Definition: vfdshmenu.cpp:39
#define SHOP_FILEPATH
Definition: vfdshmenu.cpp:36
@ VFD_CMD_OPEN
Definition: vfdshmenu.cpp:45
@ VFD_CMD_DROP
Definition: vfdshmenu.cpp:49
@ VFD_CMD_SAVE
Definition: vfdshmenu.cpp:46
@ VFD_CMD_CLOSE
Definition: vfdshmenu.cpp:47
@ VFD_CMD_PROTECT
Definition: vfdshmenu.cpp:48
@ VFD_CMD_PROP
Definition: vfdshmenu.cpp:50
#define LoadLibrary
Definition: winbase.h:3862
#define lstrcmpi
Definition: winbase.h:3873
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ QueryContextMenu()

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

Implements IContextMenu.

Definition at line 106 of file vfdshmenu.cpp.

112{
113 UNREFERENCED_PARAMETER(idCmdLast);
114 VFDTRACE(0, ("CVfdShExt::QueryContextMenu()\n"));
115
116 //
117 // Check if menu items should be added
118 //
119 if ((CMF_DEFAULTONLY & uFlags) ||
120 !m_pDataObj || m_nDevice == (ULONG)-1) {
121
122 VFDTRACE(0, ("Don't add any items.\n"));
123 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
124 }
125
126 //
127 // Drag & Drop handler?
128 //
129 if (m_bDragDrop) {
130
131 VFDTRACE(0, ("Invoked as the Drop handler.\n"));
132
134
135 // if the dropped item is a directory, nothing to do here
136 VFDTRACE(0, ("Dropped object is a directory.\n"));
137
138 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
139 }
140
141 // Add a drop context menu item
143 hMenu,
144 indexMenu,
146 idCmdFirst + VFD_CMD_DROP,
147 g_VfdMenu[VFD_CMD_DROP].textid);
148
150 }
151
152 //
153 // Context menu handler
154 //
155 VFDTRACE(0, ("Invoked as the context menu handler.\n"));
156
157 //
158 // Get the VFD media state
159 //
160 HANDLE hDevice = VfdOpenDevice(m_nDevice);
161
162 if (hDevice == INVALID_HANDLE_VALUE) {
163 VFDTRACE(0, ("device open failed.\n"));
164 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
165 }
166
167 DWORD status = VfdGetMediaState(hDevice);
168
169 CloseHandle(hDevice);
170
171 //
172 // Add context menu items
173 //
174
175 InsertMenu(hMenu, indexMenu++,
177
178 if (status == ERROR_SUCCESS ||
180
181 // An image is opened
182
183 // insert the "save" menu item
184
186 hMenu,
187 indexMenu++,
189 idCmdFirst + VFD_CMD_SAVE,
190 g_VfdMenu[VFD_CMD_SAVE].textid);
191
192 // insert the "close" menu item
193
195 hMenu,
196 indexMenu++,
198 idCmdFirst + VFD_CMD_CLOSE,
199 g_VfdMenu[VFD_CMD_CLOSE].textid);
200
201 // insert the "protect" menu item
202
204 hMenu,
205 indexMenu++,
207 idCmdFirst + VFD_CMD_PROTECT,
208 g_VfdMenu[VFD_CMD_PROTECT].textid);
209
210 // check "protect" menu item
211
213 CheckMenuItem(hMenu, indexMenu - 1,
215 }
216 }
217 else {
218 // The drive is empty
219
220 // insert the "open" menu item
221
223 hMenu,
224 indexMenu++,
226 idCmdFirst + VFD_CMD_OPEN,
227 g_VfdMenu[VFD_CMD_OPEN].textid);
228 }
229
230 // Insert the "proterty" menu item
231
233 hMenu,
234 indexMenu++,
236 idCmdFirst + VFD_CMD_PROP,
237 g_VfdMenu[VFD_CMD_PROP].textid);
238
239 // Insert a separator
240
241 InsertMenu(hMenu, indexMenu,
243
245}
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:30
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
Definition: ps.c:97
static void AddMenuItem(HMENU hMenu, UINT uPos, UINT uFlags, UINT uCmd, UINT uText)
Definition: vfdshmenu.cpp:77
#define GetFileAttributes
Definition: winbase.h:3815
#define SEVERITY_SUCCESS
Definition: winerror.h:64
#define MF_STRING
Definition: winuser.h:138
#define MF_CHECKED
Definition: winuser.h:132
DWORD WINAPI CheckMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define MF_SEPARATOR
Definition: winuser.h:137
#define MF_BYPOSITION
Definition: winuser.h:203
#define InsertMenu
Definition: winuser.h:5812

◆ QueryInterface()

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

Definition at line 55 of file vfdshext.cpp.

58{
59 *ppv = NULL;
60
61 if (IsEqualIID(riid, IID_IShellExtInit) ||
63 VFDTRACE(0,
64 ("CVfdShExt::QueryInterface()==>IID_IShellExtInit\n"));
65
66 *ppv = (LPSHELLEXTINIT)this;
67 }
68 else if (IsEqualIID(riid, IID_IContextMenu)) {
69 VFDTRACE(0,
70 ("CVfdShExt::QueryInterface()==>IID_IContextMenu\n"));
71
72 *ppv = (LPCONTEXTMENU)this;
73 }
74 else if (IsEqualIID(riid, IID_IShellPropSheetExt)) {
75 VFDTRACE(0,
76 ("CVfdShExt::QueryInterface()==>IID_IShellPropSheetExt\n"));
77
78 *ppv = (LPSHELLPROPSHEETEXT)this;
79 }
80
81 if (*ppv) {
82 AddRef();
83
84 return NOERROR;
85 }
86
87 VFDTRACE(0,
88 ("CVfdShExt::QueryInterface()==>Unknown Interface!\n"));
89
90 return E_NOINTERFACE;
91}
const GUID IID_IUnknown
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
IContextMenu * LPCONTEXTMENU
Definition: shobjidl.idl:1672
IShellExtInit * LPSHELLEXTINIT
Definition: shobjidl.idl:1290
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define E_NOINTERFACE
Definition: winerror.h:2364

Referenced by CVfdFactory::CreateInstance().

◆ ReplacePage()

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

Definition at line 454 of file vfdshprop.cpp.

458{
459 UNREFERENCED_PARAMETER(uPageID);
460 UNREFERENCED_PARAMETER(lpfnReplaceWith);
462 return E_FAIL;
463}
#define E_FAIL
Definition: ddrawi.h:102

◆ 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

◆ 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: