/* * Shell basics * * 1998 Marcus Meissner * 1998 Juergen Schmied (jsch) * */ #include #include #include "wine/winuser16.h" #include "winerror.h" #include "heap.h" #include "resource.h" #include "dlgs.h" #include "win.h" #include "sysmetrics.h" #include "debug.h" #include "winreg.h" #include "authors.h" #include "winversion.h" #include "shell.h" #include "shellapi.h" #include "pidl.h" #include "shlobj.h" #include "shell32_main.h" #include "shlguid.h" /************************************************************************* * CommandLineToArgvW [SHELL32.7] */ LPWSTR* WINAPI CommandLineToArgvW(LPWSTR cmdline,LPDWORD numargs) { LPWSTR *argv,s,t; int i; TRACE(shell,"\n"); /* to get writeable copy */ cmdline = HEAP_strdupW( GetProcessHeap(), 0, cmdline); s=cmdline;i=0; while (*s) { /* space */ if (*s==0x0020) { i++; s++; while (*s && *s==0x0020) s++; continue; } s++; } argv=(LPWSTR*)HeapAlloc( GetProcessHeap(), 0, sizeof(LPWSTR)*(i+1) ); s=t=cmdline; i=0; while (*s) { if (*s==0x0020) { *s=0; argv[i++]=HEAP_strdupW( GetProcessHeap(), 0, t ); *s=0x0020; while (*s && *s==0x0020) s++; if (*s) t=s+1; else t=s; continue; } s++; } if (*t) argv[i++]=(LPWSTR)HEAP_strdupW( GetProcessHeap(), 0, t ); HeapFree( GetProcessHeap(), 0, cmdline ); argv[i]=NULL; *numargs=i; return argv; } /************************************************************************* * Control_RunDLL [SHELL32.12] * * Wild speculation in the following! * * http://premium.microsoft.com/msdn/library/techart/msdn193.htm */ void WINAPI Control_RunDLL( HWND hwnd, LPCVOID code, LPCSTR cmd, DWORD arg4 ) { FIXME(shell, "(0x%08x, %p, %s, 0x%08lx): stub\n", hwnd, code, debugstr_a(cmd), arg4); } /************************************************************************* * SHGetFileInfoA [SHELL32.254] */ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes, SHFILEINFOA *psfi, UINT sizeofpsfi, UINT flags ) { CHAR szTemp[MAX_PATH]; LPPIDLDATA pData; LPITEMIDLIST pPidlTemp = NULL; DWORD ret=0, dwfa = dwFileAttributes; TRACE(shell,"(%s,0x%lx,%p,0x%x,0x%x)\n", path,dwFileAttributes,psfi,sizeofpsfi,flags); /* translate the pidl to a path*/ if (flags & SHGFI_PIDL) { pPidlTemp = (LPCITEMIDLIST)path; SHGetPathFromIDListA (pPidlTemp, szTemp); TRACE(shell,"pidl=%p is %s\n", path, szTemp); } else { strcpy(szTemp,path); TRACE(shell,"path=%s\n", szTemp); } if (flags & SHGFI_ATTRIBUTES) { if (flags & SHGFI_PIDL) { /* * We have to test for the desktop folder first because ILGetDataPointer returns * NULL on the desktop folder. */ if (_ILIsDesktop((LPCITEMIDLIST)path)) { psfi->dwAttributes = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANLINK; ret = TRUE; } else { pData = _ILGetDataPointer((LPCITEMIDLIST)path); switch (pData->type) { case PT_DESKTOP: psfi->dwAttributes = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANLINK; case PT_MYCOMP: psfi->dwAttributes = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANRENAME | SFGAO_CANLINK ; case PT_SPECIAL: psfi->dwAttributes = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CAPABILITYMASK; case PT_DRIVE: psfi->dwAttributes = SFGAO_HASSUBFOLDER | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANLINK; case PT_FOLDER: psfi->dwAttributes = SFGAO_HASSUBFOLDER | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_CAPABILITYMASK; case PT_VALUE: psfi->dwAttributes = SFGAO_FILESYSTEM | SFGAO_CAPABILITYMASK; } ret=TRUE; } } else { if (! (flags & SHGFI_USEFILEATTRIBUTES)) dwfa = GetFileAttributesA (szTemp); psfi->dwAttributes = SFGAO_FILESYSTEM; if (dwfa == FILE_ATTRIBUTE_DIRECTORY) psfi->dwAttributes |= SFGAO_FOLDER | SFGAO_HASSUBFOLDER; ret=TRUE; } WARN(shell,"file attributes, semi-stub\n"); } if (flags & SHGFI_DISPLAYNAME) { if (flags & SHGFI_PIDL) { strcpy(psfi->szDisplayName,szTemp); } else { strcpy(psfi->szDisplayName,path); } TRACE(shell,"displayname=%s\n", psfi->szDisplayName); ret=TRUE; } if (flags & SHGFI_TYPENAME) { FIXME(shell,"get the file type, stub\n"); strcpy(psfi->szTypeName,"FIXME: Type"); ret=TRUE; } if (flags & SHGFI_ICONLOCATION) { FIXME(shell,"location of icon, stub\n"); strcpy(psfi->szDisplayName,""); ret=TRUE; } if (flags & SHGFI_EXETYPE) FIXME(shell,"type of executable, stub\n"); if (flags & SHGFI_LINKOVERLAY) FIXME(shell,"set icon to link, stub\n"); if (flags & SHGFI_OPENICON) FIXME(shell,"set to open icon, stub\n"); if (flags & SHGFI_SELECTED) FIXME(shell,"set icon to selected, stub\n"); if (flags & SHGFI_SHELLICONSIZE) FIXME(shell,"set icon to shell size, stub\n"); if (flags & SHGFI_USEFILEATTRIBUTES) FIXME(shell,"use the dwFileAttributes, stub\n"); if (flags & (SHGFI_UNKNOWN1 | SHGFI_UNKNOWN2 | SHGFI_UNKNOWN3)) FIXME(shell,"unknown attribute!\n"); if (flags & SHGFI_ICON) { FIXME(shell,"icon handle\n"); if (flags & SHGFI_SMALLICON) { TRACE(shell,"set to small icon\n"); psfi->hIcon=pImageList_GetIcon(ShellSmallIconList,32,ILD_NORMAL); ret = (DWORD) ShellSmallIconList; } else { TRACE(shell,"set to big icon\n"); psfi->hIcon=pImageList_GetIcon(ShellBigIconList,32,ILD_NORMAL); ret = (DWORD) ShellBigIconList; } } if (flags & SHGFI_SYSICONINDEX) { if (!pPidlTemp) { pPidlTemp = ILCreateFromPathA (szTemp); } psfi->iIcon = SHMapPIDLToSystemImageListIndex (NULL, pPidlTemp, 0); TRACE(shell,"-- SYSICONINDEX %i\n", psfi->iIcon); if (flags & SHGFI_SMALLICON) { TRACE(shell,"set to small icon\n"); ret = (DWORD) ShellSmallIconList; } else { TRACE(shell,"set to big icon\n"); ret = (DWORD) ShellBigIconList; } } return ret; } /************************************************************************* * SHGetFileInfoW [SHELL32.255] */ DWORD WINAPI SHGetFileInfoW(LPCWSTR path,DWORD dwFileAttributes, SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags ) { FIXME(shell,"(%s,0x%lx,%p,0x%x,0x%x)\n", debugstr_w(path),dwFileAttributes,psfi,sizeofpsfi,flags); return 0; } /************************************************************************* * ExtractIconA [SHELL32.133] */ HICON WINAPI ExtractIconA( HINSTANCE hInstance, LPCSTR lpszExeFileName, UINT nIconIndex ) { HGLOBAL16 handle = InternalExtractIcon16(hInstance,lpszExeFileName,nIconIndex, 1); TRACE(shell,"\n"); if( handle ) { HICON16* ptr = (HICON16*)GlobalLock16(handle); HICON16 hIcon = *ptr; GlobalFree16(handle); return hIcon; } return 0; } /************************************************************************* * ExtractIconW [SHELL32.180] */ HICON WINAPI ExtractIconW( HINSTANCE hInstance, LPCWSTR lpszExeFileName, UINT nIconIndex ) { LPSTR exefn; HICON ret; TRACE(shell,"\n"); exefn = HEAP_strdupWtoA(GetProcessHeap(),0,lpszExeFileName); ret = ExtractIconA(hInstance,exefn,nIconIndex); HeapFree(GetProcessHeap(),0,exefn); return ret; } /************************************************************************* * FindExecutableA [SHELL32.184] */ HINSTANCE WINAPI FindExecutableA( LPCSTR lpFile, LPCSTR lpDirectory, LPSTR lpResult ) { HINSTANCE retval=31; /* default - 'No association was found' */ char old_dir[1024]; TRACE(shell, "File %s, Dir %s\n", (lpFile != NULL?lpFile:"-"), (lpDirectory != NULL?lpDirectory:"-")); lpResult[0]='\0'; /* Start off with an empty return string */ /* trap NULL parameters on entry */ if (( lpFile == NULL ) || ( lpResult == NULL )) { /* FIXME - should throw a warning, perhaps! */ return 2; /* File not found. Close enough, I guess. */ } if (lpDirectory) { GetCurrentDirectoryA( sizeof(old_dir), old_dir ); SetCurrentDirectoryA( lpDirectory ); } retval = SHELL_FindExecutable( lpFile, "open", lpResult ); TRACE(shell, "returning %s\n", lpResult); if (lpDirectory) SetCurrentDirectoryA( old_dir ); return retval; } /************************************************************************* * FindExecutableW [SHELL32.219] */ HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult) { FIXME(shell, "(%p,%p,%p): stub\n", lpFile, lpDirectory, lpResult); return 31; /* default - 'No association was found' */ } typedef struct { LPCSTR szApp; LPCSTR szOtherStuff; HICON hIcon; } ABOUT_INFO; #define IDC_STATIC_TEXT 100 #define IDC_LISTBOX 99 #define IDC_WINE_TEXT 98 #define DROP_FIELD_TOP (-15) #define DROP_FIELD_HEIGHT 15 extern HICON hIconTitleFont; static BOOL __get_dropline( HWND hWnd, LPRECT lprect ) { HWND hWndCtl = GetDlgItem(hWnd, IDC_WINE_TEXT); if( hWndCtl ) { GetWindowRect( hWndCtl, lprect ); MapWindowPoints( 0, hWnd, (LPPOINT)lprect, 2 ); lprect->bottom = (lprect->top += DROP_FIELD_TOP); return TRUE; } return FALSE; } /************************************************************************* * SHAppBarMessage32 [SHELL32.207] */ UINT WINAPI SHAppBarMessage(DWORD msg, PAPPBARDATA data) { FIXME(shell,"(0x%08lx,%p hwnd=0x%08x): stub\n", msg, data, data->hWnd); switch (msg) { case ABM_GETSTATE: return ABS_ALWAYSONTOP | ABS_AUTOHIDE; case ABM_GETTASKBARPOS: /* fake a taskbar on the bottom of the desktop */ { RECT rec; GetWindowRect(GetDesktopWindow(), &rec); rec.left = 0; rec.top = rec.bottom - 2; } return TRUE; case ABM_ACTIVATE: case ABM_GETAUTOHIDEBAR: case ABM_NEW: case ABM_QUERYPOS: case ABM_REMOVE: case ABM_SETAUTOHIDEBAR: case ABM_SETPOS: case ABM_WINDOWPOSCHANGED: return FALSE; } return 0; } /************************************************************************* * SHGetDesktopFolder [SHELL32.216] * * SDK header win95/shlobj.h: This is equivalent to call CoCreateInstance with * CLSID_ShellDesktop * CoCreateInstance(CLSID_Desktop, NULL, CLSCTX_INPROC, IID_IShellFolder, &pshf); * * RETURNS * the interface to the shell desktop folder. * * FIXME * the pdesktopfolder has to be released at the end (at dll unloading???) */ LPSHELLFOLDER pdesktopfolder=NULL; DWORD WINAPI SHGetDesktopFolder(LPSHELLFOLDER *shellfolder) { HRESULT hres = E_OUTOFMEMORY; LPCLASSFACTORY lpclf; TRACE(shell,"%p->(%p)\n",shellfolder,*shellfolder); if (pdesktopfolder) { hres = NOERROR; } else { lpclf = IClassFactory_Constructor(); /* fixme: the buildin IClassFactory_Constructor is at the moment only for rclsid=CLSID_ShellDesktop, so we get the right Interface (jsch)*/ if(lpclf) { hres = IClassFactory_CreateInstance(lpclf,NULL,(REFIID)&IID_IShellFolder, (void*)&pdesktopfolder); IClassFactory_Release(lpclf); } } if (pdesktopfolder) { *shellfolder = pdesktopfolder; pdesktopfolder->lpvtbl->fnAddRef(pdesktopfolder); } else { *shellfolder=NULL; } TRACE(shell,"-- %p->(%p)\n",shellfolder, *shellfolder); return hres; } /************************************************************************* * SHGetSpecialFolderLocation [SHELL32.223] * * gets the folder locations from the registry and creates a pidl * creates missing reg keys and directorys * * PARAMS * hwndOwner [I] * nFolder [I] CSIDL_xxxxx * ppidl [O] PIDL of a special folder * * RETURNS * HResult * * FIXME * - look for "User Shell Folder" first * */ HRESULT WINAPI SHGetSpecialFolderLocation(HWND hwndOwner, INT nFolder, LPITEMIDLIST * ppidl) { LPSHELLFOLDER shellfolder; DWORD pchEaten, tpathlen=MAX_PATH, type, dwdisp, res, dwLastError; CHAR pszTemp[256], buffer[256], tpath[MAX_PATH], npath[MAX_PATH]; LPWSTR lpszDisplayName = (LPWSTR)&pszTemp[0]; HKEY key; enum { FT_UNKNOWN= 0x00000000, FT_DIR= 0x00000001, FT_DESKTOP= 0x00000002, FT_SPECIAL= 0x00000003 } tFolder; TRACE(shell,"(%04x,0x%x,%p)\n", hwndOwner,nFolder,ppidl); strcpy(buffer,"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\"); res=RegCreateKeyExA(HKEY_CURRENT_USER,buffer,0,NULL,REG_OPTION_NON_VOLATILE,KEY_WRITE,NULL,&key,&dwdisp); if (res) { ERR(shell,"Could not create key %s %08lx \n",buffer,res); return E_OUTOFMEMORY; } tFolder=FT_DIR; switch (nFolder) { case CSIDL_BITBUCKET: strcpy (buffer,"xxx"); /*not in the registry*/ TRACE (shell,"looking for Recycler\n"); tFolder=FT_UNKNOWN; break; case CSIDL_CONTROLS: strcpy (buffer,"xxx"); /*virtual folder*/ TRACE (shell,"looking for Control\n"); tFolder=FT_UNKNOWN; break; case CSIDL_DESKTOP: strcpy (buffer,"xxx"); /*virtual folder*/ TRACE (shell,"looking for Desktop\n"); tFolder=FT_DESKTOP; break; case CSIDL_DESKTOPDIRECTORY: case CSIDL_COMMON_DESKTOPDIRECTORY: strcpy (buffer,"Desktop"); break; case CSIDL_DRIVES: strcpy (buffer,"xxx"); /*virtual folder*/ TRACE (shell,"looking for Drives\n"); tFolder=FT_SPECIAL; break; case CSIDL_FONTS: strcpy (buffer,"Fonts"); break; case CSIDL_NETHOOD: strcpy (buffer,"NetHood"); break; case CSIDL_PRINTHOOD: strcpy (buffer,"PrintHood"); break; case CSIDL_NETWORK: strcpy (buffer,"xxx"); /*virtual folder*/ TRACE (shell,"looking for Network\n"); tFolder=FT_UNKNOWN; break; case CSIDL_APPDATA: strcpy (buffer,"Appdata"); break; case CSIDL_PERSONAL: strcpy (buffer,"Personal"); break; case CSIDL_FAVORITES: strcpy (buffer,"Favorites"); break; case CSIDL_PRINTERS: strcpy (buffer,"PrintHood"); break; case CSIDL_COMMON_PROGRAMS: case CSIDL_PROGRAMS: strcpy (buffer,"Programs"); break; case CSIDL_RECENT: strcpy (buffer,"Recent"); break; case CSIDL_SENDTO: strcpy (buffer,"SendTo"); break; case CSIDL_COMMON_STARTMENU: case CSIDL_STARTMENU: strcpy (buffer,"Start Menu"); break; case CSIDL_COMMON_STARTUP: case CSIDL_STARTUP: strcpy (buffer,"Startup"); break; case CSIDL_TEMPLATES: strcpy (buffer,"Templates"); break; case CSIDL_INTERNET_CACHE: strcpy (buffer,"Cache"); break; case CSIDL_HISTORY: strcpy (buffer,"History"); break; case CSIDL_COOKIES: strcpy(buffer,"Cookies"); break; default: ERR (shell,"unknown CSIDL 0x%08x\n", nFolder); tFolder=FT_UNKNOWN; break; } TRACE(shell,"Key=%s\n",buffer); type=REG_SZ; switch (tFolder) { case FT_DIR: /* Directory: get the value from the registry, if its not there create it and the directory*/ if (RegQueryValueExA(key,buffer,NULL,&type,(LPBYTE)tpath,&tpathlen)) { GetWindowsDirectoryA(npath,MAX_PATH); PathAddBackslashA(npath); switch (nFolder) { case CSIDL_DESKTOPDIRECTORY: case CSIDL_COMMON_DESKTOPDIRECTORY: strcat (npath,"Desktop"); break; case CSIDL_FONTS: strcat (npath,"Fonts"); break; case CSIDL_NETHOOD: strcat (npath,"NetHood"); break; case CSIDL_PRINTHOOD: strcat (npath,"PrintHood"); break; case CSIDL_APPDATA: strcat (npath,"Appdata"); break; case CSIDL_PERSONAL: strcpy (npath,"C:\\Personal"); break; case CSIDL_FAVORITES: strcat (npath,"Favorites"); break; case CSIDL_PRINTERS: strcat (npath,"PrintHood"); break; case CSIDL_COMMON_PROGRAMS: case CSIDL_PROGRAMS: strcat (npath,"Start Menu"); CreateDirectoryA(npath,NULL); strcat (npath,"\\Programs"); break; case CSIDL_RECENT: strcat (npath,"Recent"); break; case CSIDL_SENDTO: strcat (npath,"SendTo"); break; case CSIDL_COMMON_STARTMENU: case CSIDL_STARTMENU: strcat (npath,"Start Menu"); break; case CSIDL_COMMON_STARTUP: case CSIDL_STARTUP: strcat (npath,"Start Menu"); CreateDirectoryA(npath,NULL); strcat (npath,"\\Startup"); break; case CSIDL_TEMPLATES: strcat (npath,"Templates"); break; case CSIDL_INTERNET_CACHE: strcat(npath,"Temporary Internet Files"); break; case CSIDL_HISTORY: strcat (npath,"History"); break; case CSIDL_COOKIES: strcat (npath,"Cookies"); break; default: RegCloseKey(key); return E_OUTOFMEMORY; } if (RegSetValueExA(key,buffer,0,REG_SZ,(LPBYTE)npath,sizeof(npath)+1)) { ERR(shell,"could not create value %s\n",buffer); RegCloseKey(key); return E_OUTOFMEMORY; } TRACE(shell,"value %s=%s created\n",buffer,npath); dwLastError = GetLastError(); CreateDirectoryA(npath,NULL); SetLastError (dwLastError); strcpy(tpath,npath); } break; case FT_DESKTOP: strcpy (tpath,"Desktop"); break; case FT_SPECIAL: if (nFolder==CSIDL_DRIVES) strcpy (tpath,"My Computer"); break; default: RegCloseKey(key); return E_OUTOFMEMORY; } RegCloseKey(key); TRACE(shell,"Value=%s\n",tpath); LocalToWideChar(lpszDisplayName, tpath, 256); if (SHGetDesktopFolder(&shellfolder)==S_OK) { shellfolder->lpvtbl->fnParseDisplayName(shellfolder,hwndOwner, NULL,lpszDisplayName,&pchEaten,ppidl,NULL); shellfolder->lpvtbl->fnRelease(shellfolder); } TRACE(shell, "-- (new pidl %p)\n",*ppidl); return NOERROR; } /************************************************************************* * SHHelpShortcuts_RunDLL [SHELL32.224] * */ DWORD WINAPI SHHelpShortcuts_RunDLL (DWORD dwArg1, DWORD dwArg2, DWORD dwArg3, DWORD dwArg4) { FIXME (exec, "(%lx, %lx, %lx, %lx) empty stub!\n", dwArg1, dwArg2, dwArg3, dwArg4); return 0; } /************************************************************************* * SHLoadInProc [SHELL32.225] * */ DWORD WINAPI SHLoadInProc (DWORD dwArg1) { FIXME (shell, "(%lx) empty stub!\n", dwArg1); return 0; } /************************************************************************* * ShellExecuteA [SHELL32.245] */ HINSTANCE WINAPI ShellExecuteA( HWND hWnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT iShowCmd ) { TRACE(shell,"\n"); return ShellExecute16( hWnd, lpOperation, lpFile, lpParameters, lpDirectory, iShowCmd ); } /************************************************************************* * ShellExecuteW [SHELL32.294] * from shellapi.h * WINSHELLAPI HINSTANCE APIENTRY ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, * LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd); */ HINSTANCE WINAPI ShellExecuteW( HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd) { FIXME(shell,": stub\n"); return 0; } /************************************************************************* * AboutDlgProc32 (internal) */ BOOL WINAPI AboutDlgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) { HWND hWndCtl; char Template[512], AppTitle[512]; TRACE(shell,"\n"); switch(msg) { case WM_INITDIALOG: { ABOUT_INFO *info = (ABOUT_INFO *)lParam; if (info) { const char* const *pstr = SHELL_People; SendDlgItemMessageA(hWnd, stc1, STM_SETICON,info->hIcon, 0); GetWindowTextA( hWnd, Template, sizeof(Template) ); sprintf( AppTitle, Template, info->szApp ); SetWindowTextA( hWnd, AppTitle ); SetWindowTextA( GetDlgItem(hWnd, IDC_STATIC_TEXT), info->szOtherStuff ); hWndCtl = GetDlgItem(hWnd, IDC_LISTBOX); SendMessageA( hWndCtl, WM_SETREDRAW, 0, 0 ); SendMessageA( hWndCtl, WM_SETFONT, hIconTitleFont, 0 ); while (*pstr) { SendMessageA( hWndCtl, LB_ADDSTRING, (WPARAM)-1, (LPARAM)*pstr ); pstr++; } SendMessageA( hWndCtl, WM_SETREDRAW, 1, 0 ); } } return 1; case WM_PAINT: { RECT rect; PAINTSTRUCT ps; HDC hDC = BeginPaint( hWnd, &ps ); if( __get_dropline( hWnd, &rect ) ) { SelectObject( hDC, GetStockObject( BLACK_PEN ) ); MoveToEx( hDC, rect.left, rect.top, NULL ); LineTo( hDC, rect.right, rect.bottom ); } EndPaint( hWnd, &ps ); } break; case WM_LBTRACKPOINT: hWndCtl = GetDlgItem(hWnd, IDC_LISTBOX); if( (INT16)GetKeyState16( VK_CONTROL ) < 0 ) { if( DragDetect( hWndCtl, *((LPPOINT)&lParam) ) ) { INT idx = SendMessageA( hWndCtl, LB_GETCURSEL, 0, 0 ); if( idx != -1 ) { INT length = SendMessageA( hWndCtl, LB_GETTEXTLEN, (WPARAM)idx, 0 ); HGLOBAL16 hMemObj = GlobalAlloc16( GMEM_MOVEABLE, length + 1 ); char* pstr = (char*)GlobalLock16( hMemObj ); if( pstr ) { HCURSOR16 hCursor = LoadCursor16( 0, MAKEINTRESOURCE16(OCR_DRAGOBJECT) ); SendMessageA( hWndCtl, LB_GETTEXT, (WPARAM)idx, (LPARAM)pstr ); SendMessageA( hWndCtl, LB_DELETESTRING, (WPARAM)idx, 0 ); UpdateWindow( hWndCtl ); if( !DragObject16((HWND16)hWnd, (HWND16)hWnd, DRAGOBJ_DATA, 0, (WORD)hMemObj, hCursor) ) SendMessageA( hWndCtl, LB_ADDSTRING, (WPARAM)-1, (LPARAM)pstr ); } if( hMemObj ) GlobalFree16( hMemObj ); } } } break; case WM_QUERYDROPOBJECT: if( wParam == 0 ) { LPDRAGINFO lpDragInfo = (LPDRAGINFO)PTR_SEG_TO_LIN((SEGPTR)lParam); if( lpDragInfo && lpDragInfo->wFlags == DRAGOBJ_DATA ) { RECT rect; if( __get_dropline( hWnd, &rect ) ) { POINT pt; pt.x=lpDragInfo->pt.x; pt.x=lpDragInfo->pt.y; rect.bottom += DROP_FIELD_HEIGHT; if( PtInRect( &rect, pt ) ) { SetWindowLongA( hWnd, DWL_MSGRESULT, 1 ); return TRUE; } } } } break; case WM_DROPOBJECT: if( wParam == hWnd ) { LPDRAGINFO lpDragInfo = (LPDRAGINFO)PTR_SEG_TO_LIN((SEGPTR)lParam); if( lpDragInfo && lpDragInfo->wFlags == DRAGOBJ_DATA && lpDragInfo->hList ) { char* pstr = (char*)GlobalLock16( (HGLOBAL16)(lpDragInfo->hList) ); if( pstr ) { static char __appendix_str[] = " with"; hWndCtl = GetDlgItem( hWnd, IDC_WINE_TEXT ); SendMessageA( hWndCtl, WM_GETTEXT, 512, (LPARAM)Template ); if( !lstrncmpA( Template, "WINE", 4 ) ) SetWindowTextA( GetDlgItem(hWnd, IDC_STATIC_TEXT), Template ); else { char* pch = Template + strlen(Template) - strlen(__appendix_str); *pch = '\0'; SendMessageA( GetDlgItem(hWnd, IDC_LISTBOX), LB_ADDSTRING, (WPARAM)-1, (LPARAM)Template ); } lstrcpyA( Template, pstr ); lstrcatA( Template, __appendix_str ); SetWindowTextA( hWndCtl, Template ); SetWindowLongA( hWnd, DWL_MSGRESULT, 1 ); return TRUE; } } } break; case WM_COMMAND: if (wParam == IDOK) { EndDialog(hWnd, TRUE); return TRUE; } break; } return 0; } /************************************************************************* * ShellAboutA [SHELL32.243] */ BOOL WINAPI ShellAboutA( HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff, HICON hIcon ) { ABOUT_INFO info; TRACE(shell,"\n"); info.szApp = szApp; info.szOtherStuff = szOtherStuff; info.hIcon = hIcon; if (!hIcon) info.hIcon = LoadIcon16( 0, MAKEINTRESOURCE16(OIC_WINEICON) ); return DialogBoxIndirectParamA( WIN_GetWindowInstance( hWnd ), SYSRES_GetResPtr( SYSRES_DIALOG_SHELL_ABOUT_MSGBOX ), hWnd, AboutDlgProc, (LPARAM)&info ); } /************************************************************************* * ShellAboutW [SHELL32.244] */ BOOL WINAPI ShellAboutW( HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon ) { BOOL ret; ABOUT_INFO info; TRACE(shell,"\n"); info.szApp = HEAP_strdupWtoA( GetProcessHeap(), 0, szApp ); info.szOtherStuff = HEAP_strdupWtoA( GetProcessHeap(), 0, szOtherStuff ); info.hIcon = hIcon; if (!hIcon) info.hIcon = LoadIcon16( 0, MAKEINTRESOURCE16(OIC_WINEICON) ); ret = DialogBoxIndirectParamA( WIN_GetWindowInstance( hWnd ), SYSRES_GetResPtr( SYSRES_DIALOG_SHELL_ABOUT_MSGBOX ), hWnd, AboutDlgProc, (LPARAM)&info ); HeapFree( GetProcessHeap(), 0, (LPSTR)info.szApp ); HeapFree( GetProcessHeap(), 0, (LPSTR)info.szOtherStuff ); return ret; } /************************************************************************* * Shell_NotifyIcon [SHELL32.296] * FIXME * This function is supposed to deal with the systray. * Any ideas on how this is to be implimented? */ BOOL WINAPI Shell_NotifyIcon( DWORD dwMessage, PNOTIFYICONDATA pnid ) { TRACE(shell,"\n"); return FALSE; } /************************************************************************* * Shell_NotifyIcon [SHELL32.297] * FIXME * This function is supposed to deal with the systray. * Any ideas on how this is to be implimented? */ BOOL WINAPI Shell_NotifyIconA(DWORD dwMessage, PNOTIFYICONDATA pnid ) { TRACE(shell,"\n"); return FALSE; } /************************************************************************* * FreeIconList */ void WINAPI FreeIconList( DWORD dw ) { FIXME(shell, "(%lx): stub\n",dw); } /************************************************************************* * SHGetPathFromIDListA [SHELL32.261][NT 4.0: SHELL32.220] * * PARAMETERS * pidl, [IN] pidl * pszPath [OUT] path * * RETURNS * path from a passed PIDL. * * NOTES * exported by name * * FIXME * fnGetDisplayNameOf can return different types of OLEString */ DWORD WINAPI SHGetPathFromIDListA (LPCITEMIDLIST pidl,LPSTR pszPath) { STRRET lpName; LPSHELLFOLDER shellfolder; CHAR buffer[MAX_PATH],tpath[MAX_PATH]; DWORD type,tpathlen=MAX_PATH,dwdisp; HKEY key; TRACE(shell,"(pidl=%p,%p)\n",pidl,pszPath); if (!pidl) { strcpy(buffer,"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\"); if (RegCreateKeyExA(HKEY_CURRENT_USER,buffer,0,NULL,REG_OPTION_NON_VOLATILE,KEY_WRITE,NULL,&key,&dwdisp)) { return E_OUTOFMEMORY; } type=REG_SZ; strcpy (buffer,"Desktop"); /*registry name*/ if ( RegQueryValueExA(key,buffer,NULL,&type,(LPBYTE)tpath,&tpathlen)) { GetWindowsDirectoryA(tpath,MAX_PATH); PathAddBackslashA(tpath); strcat (tpath,"Desktop"); /*folder name*/ RegSetValueExA(key,buffer,0,REG_SZ,(LPBYTE)tpath,tpathlen); CreateDirectoryA(tpath,NULL); } RegCloseKey(key); strcpy(pszPath,tpath); } else { if (SHGetDesktopFolder(&shellfolder)==S_OK) { shellfolder->lpvtbl->fnGetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&lpName); shellfolder->lpvtbl->fnRelease(shellfolder); } strcpy(pszPath,lpName.u.cStr); } TRACE(shell,"-- (%s)\n",pszPath); return TRUE; } /************************************************************************* * SHGetPathFromIDListW [SHELL32.262] */ DWORD WINAPI SHGetPathFromIDListW (LPCITEMIDLIST pidl,LPWSTR pszPath) { char sTemp[MAX_PATH]; TRACE (shell,"(pidl=%p)\n", pidl); SHGetPathFromIDListA (pidl, sTemp); lstrcpyAtoW(pszPath, sTemp); TRACE(shell,"-- (%s)\n",debugstr_w(pszPath)); return TRUE; } /************************************************************************* * SHGetPathFromIDListAW [SHELL32.221][NT 4.0: SHELL32.219] */ BOOL WINAPI SHGetPathFromIDListAW(LPCITEMIDLIST pidl,LPVOID pszPath) { TRACE(shell,"(pidl=%p,%p)\n",pidl,pszPath); if (VERSION_OsIsUnicode()) return SHGetPathFromIDListW(pidl,pszPath); return SHGetPathFromIDListA(pidl,pszPath); } /*********************************************************************** * DllGetVersion [COMCTL32.25] * * Retrieves version information of the 'SHELL32.DLL' * * PARAMS * pdvi [O] pointer to version information structure. * * RETURNS * Success: S_OK * Failure: E_INVALIDARG * * NOTES * Returns version of a shell32.dll from IE4.01 SP1. */ HRESULT WINAPI SHELL32_DllGetVersion (DLLVERSIONINFO *pdvi) { if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) { WARN (shell, "wrong DLLVERSIONINFO size from app"); return E_INVALIDARG; } pdvi->dwMajorVersion = 4; pdvi->dwMinorVersion = 72; pdvi->dwBuildNumber = 3110; pdvi->dwPlatformID = 1; TRACE (shell, "%lu.%lu.%lu.%lu\n", pdvi->dwMajorVersion, pdvi->dwMinorVersion, pdvi->dwBuildNumber, pdvi->dwPlatformID); return S_OK; } /************************************************************************* * global variables of the shell32.dll * */ void (WINAPI* pDLLInitComctl)(LPVOID); INT (WINAPI* pImageList_AddIcon) (HIMAGELIST himl, HICON hIcon); INT (WINAPI* pImageList_ReplaceIcon) (HIMAGELIST, INT, HICON); HIMAGELIST (WINAPI * pImageList_Create) (INT,INT,UINT,INT,INT); HICON (WINAPI * pImageList_GetIcon) (HIMAGELIST, INT, UINT); INT (WINAPI* pImageList_GetImageCount)(HIMAGELIST); LPVOID (WINAPI* pCOMCTL32_Alloc) (INT); BOOL (WINAPI* pCOMCTL32_Free) (LPVOID); HDPA (WINAPI* pDPA_Create) (INT); INT (WINAPI* pDPA_InsertPtr) (const HDPA, INT, LPVOID); BOOL (WINAPI* pDPA_Sort) (const HDPA, PFNDPACOMPARE, LPARAM); LPVOID (WINAPI* pDPA_GetPtr) (const HDPA, INT); BOOL (WINAPI* pDPA_Destroy) (const HDPA); INT (WINAPI *pDPA_Search) (const HDPA, LPVOID, INT, PFNDPACOMPARE, LPARAM, UINT); /* user32 */ HICON (WINAPI *pLookupIconIdFromDirectoryEx)(LPBYTE dir, BOOL bIcon, INT width, INT height, UINT cFlag); HICON (WINAPI *pCreateIconFromResourceEx)(LPBYTE bits,UINT cbSize, BOOL bIcon, DWORD dwVersion, INT width, INT height,UINT cFlag); static BOOL bShell32IsInitialized = 0; static HINSTANCE hComctl32; static INT shell32_RefCount = 0; INT shell32_ObjCount = 0; HINSTANCE shell32_hInstance; /************************************************************************* * SHELL32 LibMain * */ BOOL WINAPI Shell32LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad) { HMODULE hUser32; TRACE(shell,"0x%x 0x%lx %p\n", hinstDLL, fdwReason, fImpLoad); shell32_hInstance = hinstDLL; switch (fdwReason) { case DLL_PROCESS_ATTACH: if (!bShell32IsInitialized) { hComctl32 = LoadLibraryA("COMCTL32.DLL"); hUser32 = GetModuleHandleA("USER32"); if (hComctl32 && hUser32) { pDLLInitComctl=(void*)GetProcAddress(hComctl32,"InitCommonControlsEx"); if (pDLLInitComctl) { pDLLInitComctl(NULL); } pImageList_Create=(void*)GetProcAddress(hComctl32,"ImageList_Create"); pImageList_AddIcon=(void*)GetProcAddress(hComctl32,"ImageList_AddIcon"); pImageList_ReplaceIcon=(void*)GetProcAddress(hComctl32,"ImageList_ReplaceIcon"); pImageList_GetIcon=(void*)GetProcAddress(hComctl32,"ImageList_GetIcon"); pImageList_GetImageCount=(void*)GetProcAddress(hComctl32,"ImageList_GetImageCount"); /* imports by ordinal, pray that it works*/ pCOMCTL32_Alloc=(void*)GetProcAddress(hComctl32, (LPCSTR)71L); pCOMCTL32_Free=(void*)GetProcAddress(hComctl32, (LPCSTR)73L); pDPA_Create=(void*)GetProcAddress(hComctl32, (LPCSTR)328L); pDPA_Destroy=(void*)GetProcAddress(hComctl32, (LPCSTR)329L); pDPA_GetPtr=(void*)GetProcAddress(hComctl32, (LPCSTR)332L); pDPA_InsertPtr=(void*)GetProcAddress(hComctl32, (LPCSTR)334L); pDPA_Sort=(void*)GetProcAddress(hComctl32, (LPCSTR)338L); pDPA_Search=(void*)GetProcAddress(hComctl32, (LPCSTR)339L); /* user32 */ pLookupIconIdFromDirectoryEx=(void*)GetProcAddress(hUser32,"LookupIconIdFromDirectoryEx"); pCreateIconFromResourceEx=(void*)GetProcAddress(hUser32,"CreateIconFromResourceEx"); } else { ERR(shell,"P A N I C SHELL32 loading failed\n"); return FALSE; } SIC_Initialize(); bShell32IsInitialized = TRUE; } shell32_RefCount++; break; case DLL_THREAD_ATTACH: shell32_RefCount++; break; case DLL_THREAD_DETACH: shell32_RefCount--; break; case DLL_PROCESS_DETACH: shell32_RefCount--; if ( !shell32_RefCount ) { FreeLibrary(hComctl32); bShell32IsInitialized = FALSE; if (pdesktopfolder) { pdesktopfolder->lpvtbl->fnRelease(pdesktopfolder); } SIC_Destroy(); /* this one is here to check if AddRef/Release is balanced */ if (shell32_ObjCount) { WARN(shell,"leaving with %u objects left (memory leak)\n", shell32_ObjCount); } } TRACE(shell, "refcount=%u objcount=%u \n", shell32_RefCount, shell32_ObjCount); break; } return TRUE; }