2 * Shell Ordinal Functions
4 * These are completely undocumented. The meaning of the functions changes
5 * between different OS versions (NT uses Unicode strings, 95 uses ASCII
8 * They are just here so that explorer.exe and iexplore.exe can be tested.
10 * Copyright 1997 Marcus Meissner
27 #include "cursoricon.h"
28 #include "interfaces.h"
33 #include "winversion.h"
34 #include "shell32_main.h"
36 /*************************************************************************
37 * SHChangeNotifyRegister [SHELL32.2]
39 * Idlist is an array of structures and Count specifies how many items in the array
40 * (usually just one I think).
43 SHChangeNotifyRegister(
50 { FIXME(shell
,"(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
51 hwnd
,events1
,events2
,msg
,count
,idlist
);
54 /*************************************************************************
55 * SHChangeNotifyDeregister [SHELL32.4]
58 SHChangeNotifyDeregister(LONG x1
)
59 { FIXME(shell
,"(0x%08lx):stub.\n",x1
);
63 /*************************************************************************
64 * ParseField [SHELL32.58]
67 DWORD WINAPI
ParseField32A(LPCSTR src
, DWORD field
, LPSTR dst
, DWORD len
)
68 { WARN(shell
,"('%s',0x%08lx,%p,%ld) semi-stub.\n",src
,field
,dst
,len
);
70 if (!src
|| !src
[0] || !dst
|| !len
)
76 { if (*src
==0x0) return FALSE
;
77 if (*src
==',') field
--;
82 while (*src
!=0x00 && *src
!=',' && len
>0)
83 { *dst
=*src
; dst
++, src
++; len
--;
90 /*************************************************************************
91 * PickIconDlg [SHELL32.62]
94 DWORD WINAPI
PickIconDlg(DWORD x
,DWORD y
,DWORD z
,DWORD a
)
95 { FIXME(shell
,"(%08lx,%08lx,%08lx,%08lx):stub.\n",x
,y
,z
,a
);
99 /*************************************************************************
100 * GetFileNameFromBrowse [SHELL32.63]
103 DWORD WINAPI
GetFileNameFromBrowse(HWND32 howner
, LPSTR targetbuf
, DWORD len
, DWORD x
, LPCSTR suffix
, LPCSTR y
, LPCSTR cmd
)
104 { FIXME(shell
,"(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
105 howner
,targetbuf
,len
,x
,suffix
,y
,cmd
);
106 /* puts up a Open Dialog and requests input into targetbuf */
107 /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
108 lstrcpy32A(targetbuf
,"x:\\dummy.exe");
112 /*************************************************************************
113 * SHGetSettings [SHELL32.68]
116 DWORD WINAPI
SHGetSettings(DWORD x
,DWORD y
,DWORD z
)
117 { FIXME(shell
,"(0x%08lx,0x%08lx,0x%08lx):stub.\n",x
,y
,z
);
121 /*************************************************************************
122 * Shell_GetCachedImageIndex [SHELL32.72]
125 void WINAPI
Shell_GetCachedImageIndex(LPVOID x
,DWORD y
,DWORD z
)
126 { if( VERSION_OsIsUnicode())
127 { FIXME(shell
,"(L%s,%08lx,%08lx):stub.\n",debugstr_w((LPWSTR
)x
),y
,z
);
130 { FIXME(shell
,"(%s,%08lx,%08lx):stub.\n",debugstr_a((LPSTR
)x
),y
,z
);
134 /*************************************************************************
135 * SHShellFolderView_Message [SHELL32.73]
138 * hwndCabinet defines the explorer cabinet window that contains the
139 * shellview you need to communicate with
140 * uMsg identifying the SFVM enum to perform
144 * Message SFVM_REARRANGE = 1
145 * This message gets sent when a column gets clicked to instruct the
146 * shell view to re-sort the item list. lParam identifies the column
149 int WINAPI
SHShellFolderView_Message(HWND32 hwndCabinet
,UINT32 uMsg
,LPARAM lParam
)
150 { FIXME(shell
,"%04x %08ux %08lx stub\n",hwndCabinet
,uMsg
,lParam
);
154 /*************************************************************************
155 * OleStrToStrN [SHELL32.78]
158 * exported by ordinal
160 * wrong implemented OleStr is NOT wide string !!!! (jsch)
163 OleStrToStrN (LPSTR lpMulti
, INT32 nMulti
, LPCWSTR lpWide
, INT32 nWide
) {
164 return WideCharToMultiByte (0, 0, lpWide
, nWide
,
165 lpMulti
, nMulti
, NULL
, NULL
);
168 /*************************************************************************
169 * StrToOleStrN [SHELL32.79]
172 * exported by ordinal
174 * wrong implemented OleStr is NOT wide string !!!! (jsch)
177 StrToOleStrN (LPWSTR lpWide
, INT32 nWide
, LPCSTR lpMulti
, INT32 nMulti
) {
178 return MultiByteToWideChar (0, 0, lpMulti
, nMulti
, lpWide
, nWide
);
181 /*************************************************************************
182 * SHCloneSpecialIDList [SHELL32.89]
186 * nFolder [in] CSIDL_xxxxx ??
191 * exported by ordinal
193 LPITEMIDLIST WINAPI
SHCloneSpecialIDList(HWND32 hwndOwner
,DWORD nFolder
,DWORD x3
)
194 { LPITEMIDLIST ppidl
;
195 WARN(shell
,"(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
196 hwndOwner
,nFolder
,x3
);
198 SHGetSpecialFolderLocation(hwndOwner
, nFolder
, &ppidl
);
204 /*************************************************************************
205 * SHGetSpecialFolderPath [SHELL32.175]
208 * exported by ordinal
210 void WINAPI
SHGetSpecialFolderPath(DWORD x1
,DWORD x2
,DWORD x3
,DWORD x4
) {
211 FIXME(shell
,"(0x%04lx,0x%04lx,csidl=0x%04lx,0x%04lx):stub.\n",
216 /*************************************************************************
217 * RegisterShellHook [SHELL32.181]
220 * hwnd [I] window handle
224 * exported by ordinal
226 void WINAPI
RegisterShellHook32(HWND32 hwnd
, DWORD y
) {
227 FIXME(shell
,"(0x%08x,0x%08lx):stub.\n",hwnd
,y
);
230 /*************************************************************************
231 * ShellMessageBoxA [SHELL32.183]
233 * Format and output errormessage.
236 * exported by ordinal
239 ShellMessageBoxA(HMODULE32 hmod
,HWND32 hwnd
,DWORD id
,DWORD x
,DWORD type
,LPVOID arglist
) {
240 char buf
[100],buf2
[100]/*,*buf3*/;
241 /* LPVOID args = &arglist;*/
243 if (!LoadString32A(hmod
,x
,buf
,100))
244 strcpy(buf
,"Desktop");
245 // LoadString32A(hmod,id,buf2,100);
246 /* FIXME: the varargs handling doesn't. */
247 // FormatMessage32A(0x500,buf2,0,0,(LPSTR)&buf3,256,(LPDWORD)&args);
249 FIXME(shell
,"(%08lx,%08lx,%08lx(%s),%08lx(%s),%08lx,%p):stub.\n",
250 (DWORD
)hmod
,(DWORD
)hwnd
,id
,buf2
,x
,buf
,type
,arglist
252 /*MessageBox32A(hwnd,buf3,buf,id|0x10000);*/
255 /*************************************************************************
256 * SHRestricted [SHELL32.100]
258 * walks through policy table, queries <app> key, <type> value, returns
259 * queried (DWORD) value.
260 * {0x00001,Explorer,NoRun}
261 * {0x00002,Explorer,NoClose}
262 * {0x00004,Explorer,NoSaveSettings}
263 * {0x00008,Explorer,NoFileMenu}
264 * {0x00010,Explorer,NoSetFolders}
265 * {0x00020,Explorer,NoSetTaskbar}
266 * {0x00040,Explorer,NoDesktop}
267 * {0x00080,Explorer,NoFind}
268 * {0x00100,Explorer,NoDrives}
269 * {0x00200,Explorer,NoDriveAutoRun}
270 * {0x00400,Explorer,NoDriveTypeAutoRun}
271 * {0x00800,Explorer,NoNetHood}
272 * {0x01000,Explorer,NoStartBanner}
273 * {0x02000,Explorer,RestrictRun}
274 * {0x04000,Explorer,NoPrinterTabs}
275 * {0x08000,Explorer,NoDeletePrinter}
276 * {0x10000,Explorer,NoAddPrinter}
277 * {0x20000,Explorer,NoStartMenuSubFolders}
278 * {0x40000,Explorer,MyDocsOnNet}
279 * {0x80000,WinOldApp,NoRealMode}
282 * exported by ordinal
284 DWORD WINAPI
SHRestricted (DWORD pol
) {
287 FIXME(shell
,"(%08lx):stub.\n",pol
);
288 if (RegOpenKey32A(HKEY_CURRENT_USER
,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey
))
290 /* FIXME: do nothing for now, just return 0 (== "allowed") */
295 /*************************************************************************
296 * SHCreateDirectory [SHELL32.165]
299 * exported by ordinal
300 * not sure about LPSECURITY_ATTRIBUTES
302 DWORD WINAPI
SHCreateDirectory(LPSECURITY_ATTRIBUTES sec
,LPCSTR path
) {
303 TRACE(shell
,"(%p,%s):stub.\n",sec
,path
);
304 if (CreateDirectory32A(path
,sec
))
306 /* SHChangeNotify(8,1,path,0); */
309 if (SHELL32_79(path
,(LPVOID
)x
))
311 FIXME(shell
,"(%08lx,%s):stub.\n",x
,path
);
316 /*************************************************************************
317 * SHFree [SHELL32.195]
320 * free_ptr() - frees memory using IMalloc
321 * exported by ordinal
323 DWORD WINAPI
SHFree(LPVOID x
) {
324 TRACE(shell
,"%p\n",x
);
325 /*return LocalFree32((HANDLE32)x);*/ /* crashes */
326 return HeapFree(GetProcessHeap(),0,x
);
329 /*************************************************************************
330 * SHAlloc [SHELL32.196]
333 * void *task_alloc(DWORD len), uses SHMalloc allocator
334 * exported by ordinal
336 LPVOID WINAPI
SHAlloc(DWORD len
) {
337 /* void * ret = (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT);*/ /* chrashes */
338 void * ret
= (LPVOID
) HeapAlloc(GetProcessHeap(),0,len
);
339 TRACE(shell
,"%lu bytes at %p\n",len
, ret
);
343 /*************************************************************************
344 * OpenRegStream [SHELL32.85]
347 * exported by ordinal
349 DWORD WINAPI
OpenRegStream(DWORD x1
,DWORD x2
,DWORD x3
,DWORD x4
) {
350 FIXME(shell
,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub.\n",
356 /*************************************************************************
357 * SHRegisterDragDrop [SHELL32.86]
360 * exported by ordinal
362 DWORD WINAPI
SHRegisterDragDrop(HWND32 hwnd
,DWORD x2
) {
363 FIXME (shell
, "(0x%08x,0x%08lx):stub.\n", hwnd
, x2
);
367 /*************************************************************************
368 * SHRevokeDragDrop [SHELL32.87]
371 * exported by ordinal
373 DWORD WINAPI
SHRevokeDragDrop(DWORD x
) {
374 FIXME(shell
,"(0x%08lx):stub.\n",x
);
378 /*************************************************************************
379 * RunFileDlg [SHELL32.61]
382 * Original name: RunFileDlg (exported by ordinal)
385 RunFileDlg (HWND32 hwndOwner
, DWORD dwParam1
, DWORD dwParam2
,
386 LPSTR lpszTitle
, LPSTR lpszPrompt
, UINT32 uFlags
)
388 FIXME (shell
,"(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
389 hwndOwner
, dwParam1
, dwParam2
, lpszTitle
, lpszPrompt
, uFlags
);
393 /*************************************************************************
394 * ExitWindowsDialog [SHELL32.60]
397 * exported by ordinal
400 ExitWindowsDialog (HWND32 hwndOwner
)
402 FIXME (shell
,"(0x%08x):stub.\n", hwndOwner
);
406 /*************************************************************************
407 * ArrangeWindows [SHELL32.184]
411 ArrangeWindows (DWORD dwParam1
, DWORD dwParam2
, DWORD dwParam3
,
412 DWORD dwParam4
, DWORD dwParam5
)
414 FIXME (shell
,"(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
415 dwParam1
, dwParam2
, dwParam3
, dwParam4
, dwParam5
);
419 /*************************************************************************
420 * SHCLSIDFromString [SHELL32.147]
423 * exported by ordinal
426 SHCLSIDFromString (DWORD dwParam1
, DWORD dwParam2
)
428 FIXME (shell
,"(0x%lx 0x%lx):stub.\n", dwParam1
, dwParam2
);
429 FIXME (shell
,"(\"%s\" \"%s\"):stub.\n", (LPSTR
)dwParam1
, (LPSTR
)dwParam2
);
435 /*************************************************************************
436 * SignalFileOpen [SHELL32.103]
439 * exported by ordinal
442 SignalFileOpen (DWORD dwParam1
)
444 FIXME (shell
,"(0x%08lx):stub.\n", dwParam1
);
449 /*************************************************************************
450 * SHAddToRecentDocs [SHELL32.234]
453 * uFlags [IN] SHARD_PATH or SHARD_PIDL
454 * pv [IN] string or pidl, NULL clears the list
459 DWORD WINAPI
SHAddToRecentDocs32 (UINT32 uFlags
,LPCVOID pv
)
460 { if (SHARD_PIDL
==uFlags
)
461 { FIXME (shell
,"(0x%08x,pidl=%p):stub.\n", uFlags
,pv
);
464 { FIXME (shell
,"(0x%08x,%s):stub.\n", uFlags
,(char*)pv
);
468 /*************************************************************************
469 * SHFileOperation32 [SHELL32.242]
472 DWORD WINAPI
SHFileOperation32(DWORD x
)
473 { FIXME(shell
,"0x%08lx stub\n",x
);
478 /*************************************************************************
479 * SHFileOperation32A [SHELL32.243]
484 DWORD WINAPI
SHFileOperation32A (LPSHFILEOPSTRUCT32A lpFileOp
)
485 { FIXME (shell
,"(%p):stub.\n", lpFileOp
);
488 /*************************************************************************
489 * SHFileOperation32W [SHELL32.244]
494 DWORD WINAPI
SHFileOperation32W (LPSHFILEOPSTRUCT32W lpFileOp
)
495 { FIXME (shell
,"(%p):stub.\n", lpFileOp
);
499 /*************************************************************************
500 * SHChangeNotify [SHELL32.239]
505 DWORD WINAPI
SHChangeNotify32 (
506 INT32 wEventId
, /* [IN] flags that specifies the event*/
507 UINT32 uFlags
, /* [IN] the meaning of dwItem[1|2]*/
510 { FIXME (shell
,"(0x%08x,0x%08ux,%p,%p):stub.\n", wEventId
,uFlags
,dwItem1
,dwItem2
);
513 /*************************************************************************
514 * SHCreateShellFolderViewEx [SHELL32.174]
517 * see IShellFolder::CreateViewObject
519 HRESULT WINAPI
SHCreateShellFolderViewEx32(
520 LPSHELLVIEWDATA psvcbi
, /*[in ] shelltemplate struct*/
521 LPVOID
* ppv
) /*[out] IShellView pointer*/
522 { FIXME (shell
,"(%p,%p):stub.\n", psvcbi
,ppv
);
525 /*************************************************************************
526 * SHFind_InitMenuPopup [SHELL32.149]
529 * Registers the menu behind the "Start" button
532 * hMenu [in] handel of menu previously created
533 * hWndParent [in] parent window
537 HRESULT WINAPI
SHFind_InitMenuPopup (HMENU32 hMenu
, HWND32 hWndParent
, DWORD w
, DWORD x
)
538 { FIXME(shell
,"hmenu=0x%08x hwnd=0x%08x 0x%08lx 0x%08lx stub\n",
539 hMenu
,hWndParent
,w
,x
);
542 /*************************************************************************
543 * FileMenu_InitMenuPopup [SHELL32.109]
546 HRESULT WINAPI
FileMenu_InitMenuPopup (DWORD hmenu
)
547 { FIXME(shell
,"hmenu=0x%lx stub\n",hmenu
);
550 /*************************************************************************
551 * FileMenu_Create [SHELL32.114]
553 * w retval from LoadBitmapA
557 HRESULT WINAPI
FileMenu_Create (DWORD u
, DWORD v
, DWORD w
, DWORD x
, DWORD z
)
558 { FIXME(shell
,"0x%08lx 0x%08lx hbmp=0x%lx 0x%08lx 0x%08lx stub\n",u
,v
,w
,x
,z
);
561 /*************************************************************************
562 * FileMenu_TrackPopupMenuEx [SHELL32.116]
565 * uFlags [in] according to TrackPopupMenuEx
569 * z could be rect (trace) or TPMPARAMS (TrackPopupMenuEx)
571 HRESULT WINAPI
FileMenu_TrackPopupMenuEx (DWORD t
, DWORD uFlags
, DWORD posX
, DWORD posY
, HWND32 hWndParent
, DWORD z
)
572 { FIXME(shell
,"0x%lx flags=0x%lx posx=0x%lx posy=0x%lx hwndp=0x%x 0x%lx stub\n",
573 t
,uFlags
,posX
,posY
, hWndParent
,z
);
576 /*************************************************************************
577 * SHWinHelp [SHELL32.127]
580 HRESULT WINAPI
SHWinHelp (DWORD v
, DWORD w
, DWORD x
, DWORD z
)
581 { FIXME(shell
,"0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v
,w
,x
,z
);
584 /*************************************************************************
585 * SHRunControlPanel [SHELL32.161]
588 HRESULT WINAPI
SHRunControlPanel (DWORD x
, DWORD z
)
589 { FIXME(shell
,"0x%08lx 0x%08lx stub\n",x
,z
);
592 /*************************************************************************
593 * ShellExecuteEx [SHELL32.291]
596 BOOL32 WINAPI
ShellExecuteEx32 (LPVOID sei
)
597 { if (VERSION_OsIsUnicode())
598 return ShellExecuteEx32W (sei
);
599 return ShellExecuteEx32A (sei
);
601 /*************************************************************************
602 * ShellExecuteEx32A [SHELL32.292]
605 BOOL32 WINAPI
ShellExecuteEx32A (LPSHELLEXECUTEINFO32A sei
)
606 { CHAR szApplicationName
[MAX_PATH
],szCommandline
[MAX_PATH
],szPidl
[20];
609 STARTUPINFO32A startupinfo
;
610 PROCESS_INFORMATION processinformation
;
612 FIXME(shell
,"mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%sstub\n",
613 sei
->fMask
, sei
->hwnd
, sei
->lpVerb
, sei
->lpFile
,
614 sei
->lpParameters
, sei
->lpDirectory
, sei
->nShow
, sei
->lpClass
);
616 ZeroMemory(szApplicationName
,MAX_PATH
);
618 strcpy(szApplicationName
, sei
->lpFile
);
620 ZeroMemory(szCommandline
,MAX_PATH
);
621 if (sei
->lpParameters
)
622 strcpy(szCommandline
, sei
->lpParameters
);
624 if (sei
->fMask
& (SEE_MASK_CLASSKEY
| SEE_MASK_INVOKEIDLIST
| SEE_MASK_ICON
| SEE_MASK_HOTKEY
|
625 SEE_MASK_NOCLOSEPROCESS
| SEE_MASK_CONNECTNETDRV
| SEE_MASK_FLAG_DDEWAIT
|
626 SEE_MASK_DOENVSUBST
| SEE_MASK_FLAG_NO_UI
| SEE_MASK_UNICODE
|
627 SEE_MASK_NO_CONSOLE
| SEE_MASK_ASYNCOK
| SEE_MASK_HMONITOR
))
628 { FIXME (shell
,"flags ignored: 0x%08lx\n", sei
->fMask
);
631 if (sei
->fMask
& SEE_MASK_CLASSNAME
)
632 { HCR_GetExecuteCommand(sei
->lpClass
, (sei
->lpVerb
) ? sei
->lpVerb
: "open", szCommandline
, 256);
635 /* process the IDList */
636 if ( (sei
->fMask
& SEE_MASK_INVOKEIDLIST
) == SEE_MASK_INVOKEIDLIST
) /*0x0c*/
637 { SHGetPathFromIDList32A (sei
->lpIDList
,szApplicationName
);
638 FIXME(shell
,"-- idlist=%p (%s)\n", sei
->lpIDList
, szApplicationName
);
641 { if (sei
->fMask
& SEE_MASK_IDLIST
)
642 { /* %I is the adress of a global item ID*/
643 pos
= strstr(szCommandline
, "%I");
645 { HGLOBAL32 hmem
= SHAllocShared ( sei
->lpIDList
, ILGetSize(sei
->lpIDList
), 0);
646 sprintf(szPidl
,":%li",(DWORD
)SHLockShared(hmem
,0) );
647 SHUnlockShared(hmem
);
649 gap
= strlen(szPidl
);
651 memmove(pos
+gap
,pos
+2,len
);
652 memcpy(pos
,szPidl
,gap
);
658 pos
= strstr(szCommandline
, ",%L"); /* dunno what it means: kill it*/
660 { len
= strlen(pos
)-2;
662 memmove(pos
,pos
+3,len
);
665 FIXME(shell
,"-- %s\n",szCommandline
);
667 ZeroMemory(&startupinfo
,sizeof(STARTUPINFO32A
));
668 startupinfo
.cb
= sizeof(STARTUPINFO32A
);
670 CreateProcess32A(szApplicationName
[0] ? szApplicationName
:NULL
,
671 szCommandline
[0] ? szCommandline
: NULL
,
672 NULL
, NULL
, FALSE
, 0,
673 NULL
, NULL
, &startupinfo
, &processinformation
);
678 /*************************************************************************
679 * ShellExecuteEx [SHELL32.293]
682 BOOL32 WINAPI
ShellExecuteEx32W (LPSHELLEXECUTEINFO32W sei
)
683 { WCHAR szTemp
[MAX_PATH
];
685 FIXME(shell
,"(%p): stub\n",sei
);
687 if (sei
->fMask
& SEE_MASK_IDLIST
)
688 { SHGetPathFromIDList32W (sei
->lpIDList
,szTemp
);
689 TRACE (shell
,"-- idlist=%p (%s)\n", sei
->lpIDList
, debugstr_w(szTemp
));
692 if (sei
->fMask
& SEE_MASK_CLASSNAME
)
693 { TRACE (shell
,"-- classname= %s\n", debugstr_w(sei
->lpClass
));
697 { TRACE (shell
,"-- action=%s\n", debugstr_w(sei
->lpVerb
));
702 static LPUNKNOWN SHELL32_IExplorerInterface
=0;
703 /*************************************************************************
704 * SHSetInstanceExplorer [SHELL32.176]
709 HRESULT WINAPI
SHSetInstanceExplorer (LPUNKNOWN lpUnknown
)
710 { TRACE (shell
,"%p\n", lpUnknown
);
711 SHELL32_IExplorerInterface
= lpUnknown
;
712 return (HRESULT
) lpUnknown
;
714 /*************************************************************************
715 * SHGetInstanceExplorer [SHELL32.256]
718 * gets the interface pointer of the explorer and a reference
720 HRESULT WINAPI
SHGetInstanceExplorer (LPUNKNOWN
* lpUnknown
)
721 { TRACE(shell
,"%p\n", lpUnknown
);
723 *lpUnknown
= SHELL32_IExplorerInterface
;
725 if (!SHELL32_IExplorerInterface
)
728 SHELL32_IExplorerInterface
->lpvtbl
->fnAddRef(SHELL32_IExplorerInterface
);
731 /*************************************************************************
732 * SHFreeUnusedLibraries [SHELL32.123]
737 HRESULT WINAPI
SHFreeUnusedLibraries (void)
738 { FIXME(shell
,"stub\n");
741 /*************************************************************************
742 * DAD_ShowDragImage [SHELL32.137]
747 HRESULT WINAPI
DAD_ShowDragImage (DWORD u
)
748 { FIXME(shell
,"0x%08lx stub\n",u
);
751 /*************************************************************************
752 * FileMenu_Destroy [SHELL32.118]
757 HRESULT WINAPI
FileMenu_Destroy (DWORD u
)
758 { FIXME(shell
,"0x%08lx stub\n",u
);
761 /*************************************************************************
762 * SHGetDataFromIDListA [SHELL32.247]
765 HRESULT WINAPI
SHGetDataFromIDListA(DWORD u
, DWORD v
, DWORD w
, DWORD x
, DWORD y
)
766 { FIXME(shell
,"0x%04lx 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",u
,v
,w
,x
,y
);
769 /*************************************************************************
770 * SHRegCloseKey32 [NT4.0:SHELL32.505]
773 HRESULT WINAPI
SHRegCloseKey32 (HKEY hkey
)
774 { TRACE(shell
,"0x%04x\n",hkey
);
775 return RegCloseKey( hkey
);
777 /*************************************************************************
778 * SHRegOpenKey32A [SHELL32.506]
781 HRESULT WINAPI
SHRegOpenKey32A(HKEY hKey
, LPSTR lpSubKey
, LPHKEY phkResult
)
782 { FIXME(shell
,"(0x%08x, %s, %p)\n", hKey
, debugstr_a(lpSubKey
),
784 return RegOpenKey32A(hKey
, lpSubKey
, phkResult
);
787 /*************************************************************************
788 * SHRegOpenKey32W [NT4.0:SHELL32.507]
791 HRESULT WINAPI
SHRegOpenKey32W (HKEY hkey
, LPCWSTR lpszSubKey
, LPHKEY retkey
)
792 { WARN(shell
,"0x%04x %s %p\n",hkey
,debugstr_w(lpszSubKey
),retkey
);
793 return RegOpenKey32W( hkey
, lpszSubKey
, retkey
);
795 /*************************************************************************
796 * SHRegQueryValueExA [SHELL32.509]
799 HRESULT WINAPI
SHRegQueryValueEx32A(DWORD u
, LPSTR v
, DWORD w
, DWORD x
,
801 { FIXME(shell
,"0x%04lx %s 0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",
802 u
,debugstr_a(v
),w
,x
,y
,z
);
805 /*************************************************************************
806 * SHRegQueryValue32W [NT4.0:SHELL32.510]
809 HRESULT WINAPI
SHRegQueryValue32W (HKEY hkey
, LPWSTR lpszSubKey
,
810 LPWSTR lpszData
, LPDWORD lpcbData
)
811 { WARN(shell
,"0x%04x %s %p %p semi-stub\n",
812 hkey
, debugstr_w(lpszSubKey
), lpszData
, lpcbData
);
813 return RegQueryValue32W( hkey
, lpszSubKey
, lpszData
, lpcbData
);
816 /*************************************************************************
817 * SHRegQueryValueEx32W [NT4.0:SHELL32.511]
820 * if the datatype REG_EXPAND_SZ then expand the string and change
821 * *pdwType to REG_SZ.
823 HRESULT WINAPI
SHRegQueryValueEx32W (HKEY hkey
, LPWSTR pszValue
, LPDWORD pdwReserved
,
824 LPDWORD pdwType
, LPVOID pvData
, LPDWORD pcbData
)
826 WARN(shell
,"0x%04x %s %p %p %p %p semi-stub\n",
827 hkey
, debugstr_w(pszValue
), pdwReserved
, pdwType
, pvData
, pcbData
);
828 ret
= RegQueryValueEx32W ( hkey
, pszValue
, pdwReserved
, pdwType
, pvData
, pcbData
);
832 /*************************************************************************
833 * ReadCabinetState [NT 4.0:SHELL32.651]
836 HRESULT WINAPI
ReadCabinetState(DWORD u
, DWORD v
)
837 { FIXME(shell
,"0x%04lx 0x%04lx stub\n",u
,v
);
840 /*************************************************************************
841 * WriteCabinetState [NT 4.0:SHELL32.652]
844 HRESULT WINAPI
WriteCabinetState(DWORD u
)
845 { FIXME(shell
,"0x%04lx stub\n",u
);
848 /*************************************************************************
849 * FileIconInit [SHELL32.660]
852 BOOL32 WINAPI
FileIconInit(BOOL32 bFullInit
)
853 { FIXME(shell
,"(%s)\n", bFullInit
? "true" : "false");
856 /*************************************************************************
857 * IsUserAdmin [NT 4.0:SHELL32.680]
860 HRESULT WINAPI
IsUserAdmin(void)
861 { FIXME(shell
,"stub\n");
864 /*************************************************************************
865 * StrRetToStrN [SHELL32.96]
867 * converts a STRRET to a normal string
870 * FIXME the string handling is to simple (different STRRET choices)
871 * at the moment only CSTR
872 * the pidl is for STRRET OFFSET
874 HRESULT WINAPI
StrRetToStrN (LPVOID dest
, DWORD len
, LPSTRRET src
, LPITEMIDLIST pidl
)
875 { TRACE(shell
,"dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest
,len
,src
,pidl
);
879 WideCharToMultiByte(CP_ACP
, 0, src
->u
.pOleStr
, -1, (LPSTR
)dest
, len
, NULL
, NULL
);
880 SHFree(src
->u
.pOleStr
);
884 if (VERSION_OsIsUnicode())
885 lstrcpynAtoW((LPWSTR
)dest
, src
->u
.cStr
, len
);
887 strncpy((LPSTR
)dest
, src
->u
.cStr
, len
);
892 { if(VERSION_OsIsUnicode())
893 lstrcpynAtoW((LPWSTR
)dest
, ((LPCSTR
)&pidl
->mkid
)+src
->u
.uOffset
, len
);
895 strncpy((LPSTR
)dest
, ((LPCSTR
)&pidl
->mkid
)+src
->u
.uOffset
, len
);
900 FIXME(shell
,"unknown type!\n");
902 { *(LPSTR
)dest
= '\0';
909 /*************************************************************************
910 * StrChrW [NT 4.0:SHELL32.651]
913 LPWSTR WINAPI
StrChrW (LPWSTR str
, WCHAR x
)
916 TRACE(shell
,"%s 0x%04x\n",debugstr_w(str
),x
);
926 /*************************************************************************
927 * StrCmpNIW [NT 4.0:SHELL32.*]
930 INT32 WINAPI
StrCmpNIW ( LPWSTR wstr1
, LPWSTR wstr2
, INT32 len
)
931 { FIXME( shell
,"%s %s %i stub\n", debugstr_w(wstr1
),debugstr_w(wstr2
),len
);
935 /*************************************************************************
936 * SHAllocShared [SHELL32.520]
939 * parameter1 is return value from HeapAlloc
940 * parameter2 is equal to the size allocated with HeapAlloc
941 * parameter3 is return value from GetCurrentProcessId
943 * the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
944 * WM_USER+2 could be the undocumented CWM_SETPATH
945 * the allocated memory contains a pidl
947 HGLOBAL32 WINAPI
SHAllocShared(LPVOID psrc
, DWORD size
, DWORD procID
)
951 TRACE(shell
,"ptr=%p size=0x%04lx procID=0x%04lx\n",psrc
,size
,procID
);
952 hmem
= GlobalAlloc32(GMEM_FIXED
, size
);
956 pmem
= GlobalLock32 (hmem
);
961 memcpy (pmem
, psrc
, size
);
962 GlobalUnlock32(hmem
);
965 /*************************************************************************
966 * SHLockShared [SHELL32.521]
969 * parameter1 is return value from SHAllocShared
970 * parameter2 is return value from GetCurrentProcessId
971 * the receiver of (WM_USER+2) trys to lock the HANDLE (?)
972 * the returnvalue seems to be a memoryadress
974 LPVOID WINAPI
SHLockShared(HANDLE32 hmem
, DWORD procID
)
975 { TRACE(shell
,"handle=0x%04x procID=0x%04lx\n",hmem
,procID
);
976 return GlobalLock32(hmem
);
978 /*************************************************************************
979 * SHUnlockShared [SHELL32.522]
982 * parameter1 is return value from SHLockShared
984 BOOL32 WINAPI
SHUnlockShared(HANDLE32 pmem
)
985 { TRACE(shell
,"handle=0x%04x\n",pmem
);
986 return GlobalUnlock32(pmem
);
988 /*************************************************************************
989 * SHFreeShared [SHELL32.523]
992 * parameter1 is return value from SHAllocShared
993 * parameter2 is return value from GetCurrentProcessId
995 HANDLE32 WINAPI
SHFreeShared(HANDLE32 hmem
, DWORD procID
)
996 { TRACE(shell
,"handle=0x%04x 0x%04lx\n",hmem
,procID
);
997 return GlobalFree32(hmem
);
1000 /*************************************************************************
1001 * SetAppStartingCursor32 [SHELL32.99]
1004 HRESULT WINAPI
SetAppStartingCursor32(DWORD u
, DWORD v
)
1005 { FIXME(shell
,"0x%04lx 0x%04lx stub\n",u
,v
);
1008 /*************************************************************************
1009 * SHLoadOLE32 [SHELL32.151]
1012 HRESULT WINAPI
SHLoadOLE32(DWORD u
)
1013 { FIXME(shell
,"0x%04lx stub\n",u
);
1016 /*************************************************************************
1017 * Shell_MergeMenus32 [SHELL32.67]
1020 BOOL32
_SHIsMenuSeparator(HMENU32 hm
, int i
)
1022 MENUITEMINFO32A mii
;
1024 mii
.cbSize
= sizeof(MENUITEMINFO32A
);
1025 mii
.fMask
= MIIM_TYPE
;
1026 mii
.cch
= 0; /* WARNING: We MUST initialize it to 0*/
1027 if (!GetMenuItemInfo32A(hm
, i
, TRUE
, &mii
))
1031 if (mii
.fType
& MFT_SEPARATOR
)
1037 #define MM_ADDSEPARATOR 0x00000001L
1038 #define MM_SUBMENUSHAVEIDS 0x00000002L
1039 HRESULT WINAPI
Shell_MergeMenus32 (HMENU32 hmDst
, HMENU32 hmSrc
, UINT32 uInsert
, UINT32 uIDAdjust
, UINT32 uIDAdjustMax
, ULONG uFlags
)
1042 BOOL32 bAlreadySeparated
;
1043 MENUITEMINFO32A miiSrc
;
1045 UINT32 uTemp
, uIDMax
= uIDAdjust
;
1047 FIXME(shell
,"hmenu1=0x%04x hmenu2=0x%04x 0x%04x 0x%04x 0x%04x 0x%04lx stub\n",
1048 hmDst
, hmSrc
, uInsert
, uIDAdjust
, uIDAdjustMax
, uFlags
);
1050 if (!hmDst
|| !hmSrc
)
1054 nItem
= GetMenuItemCount32(hmDst
);
1055 if (uInsert
>= (UINT32
)nItem
)
1056 { uInsert
= (UINT32
)nItem
;
1057 bAlreadySeparated
= TRUE
;
1060 { bAlreadySeparated
= _SHIsMenuSeparator(hmDst
, uInsert
);;
1062 if ((uFlags
& MM_ADDSEPARATOR
) && !bAlreadySeparated
)
1063 { /* Add a separator between the menus */
1064 InsertMenu32A(hmDst
, uInsert
, MF_BYPOSITION
| MF_SEPARATOR
, 0, NULL
);
1065 bAlreadySeparated
= TRUE
;
1069 /* Go through the menu items and clone them*/
1070 for (nItem
= GetMenuItemCount32(hmSrc
) - 1; nItem
>= 0; nItem
--)
1071 { miiSrc
.cbSize
= sizeof(MENUITEMINFO32A
);
1072 miiSrc
.fMask
= MIIM_STATE
| MIIM_ID
| MIIM_SUBMENU
| MIIM_CHECKMARKS
| MIIM_TYPE
| MIIM_DATA
;
1073 /* We need to reset this every time through the loop in case
1074 menus DON'T have IDs*/
1075 miiSrc
.fType
= MFT_STRING
;
1076 miiSrc
.dwTypeData
= szName
;
1077 miiSrc
.dwItemData
= 0;
1078 miiSrc
.cch
= sizeof(szName
);
1080 if (!GetMenuItemInfo32A(hmSrc
, nItem
, TRUE
, &miiSrc
))
1083 if (miiSrc
.fType
& MFT_SEPARATOR
)
1084 { /* This is a separator; don't put two of them in a row*/
1085 if (bAlreadySeparated
)
1088 bAlreadySeparated
= TRUE
;
1090 else if (miiSrc
.hSubMenu
)
1091 { if (uFlags
& MM_SUBMENUSHAVEIDS
)
1092 { /* Adjust the ID and check it*/
1093 miiSrc
.wID
+= uIDAdjust
;
1094 if (miiSrc
.wID
> uIDAdjustMax
)
1097 if (uIDMax
<= miiSrc
.wID
)
1098 { uIDMax
= miiSrc
.wID
+ 1;
1102 { /* Don't set IDs for submenus that didn't have them already */
1103 miiSrc
.fMask
&= ~MIIM_ID
;
1105 hmSubMenu
= miiSrc
.hSubMenu
;
1106 miiSrc
.hSubMenu
= CreatePopupMenu32();
1107 if (!miiSrc
.hSubMenu
)
1110 uTemp
= Shell_MergeMenus32(miiSrc
.hSubMenu
, hmSubMenu
, 0, uIDAdjust
, uIDAdjustMax
, uFlags
&MM_SUBMENUSHAVEIDS
);
1111 if (uIDMax
<= uTemp
)
1114 bAlreadySeparated
= FALSE
;
1117 { /* Adjust the ID and check it*/
1118 miiSrc
.wID
+= uIDAdjust
;
1119 if (miiSrc
.wID
> uIDAdjustMax
)
1122 if (uIDMax
<= miiSrc
.wID
)
1123 { uIDMax
= miiSrc
.wID
+ 1;
1125 bAlreadySeparated
= FALSE
;
1127 if (!InsertMenuItem32A(hmDst
, uInsert
, TRUE
, &miiSrc
))
1132 /* Ensure the correct number of separators at the beginning of the
1133 inserted menu items*/
1135 { if (bAlreadySeparated
)
1136 { DeleteMenu32(hmDst
, uInsert
, MF_BYPOSITION
);
1140 { if (_SHIsMenuSeparator(hmDst
, uInsert
-1))
1141 { if (bAlreadySeparated
)
1142 { DeleteMenu32(hmDst
, uInsert
, MF_BYPOSITION
);
1146 { if ((uFlags
& MM_ADDSEPARATOR
) && !bAlreadySeparated
)
1147 { /* Add a separator between the menus*/
1148 InsertMenu32A(hmDst
, uInsert
, MF_BYPOSITION
| MF_SEPARATOR
, 0, NULL
);
1155 /*************************************************************************
1156 * DriveType32 [SHELL32.64]
1159 HRESULT WINAPI
DriveType32(DWORD u
)
1160 { FIXME(shell
,"0x%04lx stub\n",u
);
1163 /*************************************************************************
1164 * SHAbortInvokeCommand [SHELL32.198]
1167 HRESULT WINAPI
SHAbortInvokeCommand(void)
1168 { FIXME(shell
,"stub\n");
1171 /*************************************************************************
1172 * SHOutOfMemoryMessageBox [SHELL32.126]
1175 HRESULT WINAPI
SHOutOfMemoryMessageBox(DWORD u
, DWORD v
, DWORD w
)
1176 { FIXME(shell
,"0x%04lx 0x%04lx 0x%04lx stub\n",u
,v
,w
);
1179 /*************************************************************************
1180 * SHFlushClipboard [SHELL32.121]
1183 HRESULT WINAPI
SHFlushClipboard(void)
1184 { FIXME(shell
,"stub\n");
1187 /*************************************************************************
1188 * StrRChrW [SHELL32.320]
1191 LPWSTR WINAPI
StrRChrW(LPWSTR lpStart
, LPWSTR lpEnd
, DWORD wMatch
)
1193 TRACE(shell
,"%s %s 0x%04x\n",debugstr_w(lpStart
),debugstr_w(lpEnd
), (WCHAR
)wMatch
);
1195 /* if the end not given, search*/
1203 { if (*lpStart
==(WCHAR
)wMatch
)
1206 } while ( lpStart
<=lpEnd
);
1209 /*************************************************************************
1210 * StrFormatByteSize [SHLWAPI]
1212 LPSTR WINAPI
StrFormatByteSize32A ( DWORD dw
, LPSTR pszBuf
, UINT32 cchBuf
)
1214 TRACE(shell
,"%lx %p %i\n", dw
, pszBuf
, cchBuf
);
1216 { sprintf (buf
,"%3.1f bytes", (FLOAT
)dw
);
1218 else if ( dw
<1048576L)
1219 { sprintf (buf
,"%3.1f KB", (FLOAT
)dw
/1024);
1221 else if ( dw
< 1073741824L)
1222 { sprintf (buf
,"%3.1f MB", (FLOAT
)dw
/1048576L);
1225 { sprintf (buf
,"%3.1f GB", (FLOAT
)dw
/1073741824L);
1227 strncpy (pszBuf
, buf
, cchBuf
);
1230 LPWSTR WINAPI
StrFormatByteSize32W ( DWORD dw
, LPWSTR pszBuf
, UINT32 cchBuf
)
1232 TRACE(shell
,"%lx %p %i\n", dw
, pszBuf
, cchBuf
);
1234 { sprintf (buf
,"%3.1f bytes", (FLOAT
)dw
);
1236 else if ( dw
<1048576L)
1237 { sprintf (buf
,"%3.1f KB", (FLOAT
)dw
/1024);
1239 else if ( dw
< 1073741824L)
1240 { sprintf (buf
,"%3.1f MB", (FLOAT
)dw
/1048576L);
1243 { sprintf (buf
,"%3.1f GB", (FLOAT
)dw
/1073741824L);
1245 lstrcpynAtoW (pszBuf
, buf
, cchBuf
);
1248 /*************************************************************************
1249 * SHWaitForFileToOpen [SHELL32.97]
1252 HRESULT WINAPI
SHWaitForFileToOpen(DWORD u
, DWORD v
, DWORD w
)
1253 { FIXME(shell
,"0x%04lx 0x%04lx 0x%04lx stub\n",u
,v
,w
);