| /* |
| * Shell Ordinal Functions |
| * |
| * These are completely undocumented. The meaning of the functions changes |
| * between different OS versions (NT uses Unicode strings, 95 uses ASCII |
| * strings, etc. etc.) |
| * |
| * They are just here so that explorer.exe and iexplore.exe can be tested. |
| * |
| * Copyright 1997 Marcus Meissner |
| * 1998 Jürgen Schmied |
| */ |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <ctype.h> |
| #include "windows.h" |
| #include "winerror.h" |
| #include "file.h" |
| #include "shell.h" |
| #include "heap.h" |
| #include "module.h" |
| #include "neexe.h" |
| #include "resource.h" |
| #include "dlgs.h" |
| #include "win.h" |
| #include "graphics.h" |
| #include "cursoricon.h" |
| #include "interfaces.h" |
| #include "shlobj.h" |
| #include "debug.h" |
| #include "winreg.h" |
| #include "shell32_main.h" |
| |
| /************************************************************************* |
| * SHChangeNotifyRegister [SHELL32.2] |
| * NOTES |
| * Idlist is an array of structures and Count specifies how many items in the array |
| * (usually just one I think). |
| */ |
| DWORD WINAPI |
| SHChangeNotifyRegister( |
| HWND32 hwnd, |
| LONG events1, |
| LONG events2, |
| DWORD msg, |
| int count, |
| IDSTRUCT *idlist) |
| { FIXME(shell,"(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n", |
| hwnd,events1,events2,msg,count,idlist); |
| return 0; |
| } |
| /************************************************************************* |
| * SHChangeNotifyDeregister [SHELL32.4] |
| */ |
| DWORD WINAPI |
| SHChangeNotifyDeregister(LONG x1,LONG x2) |
| { FIXME(shell,"(0x%08lx,0x%08lx):stub.\n",x1,x2); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathIsRoot [SHELL32.29] |
| */ |
| BOOL32 WINAPI PathIsRoot(LPCSTR x) { |
| TRACE(shell,"%s\n",x); |
| if (!strcmp(x+1,":\\")) /* "X:\" */ |
| return 1; |
| if (!strcmp(x,"\\")) /* "\" */ |
| return 1; |
| if (x[0]=='\\' && x[1]=='\\') { /* UNC "\\<xx>\" */ |
| int foundbackslash = 0; |
| x=x+2; |
| while (*x) { |
| if (*x++=='\\') |
| foundbackslash++; |
| } |
| if (foundbackslash<=1) /* max 1 \ more ... */ |
| return 1; |
| } |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathBuildRoot [SHELL32.30] |
| */ |
| LPSTR WINAPI PathBuildRoot(LPSTR root,BYTE drive) { |
| TRACE(shell,"%p %i\n",root, drive); |
| strcpy(root,"A:\\"); |
| root[0]+=drive; |
| return root; |
| } |
| |
| /************************************************************************* |
| * PathFindExtension [SHELL32.31] |
| * |
| * NOTES |
| * returns pointer to last . in last pathcomponent or at \0. |
| */ |
| LPSTR WINAPI PathFindExtension(LPSTR path) { |
| LPSTR lastpoint = NULL; |
| TRACE(shell,"%p %s\n",path,path); |
| while (*path) { |
| if (*path=='\\'||*path==' ') |
| lastpoint=NULL; |
| if (*path=='.') |
| lastpoint=path; |
| path++; |
| } |
| return lastpoint?lastpoint:path; |
| } |
| |
| /************************************************************************* |
| * PathAddBackslash [SHELL32.32] |
| * |
| * NOTES |
| * append \ if there is none |
| */ |
| LPSTR WINAPI PathAddBackslash(LPSTR path) |
| { int len; |
| TRACE(shell,"%p->%s\n",path,path); |
| len = strlen(path); |
| if (len && path[len-1]!='\\') |
| { path[len+0]='\\'; |
| path[len+1]='\0'; |
| return path+len+1; |
| } |
| else |
| return path+len; |
| } |
| |
| /************************************************************************* |
| * PathRemoveBlanks [SHELL32.33] |
| * |
| * NOTES |
| * remove spaces from beginning and end of passed string |
| */ |
| LPSTR WINAPI PathRemoveBlanks(LPSTR str) |
| { LPSTR x = str; |
| TRACE(shell,"%s\n",str); |
| while (*x==' ') x++; |
| if (x!=str) |
| strcpy(str,x); |
| if (!*str) |
| return str; |
| x=str+strlen(str)-1; |
| while (*x==' ') |
| x--; |
| if (*x==' ') |
| *x='\0'; |
| return x; |
| } |
| |
| |
| /************************************************************************* |
| * PathFindFilename [SHELL32.34] |
| * |
| * NOTES |
| * basename(char *fn); |
| */ |
| LPSTR WINAPI PathFindFilename(LPSTR fn) |
| { LPSTR basefn; |
| TRACE(shell,"%s\n",fn); |
| basefn = fn; |
| while (fn[0]) |
| { if (((fn[0]=='\\') || (fn[0]==':')) && fn[1] && fn[1]!='\\') |
| basefn = fn+1; |
| fn++; |
| } |
| return basefn; |
| } |
| |
| /************************************************************************* |
| * PathRemoveFileSpec [SHELL32.35] |
| * |
| * NOTES |
| * bool getpath(char *pathname); truncates passed argument to a valid path |
| * returns if the string was modified or not. |
| * "\foo\xx\foo"-> "\foo\xx" |
| * "\" -> "\" |
| * "a:\foo" -> "a:\" |
| */ |
| DWORD WINAPI PathRemoveFileSpec(LPSTR fn) { |
| LPSTR x,cutplace; |
| TRACE(shell,"%s\n",fn); |
| if (!fn[0]) |
| return 0; |
| x=fn; |
| cutplace = fn; |
| while (*x) { |
| if (*x=='\\') { |
| cutplace=x++; |
| continue; |
| } |
| if (*x==':') { |
| x++; |
| if (*x=='\\') |
| cutplace=++x; |
| continue; /* already x++ed */ |
| } |
| x++; |
| } |
| if (!*cutplace) |
| return 0; |
| if (cutplace==fn) { |
| if (fn[0]=='\\') { |
| if (!fn[1]) |
| return 0; |
| fn[0]='\0'; |
| return 1; |
| } |
| } |
| *cutplace='\0'; |
| return 1; |
| } |
| |
| /************************************************************************* |
| * PathAppend [SHELL32.36] |
| * |
| * NOTES |
| * concat_paths(char*target,const char*add); |
| * concats "target\\add" and writes them to target |
| */ |
| LPSTR WINAPI PathAppend(LPSTR x1,LPSTR x2) { |
| TRACE(shell,"%s %s\n",x1,x2); |
| while (x2[0]=='\\') x2++; |
| return PathCombine(x1,x1,x2); |
| } |
| |
| /************************************************************************* |
| * PathCombine [SHELL32.37] |
| * |
| * NOTES |
| * concat_paths(char*target,const char*add); |
| * concats "target\\add" and writes them to target |
| */ |
| LPSTR WINAPI PathCombine(LPSTR target,LPSTR x1,LPSTR x2) { |
| char buf[260]; |
| TRACE(shell,"%s %s\n",x1,x2); |
| if (!x2 || !x2[0]) { |
| lstrcpy32A(target,x1); |
| return target; |
| } |
| lstrcpy32A(buf,x1); |
| PathAddBackslash(buf); /* append \ if not there */ |
| lstrcat32A(buf,x2); |
| lstrcpy32A(target,buf); |
| return target; |
| } |
| |
| /************************************************************************* |
| * PathIsUNC [SHELL32.39] |
| * |
| * NOTES |
| * isUNC(const char*path); |
| */ |
| BOOL32 WINAPI PathIsUNC(LPCSTR path) { |
| TRACE(shell,"%s\n",path); |
| if ((path[0]=='\\') && (path[1]=='\\')) |
| return TRUE; |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * PathFileExists [SHELL32.45] |
| * |
| * NOTES |
| * file_exists(char *fn); |
| */ |
| BOOL32 WINAPI PathFileExists(LPSTR fn) { |
| TRACE(shell,"%s\n",fn); |
| if (GetFileAttributes32A(fn)==-1) |
| return FALSE; |
| else |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * PathResolve [SHELL32.51] |
| */ |
| DWORD WINAPI PathResolve(LPCSTR s,DWORD x2,DWORD x3) { |
| FIXME(shell,"(%s,0x%08lx,0x%08lx),stub!\n",s,x2,x3); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathGetArgs [SHELL32.52] |
| * |
| * NOTES |
| * look for next arg in string. handle "quoted" strings |
| * returns pointer to argument *AFTER* the space. Or to the \0. |
| */ |
| LPSTR WINAPI PathGetArgs(LPSTR cmdline) { |
| BOOL32 qflag = FALSE; |
| TRACE(shell,"%s\n",cmdline); |
| while (*cmdline) { |
| if ((*cmdline==' ') && !qflag) |
| return cmdline+1; |
| if (*cmdline=='"') |
| qflag=!qflag; |
| cmdline++; |
| } |
| return cmdline; |
| } |
| |
| /************************************************************************* |
| * PathUnquoteSpaces [SHELL32.56] |
| * |
| * NOTES |
| * unquote string (remove ") |
| */ |
| VOID WINAPI PathUnquoteSpaces(LPSTR str) { |
| DWORD len = lstrlen32A(str); |
| TRACE(shell,"%s\n",str); |
| if (*str!='"') return; |
| if (str[len-1]!='"') return; |
| str[len-1]='\0'; |
| lstrcpy32A(str,str+1); |
| return; |
| } |
| |
| /************************************************************************* |
| * ParseField [SHELL32.58] |
| * |
| */ |
| DWORD WINAPI ParseField(LPCSTR src,DWORD x2,LPSTR target,DWORD pathlen) { |
| FIXME(shell,"(%s,0x%08lx,%p,%ld):stub.\n", |
| src,x2,target,pathlen |
| ); |
| if (!src) |
| return 0; |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PickIconDlg [SHELL32.62] |
| * |
| */ |
| DWORD WINAPI PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a) { |
| FIXME(shell,"(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a); |
| return 0xffffffff; |
| } |
| |
| /************************************************************************* |
| * GetFileNameFromBrowse [SHELL32.63] |
| * |
| */ |
| DWORD WINAPI GetFileNameFromBrowse(HWND32 howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd) { |
| FIXME(shell,"(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n", |
| howner,targetbuf,len,x,suffix,y,cmd |
| ); |
| /* puts up a Open Dialog and requests input into targetbuf */ |
| /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */ |
| lstrcpy32A(targetbuf,"x:\\s3.exe"); |
| return 1; |
| } |
| |
| /************************************************************************* |
| * SHGetSettings [SHELL32.68] |
| * |
| */ |
| DWORD WINAPI SHGetSettings(DWORD x,DWORD y,DWORD z) { |
| FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx):stub.\n", |
| x,y,z |
| ); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * Shell_GetCachedImageIndex [SHELL32.72] |
| * |
| */ |
| void WINAPI Shell_GetCachedImageIndex(LPSTR x,DWORD y,DWORD z) |
| { FIXME(shell,"(%s,%08lx,%08lx):stub.\n",x,y,z); |
| } |
| |
| /************************************************************************* |
| * SHShellFolderView_Message [SHELL32.73] |
| * |
| * PARAMETERS |
| * hwndCabinet defines the explorer cabinet window that contains the |
| * shellview you need to communicate with |
| * uMsg identifying the SFVM enum to perform |
| * lParam |
| * |
| * NOTES |
| * Message SFVM_REARRANGE = 1 |
| * This message gets sent when a column gets clicked to instruct the |
| * shell view to re-sort the item list. lParam identifies the column |
| * that was clicked. |
| */ |
| int WINAPI SHShellFolderView_Message(HWND32 hwndCabinet,UINT32 uMsg,LPARAM lParam) |
| { FIXME(shell,"%04x %08ux %08lx stub\n",hwndCabinet,uMsg,lParam); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathYetAnotherMakeUniqueName [SHELL32.75] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| BOOL32 WINAPI PathYetAnotherMakeUniqueName(LPDWORD x,LPDWORD y) { |
| FIXME(shell,"(%p,%p):stub.\n",x,y); |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * SHMapPIDLToSystemImageListIndex [SHELL32.77] |
| * |
| * PARAMETERS |
| * x pointer to an instance of IShellFolder |
| * |
| * NOTES |
| * exported by ordinal |
| * |
| */ |
| DWORD WINAPI |
| SHMapPIDLToSystemImageListIndex(DWORD x,DWORD y,DWORD z) |
| { FIXME(shell,"(%08lx,%08lx,%08lx):stub.\n",x,y,z); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * OleStrToStrN [SHELL32.78] |
| * |
| * NOTES |
| * exported by ordinal |
| * FIXME |
| * wrong implemented OleStr is NOT wide string !!!! (jsch) |
| */ |
| BOOL32 WINAPI |
| OleStrToStrN (LPSTR lpMulti, INT32 nMulti, LPCWSTR lpWide, INT32 nWide) { |
| return WideCharToMultiByte (0, 0, lpWide, nWide, |
| lpMulti, nMulti, NULL, NULL); |
| } |
| |
| /************************************************************************* |
| * StrToOleStrN [SHELL32.79] |
| * |
| * NOTES |
| * exported by ordinal |
| * FIXME |
| * wrong implemented OleStr is NOT wide string !!!! (jsch) |
| */ |
| BOOL32 WINAPI |
| StrToOleStrN (LPWSTR lpWide, INT32 nWide, LPCSTR lpMulti, INT32 nMulti) { |
| return MultiByteToWideChar (0, 0, lpMulti, nMulti, lpWide, nWide); |
| } |
| |
| /************************************************************************* |
| * SHCloneSpecialIDList [SHELL32.89] |
| * |
| * PARAMETERS |
| * hwnd |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI SHCloneSpecialIDList(HWND32 hwnd,DWORD x2,DWORD x3) { |
| FIXME(shell,"(hwnd=0x%x,0x%lx,0x%lx):stub.\n", |
| hwnd,x2,x3 |
| ); |
| return S_OK; |
| } |
| |
| /************************************************************************* |
| * IsLFNDrive [SHELL32.119] |
| * |
| * NOTES |
| * exported by ordinal Name |
| */ |
| BOOL32 WINAPI IsLFNDrive(LPCSTR path) { |
| DWORD fnlen; |
| |
| if (!GetVolumeInformation32A(path,NULL,0,NULL,&fnlen,NULL,NULL,0)) |
| return FALSE; |
| return fnlen>12; |
| } |
| |
| /************************************************************************* |
| * SHGetSpecialFolderPath [SHELL32.175] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| void WINAPI SHGetSpecialFolderPath(DWORD x1,DWORD x2,DWORD x3,DWORD x4) { |
| FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub.\n", |
| x1,x2,x3,x4 |
| ); |
| } |
| |
| /************************************************************************* |
| * RegisterShellHook [SHELL32.181] |
| * |
| * PARAMS |
| * hwnd [I] window handle |
| * y [I] flag ???? |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| void WINAPI RegisterShellHook32(HWND32 hwnd, DWORD y) { |
| FIXME(shell,"(0x%08x,0x%08lx):stub.\n",hwnd,y); |
| } |
| |
| /************************************************************************* |
| * ShellMessageBoxA [SHELL32.183] |
| * |
| * Format and output errormessage. |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| void __cdecl |
| ShellMessageBoxA(HMODULE32 hmod,HWND32 hwnd,DWORD id,DWORD x,DWORD type,LPVOID arglist) { |
| char buf[100],buf2[100],*buf3; |
| LPVOID args = &arglist; |
| |
| if (!LoadString32A(hmod,x,buf,100)) |
| strcpy(buf,"Desktop"); |
| // LoadString32A(hmod,id,buf2,100); |
| /* FIXME: the varargs handling doesn't. */ |
| // FormatMessage32A(0x500,buf2,0,0,(LPSTR)&buf3,256,(LPDWORD)&args); |
| |
| FIXME(shell,"(%08lx,%08lx,%08lx(%s),%08lx(%s),%08lx,%p):stub.\n", |
| (DWORD)hmod,(DWORD)hwnd,id,buf2,x,buf,type,arglist |
| ); |
| /*MessageBox32A(hwnd,buf3,buf,id|0x10000);*/ |
| } |
| |
| /************************************************************************* |
| * SHRestricted [SHELL32.100] |
| * |
| * walks through policy table, queries <app> key, <type> value, returns |
| * queried (DWORD) value. |
| * {0x00001,Explorer,NoRun} |
| * {0x00002,Explorer,NoClose} |
| * {0x00004,Explorer,NoSaveSettings} |
| * {0x00008,Explorer,NoFileMenu} |
| * {0x00010,Explorer,NoSetFolders} |
| * {0x00020,Explorer,NoSetTaskbar} |
| * {0x00040,Explorer,NoDesktop} |
| * {0x00080,Explorer,NoFind} |
| * {0x00100,Explorer,NoDrives} |
| * {0x00200,Explorer,NoDriveAutoRun} |
| * {0x00400,Explorer,NoDriveTypeAutoRun} |
| * {0x00800,Explorer,NoNetHood} |
| * {0x01000,Explorer,NoStartBanner} |
| * {0x02000,Explorer,RestrictRun} |
| * {0x04000,Explorer,NoPrinterTabs} |
| * {0x08000,Explorer,NoDeletePrinter} |
| * {0x10000,Explorer,NoAddPrinter} |
| * {0x20000,Explorer,NoStartMenuSubFolders} |
| * {0x40000,Explorer,MyDocsOnNet} |
| * {0x80000,WinOldApp,NoRealMode} |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI SHRestricted (DWORD pol) { |
| HKEY xhkey; |
| |
| FIXME(shell,"(%08lx):stub.\n",pol); |
| if (RegOpenKey32A(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey)) |
| return 0; |
| /* FIXME: do nothing for now, just return 0 (== "allowed") */ |
| RegCloseKey(xhkey); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathGetExtension [SHELL32.158] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| LPSTR WINAPI PathGetExtension(LPSTR path,DWORD y,DWORD z) |
| { TRACE(shell,"(%s,%08lx,%08lx)\n",path,y,z); |
| path = PathFindExtension(path); |
| return *path?(path+1):path; |
| } |
| |
| /************************************************************************* |
| * SHCreateDirectory [SHELL32.165] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI SHCreateDirectory(DWORD x,LPCSTR path) { |
| TRACE(shell,"(%08lx,%s):stub.\n",x,path); |
| if (CreateDirectory32A(path,x)) |
| return TRUE; |
| /* SHChangeNotify(8,1,path,0); */ |
| return FALSE; |
| #if 0 |
| if (SHELL32_79(path,(LPVOID)x)) |
| return 0; |
| FIXME(shell,"(%08lx,%s):stub.\n",x,path); |
| return 0; |
| #endif |
| } |
| |
| /************************************************************************* |
| * SHFree [SHELL32.195] |
| * |
| * NOTES |
| * free_ptr() - frees memory using IMalloc |
| * exported by ordinal |
| */ |
| DWORD WINAPI SHFree(LPVOID x) { |
| TRACE(shell,"%p\n",x); |
| /*return LocalFree32((HANDLE32)x);*/ /* crashes */ |
| return HeapFree(GetProcessHeap(),0,x); |
| } |
| |
| /************************************************************************* |
| * SHAlloc [SHELL32.196] |
| * |
| * NOTES |
| * void *task_alloc(DWORD len), uses SHMalloc allocator |
| * exported by ordinal |
| */ |
| LPVOID WINAPI SHAlloc(DWORD len) { |
| /* void * ret = (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT);*/ /* chrashes */ |
| void * ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len); |
| TRACE(shell,"%lu bytes at %p\n",len, ret); |
| return ret; |
| } |
| |
| /************************************************************************* |
| * OpenRegStream [SHELL32.85] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI OpenRegStream(DWORD x1,DWORD x2,DWORD x3,DWORD x4) { |
| FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub.\n", |
| x1,x2,x3,x4 |
| ); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * SHRegisterDragDrop [SHELL32.86] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI SHRegisterDragDrop(HWND32 hwnd,DWORD x2) { |
| FIXME (shell, "(0x%08x,0x%08lx):stub.\n", hwnd, x2); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * SHRevokeDragDrop [SHELL32.87] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI SHRevokeDragDrop(DWORD x) { |
| FIXME(shell,"(0x%08lx):stub.\n",x); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * RunFileDlg [SHELL32.61] |
| * |
| * NOTES |
| * Original name: RunFileDlg (exported by ordinal) |
| */ |
| DWORD WINAPI |
| RunFileDlg (HWND32 hwndOwner, DWORD dwParam1, DWORD dwParam2, |
| LPSTR lpszTitle, LPSTR lpszPrompt, UINT32 uFlags) |
| { |
| FIXME (shell,"(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n", |
| hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * ExitWindowsDialog [SHELL32.60] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI |
| ExitWindowsDialog (HWND32 hwndOwner) |
| { |
| FIXME (shell,"(0x%08x):stub.\n", hwndOwner); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * ArrangeWindows [SHELL32.184] |
| * |
| */ |
| DWORD WINAPI |
| ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, |
| DWORD dwParam4, DWORD dwParam5) |
| { |
| FIXME (shell,"(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n", |
| dwParam1, dwParam2, dwParam3, dwParam4, dwParam5); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * SHCLSIDFromString [SHELL32.147] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI |
| SHCLSIDFromString (DWORD dwParam1, DWORD dwParam2) |
| { |
| FIXME (shell,"(0x%lx 0x%lx):stub.\n", dwParam1, dwParam2); |
| FIXME (shell,"(\"%s\" \"%s\"):stub.\n", (LPSTR)dwParam1, (LPSTR)dwParam2); |
| |
| return 0; |
| } |
| |
| |
| /************************************************************************* |
| * SignalFileOpen [SHELL32.103] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| DWORD WINAPI |
| SignalFileOpen (DWORD dwParam1) |
| { |
| FIXME (shell,"(0x%08lx):stub.\n", dwParam1); |
| |
| return 0; |
| } |
| |
| /************************************************************************* |
| * SHAddToRecentDocs [SHELL32.234] |
| * |
| * PARAMETERS |
| * uFlags [IN] SHARD_PATH or SHARD_PIDL |
| * pv [IN] string or pidl, NULL clears the list |
| * |
| * NOTES |
| * exported by name |
| */ |
| DWORD WINAPI SHAddToRecentDocs32 (UINT32 uFlags,LPCVOID pv) |
| { if (SHARD_PIDL==uFlags) |
| { FIXME (shell,"(0x%08x,pidl=%p):stub.\n", uFlags,pv); |
| } |
| else |
| { FIXME (shell,"(0x%08x,%s):stub.\n", uFlags,(char*)pv); |
| } |
| return 0; |
| } |
| |
| /************************************************************************* |
| * SHFileOperation [SHELL32.242] |
| * |
| * NOTES |
| * exported by name |
| */ |
| DWORD WINAPI SHFileOperation32 ( |
| LPSHFILEOPSTRUCT32 lpFileOp) |
| { FIXME (shell,"(%p):stub.\n", lpFileOp); |
| return 1; |
| } |
| |
| /************************************************************************* |
| * SHChangeNotify [SHELL32.239] |
| * |
| * NOTES |
| * exported by name |
| */ |
| DWORD WINAPI SHChangeNotify32 ( |
| INT32 wEventId, /* [IN] flags that specifies the event*/ |
| UINT32 uFlags, /* [IN] the meaning of dwItem[1|2]*/ |
| LPCVOID dwItem1, |
| LPCVOID dwItem2) |
| { FIXME (shell,"(0x%08x,0x%08ux,%p,%p):stub.\n", wEventId,uFlags,dwItem1,dwItem2); |
| return 0; |
| } |
| /************************************************************************* |
| * SHCreateShellFolderViewEx [SHELL32.174] |
| * |
| * NOTES |
| * see IShellFolder::CreateViewObject |
| */ |
| HRESULT WINAPI SHCreateShellFolderViewEx32( |
| LPSHELLVIEWDATA psvcbi, /*[in ] shelltemplate struct*/ |
| LPVOID* ppv) /*[out] IShellView pointer*/ |
| { FIXME (shell,"(%p,%p):stub.\n", psvcbi,ppv); |
| return 0; |
| } |
| /************************************************************************* |
| * SHFind_InitMenuPopup [SHELL32.149] |
| * |
| */ |
| HRESULT WINAPI SHFind_InitMenuPopup (DWORD u, DWORD v, DWORD w, DWORD x) |
| { FIXME(shell,"0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",u,v,w,x); |
| return 0; |
| } |
| /************************************************************************* |
| * FileMenu_Create [SHELL32.114] |
| * |
| */ |
| HRESULT WINAPI FileMenu_Create (DWORD u, DWORD v, DWORD w, DWORD x, DWORD z) |
| { FIXME(shell,"0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",u,v,w,x,z); |
| return 0; |
| } |
| /************************************************************************* |
| * ShellExecuteEx [SHELL32.291] |
| * |
| */ |
| BOOL32 WINAPI ShellExecuteEx32A (LPSHELLEXECUTEINFOA u) |
| { FIXME(shell,"%p stub\n",u); |
| return 0; |
| } |
| /************************************************************************* |
| * SHSetInstanceExplorer [SHELL32.176] |
| * |
| */ |
| HRESULT WINAPI SHSetInstanceExplorer (DWORD u) |
| { FIXME(shell,"0x%08lx stub\n",u); |
| return 0; |
| } |
| /************************************************************************* |
| * SHGetInstanceExplorer [SHELL32.256] |
| * |
| * NOTES |
| * exported by name |
| */ |
| HRESULT WINAPI SHGetInstanceExplorer (DWORD u) |
| { FIXME(shell,"0x%08lx stub\n",u); |
| return 0; |
| } |
| /************************************************************************* |
| * SHFreeUnusedLibraries [SHELL32.123] |
| * |
| * NOTES |
| * exported by name |
| */ |
| HRESULT WINAPI SHFreeUnusedLibraries (DWORD u) |
| { FIXME(shell,"0x%08lx stub\n",u); |
| return 0; |
| } |
