ReactOS  0.4.13-dev-651-g5dbc677
vfdshmenu.cpp
Go to the documentation of this file.
1 /*
2  vfdshmenu.cpp
3 
4  Virtual Floppy Drive for Windows
5  Driver control library
6  COM shell extension class context menu functions
7 
8  Copyright (c) 2003-2005 Ken Kato
9 */
10 
11 #define WIN32_LEAN_AND_MEAN
12 #include <windows.h>
13 #include <shellapi.h>
14 #include <shlobj.h>
15 
16 #include "vfdtypes.h"
17 #include "vfdapi.h"
18 #include "vfdlib.h"
19 #ifndef __REACTOS__
20 #include "vfdmsg.h"
21 #else
22 #include "vfdmsg_lib.h"
23 #endif
24 
25 // class header
26 #include "vfdshext.h"
27 
28 //
29 // Undocumented windows API to handle shell property sheets
30 //
31 
33  HWND hwnd, DWORD dwType, LPCWSTR lpObject, LPCWSTR lpPage);
34 
35 #ifndef SHOP_FILEPATH
36 #define SHOP_FILEPATH 0x00000002
37 #endif
38 
39 #define SHOP_EXPORT_ORDINAL 178
40 
41 //
42 // Context Menu Items
43 //
44 enum {
52 };
53 
54 static struct _vfd_menu {
55  UINT textid; // menu item text id
56  UINT helpid; // menu item help id
57 #ifndef __REACTOS__
58  PCHAR verbA; // ansi verb text
59  PWCHAR verbW; // unicode verb text
60 #else
61  LPCSTR verbA; // ansi verb text
62  LPCWSTR verbW; // unicode verb text
63 #endif
64 }
66  { MSG_MENU_OPEN, MSG_HELP_OPEN, "vfdopen", L"vfdopen" },
67  { MSG_MENU_SAVE, MSG_HELP_SAVE, "vfdsave", L"vfdsave" },
68  { MSG_MENU_CLOSE, MSG_HELP_CLOSE, "vfdclose", L"vfdclose" },
69  { MSG_MENU_PROTECT, MSG_HELP_PROTECT, "protect", L"protect" },
70  { MSG_MENU_DROP, MSG_HELP_DROP, "vfddrop", L"vfddrop" },
71  { MSG_MENU_PROP, MSG_HELP_PROP, "vfdprop", L"vfdprop" },
72 };
73 
74 //
75 // local functions
76 //
77 static void AddMenuItem(
78  HMENU hMenu,
79  UINT uPos,
80  UINT uFlags,
81  UINT uCmd,
82  UINT uText)
83 {
84  PSTR text = ModuleMessage(uText);
85 
86  if (text) {
87  InsertMenu(hMenu, uPos, uFlags, uCmd, text);
88  LocalFree(text);
89  }
90 }
91 
92 
93 //
94 // FUNCTION: CVfdShExt::QueryContextMenu(HMENU, UINT, UINT, UINT, UINT)
95 //
96 // PURPOSE: Called by the shell just before the context menu is displayed.
97 // This is where you add your specific menu items.
98 //
99 // PARAMETERS:
100 // hMenu - Handle to the context menu
101 // indexMenu - Index of where to begin inserting menu items
102 // idCmdFirst - Lowest value for new menu ID's
103 // idCmtLast - Highest value for new menu ID's
104 // uFlags - Specifies the context of the menu event
105 //
107  HMENU hMenu,
108  UINT indexMenu,
109  UINT idCmdFirst,
110  UINT idCmdLast,
111  UINT uFlags)
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
142  AddMenuItem(
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 
185  AddMenuItem(
186  hMenu,
187  indexMenu++,
189  idCmdFirst + VFD_CMD_SAVE,
190  g_VfdMenu[VFD_CMD_SAVE].textid);
191 
192  // insert the "close" menu item
193 
194  AddMenuItem(
195  hMenu,
196  indexMenu++,
198  idCmdFirst + VFD_CMD_CLOSE,
199  g_VfdMenu[VFD_CMD_CLOSE].textid);
200 
201  // insert the "protect" menu item
202 
203  AddMenuItem(
204  hMenu,
205  indexMenu++,
207  idCmdFirst + VFD_CMD_PROTECT,
208  g_VfdMenu[VFD_CMD_PROTECT].textid);
209 
210  // check "protect" menu item
211 
212  if (status == ERROR_WRITE_PROTECT) {
213  CheckMenuItem(hMenu, indexMenu - 1,
215  }
216  }
217  else {
218  // The drive is empty
219 
220  // insert the "open" menu item
221 
222  AddMenuItem(
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 
232  AddMenuItem(
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 }
246 
247 //
248 // FUNCTION: CVfdShExt::GetCommandString(LPCMINVOKECOMMANDINFO)
249 //
250 // PURPOSE: Retrieves information about a shortcut menu command,
251 // including the Help string and the language-independent,
252 // or canonical, name for the command.
253 //
254 // PARAMETERS:
255 // idCmd - Menu command identifier offset.
256 // uFlags - Flags specifying the information to return.
257 // This parameter can have one of the following values.
258 // GCS_HELPTEXTA Sets pszName to an ANSI string containing the Help text for the command.
259 // GCS_HELPTEXTW Sets pszName to a Unicode string containing the Help text for the command.
260 // GCS_VALIDATEA Returns S_OK if the menu item exists, or S_FALSE otherwise.
261 // GCS_VALIDATEW Returns S_OK if the menu item exists, or S_FALSE otherwise.
262 // GCS_VERBA Sets pszName to an ANSI string containing the language-independent command name for the menu item.
263 // GCS_VERBW Sets pszName to a Unicode string containing the language-independent command name for the menu item.
264 // pwReserved - Reserved. Applications must specify NULL when calling this method, and handlers must ignore this parameter when called.
265 // pszName - Address of the buffer to receive the null-terminated string being retrieved.
266 // cchMax - Size of the buffer to receive the null-terminated string.
267 //
268 
270 #ifndef __REACTOS__
271  UINT idCmd,
272 #else
273  UINT_PTR idCmd,
274 #endif
275  UINT uFlags,
276  UINT *reserved,
277  LPSTR pszName,
278  UINT cchMax)
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 }
321 
322 //
323 // FUNCTION: CVfdShExt::InvokeCommand(LPCMINVOKECOMMANDINFO)
324 //
325 // PURPOSE: Called by the shell after the user has selected on of the
326 // menu items that was added in QueryContextMenu().
327 //
328 // PARAMETERS:
329 // lpcmi - Pointer to an CMINVOKECOMMANDINFO structure
330 //
331 
333  LPCMINVOKECOMMANDINFO lpcmi)
334 {
335  VFDTRACE(0, ("CVfdShExt::InvokeCommand()\n"));
336 
337  BOOL unicode = FALSE;
338  UINT id;
339  DWORD ret;
341 
342  if (lpcmi->cbSize >= sizeof(CMINVOKECOMMANDINFOEX) &&
343  (lpcmi->fMask & CMIC_MASK_UNICODE)) {
344 
345  unicode = TRUE;
346  }
347 
348 
349  if (!unicode && HIWORD(lpcmi->lpVerb)) {
350 
351  VFDTRACE(0, ("ANSI: %s\n", lpcmi->lpVerb));
352 
353  // ANSI verb
354  for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
355  if (!lstrcmpi(lpcmi->lpVerb, g_VfdMenu[id].verbA)) {
356  break;
357  }
358  }
359  }
360  else if (unicode && HIWORD(excmi->lpVerbW)) {
361 
362  VFDTRACE(0, ("UNICODE: %ws\n", excmi->lpVerbW));
363 
364  // UNICODE verb
365  for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
366  if (!lstrcmpiW(excmi->lpVerbW, g_VfdMenu[id].verbW)) {
367  break;
368  }
369  }
370  }
371  else {
372 
373  VFDTRACE(0, ("Command: %u\n", LOWORD(lpcmi->lpVerb)));
374 
375  // Command ID
376  id = LOWORD(lpcmi->lpVerb);
377  }
378 
379  VFDTRACE(0, ("MenuItem: %u\n", id));
380 
381  switch (id) {
382  case VFD_CMD_OPEN:
383  ret = DoVfdOpen(lpcmi->hwnd);
384 
385  if (ret == ERROR_SUCCESS) {
386  VfdImageTip(lpcmi->hwnd, m_nDevice);
387  }
388  break;
389 
390  case VFD_CMD_SAVE:
391  ret = DoVfdSave(lpcmi->hwnd);
392  break;
393 
394  case VFD_CMD_CLOSE:
395  ret = DoVfdClose(lpcmi->hwnd);
396  break;
397 
398  case VFD_CMD_PROTECT:
399  ret = DoVfdProtect(lpcmi->hwnd);
400 
401  if (ret == ERROR_SUCCESS) {
402  VfdImageTip(lpcmi->hwnd, m_nDevice);
403  }
404  else if (ret == ERROR_WRITE_PROTECT) {
405  VfdImageTip(lpcmi->hwnd, m_nDevice);
406  ret = ERROR_SUCCESS;
407  }
408  break;
409 
410  case VFD_CMD_DROP:
411  ret = DoVfdDrop(lpcmi->hwnd);
412 
413  if (ret == ERROR_SUCCESS) {
414  VfdImageTip(lpcmi->hwnd, m_nDevice);
415  }
416  break;
417 
418  case VFD_CMD_PROP:
419  {
420  SHOBJECTPROPERTIES pSHObjectProperties;
421  WCHAR path[4] = L" :\\";
422 
423  pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
424  LoadLibrary("shell32"), "SHObjectProperties");
425 
426  if (!pSHObjectProperties) {
427  pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
428  LoadLibrary("shell32"), (LPCSTR)SHOP_EXPORT_ORDINAL);
429  }
430 
431  if (pSHObjectProperties) {
432  path[0] = m_sTarget[0];
433 
434  pSHObjectProperties(lpcmi->hwnd,
435  SHOP_FILEPATH, path, L"VFD");
436  }
437  }
438  ret = ERROR_SUCCESS;
439  break;
440 
441  default:
442  return E_INVALIDARG;
443  }
444 
445  if (ret != ERROR_SUCCESS &&
446  ret != ERROR_CANCELLED) {
447 
448  MessageBox(lpcmi->hwnd,
450  }
451 
452  return NOERROR;
453 }
454 
455 //=====================================
456 // perform VFD menu operation
457 //=====================================
458 
460  HWND hParent)
461 {
463 
464  if (ret != ERROR_SUCCESS && ret != ERROR_CANCELLED) {
467  }
468 
469  return ret;
470 }
471 
472 //
473 // Save the VFD image
474 //
476  HWND hParent)
477 {
478  return VfdGuiSave(hParent, m_nDevice);
479 }
480 
481 //
482 // Close current VFD image
483 //
485  HWND hParent)
486 {
487  return VfdGuiClose(hParent, m_nDevice);
488 }
489 
490 //
491 // Enable/disable media write protection
492 //
494  HWND hParent)
495 {
496  HANDLE hDevice;
497  DWORD ret;
498 
500  VFDTRACE(0, ("CVfdShExt::DoVfdProtect()\n"));
501 
502  hDevice = VfdOpenDevice(m_nDevice);
503 
504  if (hDevice == INVALID_HANDLE_VALUE) {
505  return GetLastError();
506  }
507 
508  ret = VfdGetMediaState(hDevice);
509 
510  if (ret == ERROR_SUCCESS) {
511  ret = VfdWriteProtect(hDevice, TRUE);
512  }
513  else if (ret == ERROR_WRITE_PROTECT) {
514  ret = VfdWriteProtect(hDevice, FALSE);
515  }
516 
517  if (ret == ERROR_SUCCESS) {
518  ret = VfdGetMediaState(hDevice);
519  }
520 
521  CloseHandle(hDevice);
522 
523  return ret;
524 }
525 
526 //
527 // Open dropped file with VFD
528 //
530  HWND hParent)
531 {
532  HANDLE hDevice;
533  DWORD file_attr;
536 
537  VFD_DISKTYPE disk_type;
538  VFD_MEDIA media_type;
539 
540  DWORD ret;
541 
542  VFDTRACE(0, ("CVfdShExt::DoVfdDropOpen()\n"));
543 
544  // check if dropped file is a valid image
545 
547  m_sTarget, &file_attr, &file_type, &file_size);
548 
549  if (ret != ERROR_SUCCESS) {
550  return ret;
551  }
552 
553  // check file size
554  media_type = VfdLookupMedia(file_size);
555 
556  if (!media_type) {
557  PSTR msg = ModuleMessage(MSG_FILE_TOO_SMALL);
558 
559  MessageBox(hParent, msg ? msg : "Bad size",
561 
562  if (msg) {
563  LocalFree(msg);
564  }
565 
566  return ERROR_CANCELLED;
567  }
568 
569  if ((file_type == VFD_FILETYPE_ZIP) ||
571 
572  disk_type = VFD_DISKTYPE_RAM;
573  }
574  else {
575  disk_type = VFD_DISKTYPE_FILE;
576  }
577 
578  // close current image (if opened)
579 
581 
582  if (ret != ERROR_SUCCESS &&
583  ret != ERROR_NOT_READY) {
584  return ret;
585  }
586 
587  // open dropped file
588 
589  hDevice = VfdOpenDevice(m_nDevice);
590 
591  if (hDevice == INVALID_HANDLE_VALUE) {
592  return GetLastError();
593  }
594 
595  ret = VfdOpenImage(
596  hDevice, m_sTarget, disk_type, media_type, FALSE);
597 
598  CloseHandle(hDevice);
599 
600  return ret;
601 }
signed char * PCHAR
Definition: retypes.h:7
PSTR ModuleMessage(DWORD nFormat,...)
Definition: vfdlib.c:124
#define SHOP_FILEPATH
Definition: vfdshmenu.cpp:36
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
static const WCHAR verbW[]
Definition: main.c:64
static void AddMenuItem(HMENU hMenu, UINT uPos, UINT uFlags, UINT uCmd, UINT uText)
Definition: vfdshmenu.cpp:77
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:398
#define lstrcmpi
Definition: winbase.h:3687
DWORD DoVfdClose(HWND hParent)
Definition: vfdshmenu.cpp:484
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD DoVfdOpen(HWND hParent)
Definition: vfdshmenu.cpp:459
#define LoadLibrary
Definition: winbase.h:3676
#define VFD_MSGBOX_TITLE
Definition: vfdlib.h:53
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
UCHAR VFD_DISKTYPE
Definition: vfdtypes.h:60
STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
Definition: vfdshmenu.cpp:332
#define NOERROR
Definition: winerror.h:2354
STDMETHODIMP QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
Definition: vfdshmenu.cpp:106
#define InsertMenu
Definition: winuser.h:5701
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:323
UINT helpid
Definition: vfdshmenu.cpp:56
#define ERROR_WRITE_PROTECT
Definition: winerror.h:122
LPDATAOBJECT m_pDataObj
Definition: vfdshext.h:25
const WCHAR * text
Definition: package.c:1827
DWORD DoVfdProtect(HWND hParent)
Definition: vfdshmenu.cpp:493
DWORD WINAPI FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:483
#define MF_STRING
Definition: winuser.h:138
PCHAR verbA
Definition: vfdshmenu.cpp:58
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define MB_ICONSTOP
Definition: winuser.h:797
uint16_t * PWCHAR
Definition: typedefs.h:54
UINT uFlags
Definition: api.c:60
char * LPSTR
Definition: xmlstorage.h:182
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 DoVfdSave(HWND hParent)
Definition: vfdshmenu.cpp:475
#define BOOL
Definition: nt_native.h:43
DWORD DoVfdDrop(HWND hParent)
Definition: vfdshmenu.cpp:529
#define SEVERITY_SUCCESS
Definition: winerror.h:64
#define lstrcpynW
Definition: compat.h:397
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
BOOL m_bDragDrop
Definition: vfdshext.h:28
unsigned int BOOL
Definition: ntddk_ex.h:94
VFD_MEDIA WINAPI VfdLookupMedia(ULONG nSize)
Definition: vfdctl.c:3256
#define MF_BYPOSITION
Definition: winuser.h:203
ULONG m_nDevice
Definition: vfdshext.h:26
DWORD WINAPI VfdWriteProtect(HANDLE hDevice, BOOL bProtect)
Definition: vfdctl.c:2484
#define STDMETHODIMP
Definition: basetyps.h:43
r reserved
Definition: btrfs.c:2704
DWORD WINAPI VfdGuiSave(HWND hParent, ULONG nDevice)
Definition: vfdguisave.c:58
#define S_FALSE
Definition: winerror.h:2357
#define E_INVALIDARG
Definition: ddrawi.h:101
PWCHAR verbW
Definition: vfdshmenu.cpp:59
smooth NULL
Definition: ftsmooth.c:416
#define ERROR_NOT_READY
Definition: winerror.h:124
#define MF_SEPARATOR
Definition: winuser.h:137
const char * LPCSTR
Definition: xmlstorage.h:183
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:30
#define FORMAT_MESSAGE_FROM_HMODULE
Definition: winbase.h:403
static struct _vfd_menu g_VfdMenu[VFD_CMD_MAX]
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define MF_CHECKED
Definition: winuser.h:132
#define SHOP_EXPORT_ORDINAL
Definition: vfdshmenu.cpp:39
__wchar_t WCHAR
Definition: xmlstorage.h:180
DWORD WINAPI VfdGuiOpen(HWND hParent, ULONG nDevice)
Definition: vfdguiopen.c:71
PCSTR SystemMessage(DWORD nError)
Definition: vfdlib.c:147
CHAR m_sTarget[MAX_PATH]
Definition: vfdshext.h:27
STDMETHODIMP GetCommandString(UINT idCmd, UINT uFlags, UINT *reserved, LPSTR pszName, UINT cchMax)
Definition: vfdshmenu.cpp:269
DWORD WINAPI VfdGetMediaState(HANDLE hDevice)
Definition: vfdctl.c:1949
#define WINAPI
Definition: msvc.h:8
HINSTANCE g_hDllModule
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD WINAPI CheckMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define VFDTRACE(LEVEL, STRING)
Definition: vfddbg.h:72
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
FD_TYPE file_type(FDSC **curr, char *fixed)
Definition: file.c:221
#define FILE_ATTRIBUTE_COMPRESSED
Definition: nt_native.h:711
UINT cchMax
int ret
UCHAR VFD_FILETYPE
Definition: vfdtypes.h:62
static const WCHAR L[]
Definition: oid.c:1250
const DOCKBAR PVOID HWND hParent
Definition: tooldock.h:22
BOOL(WINAPI * SHOBJECTPROPERTIES)(HWND hwnd, DWORD dwType, LPCWSTR lpObject, LPCWSTR lpPage)
Definition: vfdshmenu.cpp:32
#define MessageBox
Definition: winuser.h:5720
void WINAPI VfdImageTip(HWND hParent, ULONG nDevice)
Definition: vfdguitip.c:266
HANDLE WINAPI VfdOpenDevice(ULONG nTarget)
Definition: vfdctl.c:1215
#define GetFileAttributes
Definition: winbase.h:3629
#define FORMAT_MESSAGE_IGNORE_INSERTS
Definition: winbase.h:401
#define FILE_ATTRIBUTE_ENCRYPTED
Definition: ntifs_ex.h:385
#define ERROR_CANCELLED
Definition: winerror.h:726
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
Definition: services.c:325
signed char * PSTR
Definition: retypes.h:7
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
UINT textid
Definition: vfdshmenu.cpp:55
DWORD WINAPI VfdGuiClose(HWND hParent, ULONG nDevice)
Definition: vfdguiut.c:114
unsigned int UINT
Definition: ndis.h:50
#define lstrcpynA
Definition: compat.h:408
#define msg(x)
Definition: auth_time.c:54
#define HIWORD(l)
Definition: typedefs.h:246
unsigned int ULONG
Definition: retypes.h:1
GLenum GLuint id
Definition: glext.h:5579
#define GetProcAddress(x, y)
Definition: compat.h:410
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
#define LOWORD(l)
Definition: pedump.c:82
UCHAR VFD_MEDIA
Definition: vfdtypes.h:61
#define file_size(inode)
Definition: reiserfs_fs.h:1869
Definition: ps.c:97