marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

- New (some stubs): SHGetFolderLocation, PathAddExtension, 

PathIsUNCServer, PathIsUNCServerShare, PathMakePretty,
  SHCreateShellPalette, SHOpenRegStream, SHOpenRegStream2
- Many string functions implemented
- Some stubs for exports by ordinal
oldstable
Juergen Schmied 2000-06-01 23:25:44 +00:00 committed by Alexandre Julliard
parent 6d01aeb20f
commit 0d18aad17a
14 changed files with 1878 additions and 564 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/shell32/Makefile.in
View File

@ -34,6 +34,8 @@ C_SRCS = \
shellole.c \
shellord.c \
shellpath.c \
shellstring.c \
shellreg.c \
shlfileop.c \
shlfolder.c \
shlview.c \

19
dlls/shell32/pidl.c
View File

@ -849,6 +849,25 @@ HRESULT WINAPI SHGetSpecialFolderLocation(
return hr;
}
/*************************************************************************
* SHGetFolderLocation [SHELL32]
*
* NOTES
* the pidl can be a simple one. since we cant get the path out of the pidl
* we have to take all data from the pidl
*/
HRESULT WINAPI SHGetFolderLocation(
HWND hwnd,
int csidl,
HANDLE hToken,
DWORD dwFlags,
LPITEMIDLIST *ppidl)
{
FIXME("0x%04x 0x%08x 0x%08x 0x%08lx %p\n",
hwnd, csidl, hToken, dwFlags, ppidl);
return SHGetSpecialFolderLocation(hwnd, csidl, ppidl);
}
/*************************************************************************
* SHGetDataFromIDListA [SHELL32.247]
*

104
dlls/shell32/regstream.c
View File

@ -18,8 +18,6 @@ typedef struct
{ ICOM_VFIELD(IStream);
DWORD ref;
HKEY hKey;
LPSTR pszSubKey;
LPSTR pszValue;
LPBYTE pbBuffer;
DWORD dwLength;
DWORD dwPos;
@ -28,28 +26,31 @@ typedef struct
static struct ICOM_VTABLE(IStream) rstvt;
/**************************************************************************
* IStream_Constructor()
* IStream_ConstructorA [internal]
*/
IStream *IStream_Constructor(HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD grfMode)
{ ISHRegStream* rstr;
IStream *IStream_ConstructorA(HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD grfMode)
{
ISHRegStream* rstr;
DWORD dwType;
rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
ICOM_VTBL(rstr)=&rstvt;
rstr->ref = 1;
if ( ERROR_SUCCESS == RegOpenKeyExA (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey)))
{ if ( ERROR_SUCCESS == RegQueryValueExA(rstr->hKey, (LPSTR)pszValue,0,0,0,&(rstr->dwLength)))
if (!(RegOpenKeyExA (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey))))
{
if (!(RegQueryValueExA(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
{
/* read the binary data into the buffer */
rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength);
if (rstr->pbBuffer)
{ if ( ERROR_SUCCESS == RegQueryValueExA(rstr->hKey, (LPSTR)pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength)))
{ if (dwType == REG_BINARY )
{ rstr->pszSubKey = HEAP_strdupA (GetProcessHeap(),0, pszSubKey);
rstr->pszValue = HEAP_strdupA (GetProcessHeap(),0, pszValue);
TRACE("(%p)->0x%08x,%s,%s,0x%08lx\n", rstr, hKey, pszSubKey, pszValue, grfMode);
if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
{
if (!(RegQueryValueExA(rstr->hKey, pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength))))
{
if (dwType == REG_BINARY )
{
shell32_ObjCount++;
TRACE ("%p\n", rstr);
return (IStream*)rstr;
}
}
@ -57,7 +58,44 @@ IStream *IStream_Constructor(HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD
}
}
RegCloseKey(rstr->hKey);
}
HeapFree (GetProcessHeap(),0,rstr);
return NULL;
}
/**************************************************************************
* IStream_ConstructorW [internal]
*/
IStream *IStream_ConstructorW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD grfMode)
{
ISHRegStream* rstr;
DWORD dwType;
rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
ICOM_VTBL(rstr)=&rstvt;
rstr->ref = 1;
if (!(RegOpenKeyExW (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey))))
{
if (!(RegQueryValueExW(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
{
/* read the binary data into the buffer */
if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
{
if (!(RegQueryValueExW(rstr->hKey, pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength))))
{
if (dwType == REG_BINARY )
{
shell32_ObjCount++;
TRACE ("%p\n", rstr);
return (IStream*)rstr;
}
}
HeapFree (GetProcessHeap(),0,rstr->pbBuffer);
}
}
RegCloseKey(rstr->hKey);
}
HeapFree (GetProcessHeap(),0,rstr);
return NULL;
@ -118,12 +156,6 @@ static ULONG WINAPI IStream_fnRelease(IStream *iface)
if (!--(This->ref))
{ TRACE(" destroying SHReg IStream (%p)\n",This);
if (This->pszSubKey)
HeapFree(GetProcessHeap(),0,This->pszSubKey);
if (This->pszValue)
HeapFree(GetProcessHeap(),0,This->pszValue);
if (This->pbBuffer)
HeapFree(GetProcessHeap(),0,This->pbBuffer);
@ -265,13 +297,31 @@ static struct ICOM_VTABLE(IStream) rstvt =
};
/*************************************************************************
* OpenRegStream [SHELL32.85]
*
* NOTES
* exported by ordinal
* SHOpenRegStreamA [SHLWAPI.@][SHELL32.85]
*/
IStream * WINAPI OpenRegStream(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD grfMode)
IStream * WINAPI SHOpenRegStreamA(
HKEY hkey,
LPCSTR pszSubkey,
LPCSTR pszValue,
DWORD grfMode)
{
TRACE("(0x%08x,%s,%s,0x%08lx)\n",hkey, pszSubkey, pszValue, grfMode);
return IStream_Constructor(hkey, pszSubkey, pszValue, grfMode);
TRACE("(0x%08x,%s,%s,0x%08lx)\n",
hkey, pszSubkey, pszValue, grfMode);
return IStream_ConstructorA(hkey, pszSubkey, pszValue, grfMode);
}
/*************************************************************************
* SHOpenRegStreamW [SHLWAPI.@]
*/
IStream * WINAPI SHOpenRegStreamW(
HKEY hkey,
LPCWSTR pszSubkey,
LPCWSTR pszValue,
DWORD grfMode)
{
TRACE("(0x%08x,%s,%s,0x%08lx)\n",
hkey, debugstr_w(pszSubkey), debugstr_w(pszValue), grfMode);
return IStream_ConstructorW(hkey, pszSubkey, pszValue, grfMode);
}

78
dlls/shell32/shell32.spec
View File

@ -97,7 +97,7 @@ import ole32.dll
82 stdcall DragQueryFileA(long long ptr long) DragQueryFileA
83 stub CIDLData_CreateFromIDArray
84 stub SHIsBadInterfacePtr
85 stdcall OpenRegStream(long long long long) OpenRegStream
85 stdcall OpenRegStream(long str str long) SHOpenRegStreamA
86 stdcall SHRegisterDragDrop(long ptr) SHRegisterDragDrop
87 stdcall SHRevokeDragDrop(long) SHRevokeDragDrop
88 stdcall SHDoDragDrop(long long long long long) SHDoDragDrop
@ -160,9 +160,7 @@ import ole32.dll
145 stdcall PathFindOnPath (ptr ptr) PathFindOnPathAW
146 stdcall RLBuildListOfPaths()RLBuildListOfPaths
147 stdcall SHCLSIDFromString(long long) SHCLSIDFromStringAW
148 stdcall ExtractAssociatedIconA(long ptr long) ExtractAssociatedIconA # exported by name
149 stdcall SHFind_InitMenuPopup(long long long long) SHFind_InitMenuPopup
150 stub ExtractAssociatedIconExA # exported by name
151 stdcall SHLoadOLE (long) SHLoadOLE
152 stdcall ILGetSize(ptr) ILGetSize
153 stdcall ILGetNext(ptr) ILGetNext
@ -198,15 +196,6 @@ import ole32.dll
183 varargs ShellMessageBoxA(long long long str long) ShellMessageBoxA
184 stdcall ArrangeWindows(long long long long long) ArrangeWindows
185 stub SHHandleDiskFull
186 stub ExtractAssociatedIconExW # exported by name
187 stub ExtractAssociatedIconW # exported by name
188 stdcall ExtractIconA(long str long) ExtractIconA # exported by name
189 stdcall ExtractIconEx(ptr long ptr ptr long) ExtractIconExAW
190 stdcall ExtractIconExA(str long ptr ptr long) ExtractIconExA
191 stdcall ExtractIconExW(wstr long ptr ptr long) ExtractIconExW
192 stub ExtractIconResInfoA # exported by name
193 stub ExtractIconResInfoW # exported by name
194 stdcall ExtractIconW(long wstr long) ExtractIconW # exported by name
195 stdcall SHFree(ptr) SHFree
196 stdcall SHAlloc(long) SHAlloc
197 stub SHGlobalDefect
@ -254,9 +243,6 @@ import ole32.dll
239 stdcall SHChangeNotify (long long ptr ptr) SHChangeNotifyAW # exported by name
240 stub SHEmptyRecycleBinA@12 # exported by name
241 stub SHEmptyRecycleBinW@12 # exported by name
@ stdcall SHFileOperation (ptr) SHFileOperationAW
@ stdcall SHFileOperationA (ptr) SHFileOperationA
@ stdcall SHFileOperationW (ptr) SHFileOperationW
243 stdcall shell32_243(long long) shell32_243
244 stdcall SHInitRestricted(ptr ptr) SHInitRestricted # win98+ only, by ordinal
245 stub SHFormatDrive@16 # exported by name
@ -266,17 +252,6 @@ import ole32.dll
249 stdcall PathParseIconLocation (ptr) PathParseIconLocationAW
250 stdcall PathRemoveExtension (ptr) PathRemoveExtensionAW
251 stdcall PathRemoveArgs (ptr) PathRemoveArgsAW
@ stdcall SHGetDesktopFolder(ptr) SHGetDesktopFolder
@ stdcall SHGetFileInfo(ptr long ptr long long) SHGetFileInfoAW
@ stdcall SHGetFileInfoA(ptr long ptr long long) SHGetFileInfoA
@ stdcall SHGetFileInfoW(ptr long ptr long long) SHGetFileInfoW
@ stdcall SHGetInstanceExplorer (long) SHGetInstanceExplorer
@ stdcall SHGetMalloc(ptr) SHGetMalloc
@ stub SHGetNewLinkInfo@20
@ stdcall SHGetPathFromIDList(ptr ptr) SHGetPathFromIDListAW
@ stdcall SHGetPathFromIDListA (long long) SHGetPathFromIDListA
@ stdcall SHGetPathFromIDListW (long long) SHGetPathFromIDListW
@ stdcall SHGetSpecialFolderLocation(long long ptr) SHGetSpecialFolderLocation # exported by name
264 stdcall SHHelpShortcuts_RunDLL(long long long long) SHHelpShortcuts_RunDLL # exported by name
265 stub SHHelpShortcuts_RunDLLA@16 # exported by name
266 stub SHHelpShortcuts_RunDLLW@16 # exported by name
@ -284,7 +259,6 @@ import ole32.dll
268 stub SHQueryRecycleBinA@8 # exported by name
269 stub SHQueryRecycleBinW@8 # exported by name
270 stub SHUpdateRecycleBinIcon@0 # exported by name
271 stub SheChangeDirA
272 stub SheChangeDirExA
273 stub SheChangeDirExW
@ -315,14 +289,14 @@ import ole32.dll
298 stdcall Shell_NotifyIconW(long ptr) Shell_NotifyIconW
299 stub Shl1632_ThunkData32
300 stub Shl3216_ThunkData32
301 stub StrChrA
301 stdcall StrChrA (str long) StrChrA
302 stub StrChrIA
303 stub StrChrIW
304 stdcall StrChrW (wstr long) StrChrW
305 stub StrCmpNA
306 stub StrCmpNIA
305 stdcall StrCmpNA(str str long) StrCmpNA
306 stdcall StrCmpNIA (str str long) StrCmpNIA
307 stdcall StrCmpNIW (wstr wstr long) StrCmpNIW
308 stub StrCmpNW
308 stdcall StrCmpNW (wstr wstr long) StrCmpNW
309 stdcall StrCpyNA (ptr str long) lstrcpynA
310 stdcall StrCpyNW (ptr wstr long)lstrcpynW
311 stub StrNCmpA
@ -339,10 +313,10 @@ import ole32.dll
322 stub StrRStrIA
323 stub StrRStrIW
324 stub StrRStrW
325 stub StrStrA
326 stub StrStrIA
327 stub StrStrIW
328 stub StrStrW
325 stdcall StrStrA(str str)StrStrA
326 stdcall StrStrIA(str str)StrStrIA
327 stdcall StrStrIW(wstr wstr)StrStrIW
328 stdcall StrStrW(wstr wstr)StrStrW
329 stub WOWShellExecute # proper ordinal unknown
505 stdcall SHRegCloseKey (long) SHRegCloseKey
@ -385,6 +359,10 @@ import ole32.dll
680 stdcall IsUserAdmin () IsUserAdmin
# >= NT5
714 stdcall SHELL32_714(ptr)SHELL32_714
@ stdcall SHGetFolderLocation(long long long long ptr)SHGetFolderLocation
1217 stub FOOBAR1217 # no joke! This is the real name!!
# later additions ... FIXME: incorrect ordinals
@ -396,6 +374,32 @@ import ole32.dll
1222 stdcall DoEnvironmentSubstA (str str) DoEnvironmentSubstA # win98:293
1223 stdcall DoEnvironmentSubstW (wstr wstr) DoEnvironmentSubstW # win98:204
# by-name routines relocated in win98
# by-name routines
@ stdcall DllInstall (long wstr) SHELL32_DllInstall
@ stdcall DllInstall (long wstr) SHELL32_DllInstall
@ stdcall ExtractAssociatedIconA(long ptr long) ExtractAssociatedIconA # exported by name
@ stub ExtractAssociatedIconExA # exported by name
@ stub ExtractAssociatedIconExW # exported by name
@ stub ExtractAssociatedIconW # exported by name
@ stdcall ExtractIconA(long str long) ExtractIconA # exported by name
@ stdcall ExtractIconEx(ptr long ptr ptr long) ExtractIconExAW
@ stdcall ExtractIconExA(str long ptr ptr long) ExtractIconExA
@ stdcall ExtractIconExW(wstr long ptr ptr long) ExtractIconExW
@ stdcall ExtractIconW(long wstr long) ExtractIconW # exported by name
@ stub ExtractIconResInfoA # exported by name
@ stub ExtractIconResInfoW # exported by name
@ stdcall SHFileOperation (ptr) SHFileOperationAW
@ stdcall SHFileOperationA (ptr) SHFileOperationA
@ stdcall SHFileOperationW (ptr) SHFileOperationW
@ stdcall SHGetDesktopFolder(ptr) SHGetDesktopFolder
@ stdcall SHGetFileInfo(ptr long ptr long long) SHGetFileInfoAW
@ stdcall SHGetFileInfoA(ptr long ptr long long) SHGetFileInfoA
@ stdcall SHGetFileInfoW(ptr long ptr long long) SHGetFileInfoW
@ stdcall SHGetInstanceExplorer (long) SHGetInstanceExplorer
@ stdcall SHGetMalloc(ptr) SHGetMalloc
@ stub SHGetNewLinkInfo@20
@ stdcall SHGetPathFromIDList(ptr ptr) SHGetPathFromIDListAW
@ stdcall SHGetPathFromIDListA (long long) SHGetPathFromIDListA
@ stdcall SHGetPathFromIDListW (long long) SHGetPathFromIDListW
@ stdcall SHGetSpecialFolderLocation(long long ptr) SHGetSpecialFolderLocation # exported by name

53
dlls/shell32/shell32_main.c
View File

@ -98,6 +98,7 @@ void WINAPI Control_RunDLL( HWND hwnd, LPCVOID code, LPCSTR cmd, DWORD arg4 )
/*************************************************************************
* SHGetFileInfoA [SHELL32.@]
*
*/
DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
@ -118,6 +119,11 @@ DWORD WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
if ((flags & SHGFI_USEFILEATTRIBUTES) && (flags & (SHGFI_ATTRIBUTES|SHGFI_EXETYPE|SHGFI_PIDL)))
return FALSE;
/* windows initializes this values regardless of the flags */
psfi->szDisplayName[0] = '\0';
psfi->szTypeName[0] = '\0';
psfi->iIcon = 0;
/* translate the path into a pidl only when SHGFI_USEFILEATTRIBUTES in not specified
the pidl functions fail on not existing file names */
if (flags & SHGFI_PIDL)
@ -298,6 +304,9 @@ DWORD WINAPI SHGetFileInfoAW(
/*************************************************************************
* ExtractIconA [SHELL32.133]
*
* fixme
* is the filename is not a file return 1
*/
HICON WINAPI ExtractIconA( HINSTANCE hInstance, LPCSTR lpszExeFileName,
UINT nIconIndex )
@ -316,6 +325,9 @@ HICON WINAPI ExtractIconA( HINSTANCE hInstance, LPCSTR lpszExeFileName,
/*************************************************************************
* ExtractIconW [SHELL32.180]
*
* fixme
* is the filename is not a file return 1
*/
HICON WINAPI ExtractIconW( HINSTANCE hInstance, LPCWSTR lpszExeFileName,
UINT nIconIndex )
@ -703,7 +715,7 @@ void WINAPI FreeIconList( DWORD dw )
}
/***********************************************************************
* DllGetVersion [COMCTL32.25]
* DllGetVersion [SHELL32]
*
* Retrieves version information of the 'SHELL32.DLL'
*
@ -721,7 +733,8 @@ void WINAPI FreeIconList( DWORD dw )
HRESULT WINAPI SHELL32_DllGetVersion (DLLVERSIONINFO *pdvi)
{
if (pdvi->cbSize != sizeof(DLLVERSIONINFO))
{ WARN("wrong DLLVERSIONINFO size from app");
{
WARN("wrong DLLVERSIONINFO size from app");
return E_INVALIDARG;
}
@ -736,6 +749,42 @@ HRESULT WINAPI SHELL32_DllGetVersion (DLLVERSIONINFO *pdvi)
return S_OK;
}
/***********************************************************************
* DllGetVersion [SHLWAPI]
*
* Retrieves version information of the 'SHLWAPI.DLL'
*
* PARAMS
* pdvi [O] pointer to version information structure.
*
* RETURNS
* Success: S_OK
* Failure: E_INVALIDARG
*
* NOTES
* Returns version of a SHLWAPI.dll from IE5.01.
*/
HRESULT WINAPI SHLWAPI_DllGetVersion (DLLVERSIONINFO *pdvi)
{
if (pdvi->cbSize != sizeof(DLLVERSIONINFO))
{
WARN("wrong DLLVERSIONINFO size from app");
return E_INVALIDARG;
}
pdvi->dwMajorVersion = 5;
pdvi->dwMinorVersion = 0;
pdvi->dwBuildNumber = 2314;
pdvi->dwPlatformID = 1000;
TRACE("%lu.%lu.%lu.%lu\n",
pdvi->dwMajorVersion, pdvi->dwMinorVersion,
pdvi->dwBuildNumber, pdvi->dwPlatformID);
return S_OK;
}
/*************************************************************************
* global variables of the shell32.dll
* all are once per process

776
dlls/shell32/shellord.c
View File

@ -183,59 +183,6 @@ int WINAPI SHShellFolderView_Message(
return 0;
}
/*************************************************************************
* OleStrToStrN [SHELL32.78]
*/
BOOL WINAPI OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
{
TRACE("(%p, %x, %s, %x)\n", lpStr, nStr, debugstr_wn(lpOle,nOle), nOle);
return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
}
BOOL WINAPI OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
{
TRACE("(%p, %x, %s, %x)\n", lpwStr, nwStr, debugstr_wn(lpOle,nOle), nOle);
if (lstrcpynW ( lpwStr, lpOle, nwStr))
{ return lstrlenW (lpwStr);
}
return 0;
}
BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
{
if (VERSION_OsIsUnicode())
return OleStrToStrNW (lpOut, nOut, lpIn, nIn);
return OleStrToStrNA (lpOut, nOut, lpIn, nIn);
}
/*************************************************************************
* StrToOleStrN [SHELL32.79]
* lpMulti, nMulti, nWide [IN]
* lpWide [OUT]
*/
BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
{
TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_an(lpStrA,nStr), nStr);
return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
}
BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
{
TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_wn(lpStrW, nStr), nStr);
if (lstrcpynW (lpWide, lpStrW, nWide))
{ return lstrlenW (lpWide);
}
return 0;
}
BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
{
if (VERSION_OsIsUnicode())
return StrToOleStrNW (lpWide, nWide, lpStr, nStr);
return StrToOleStrNA (lpWide, nWide, lpStr, nStr);
}
/*************************************************************************
* RegisterShellHook [SHELL32.181]
*
@ -344,7 +291,7 @@ int WINAPIV ShellMessageBoxA(
* free_ptr() - frees memory using IMalloc
* exported by ordinal
*/
#define MEM_DEBUG 1
#define MEM_DEBUG 0
void WINAPI SHFree(LPVOID x)
{
#if MEM_DEBUG
@ -754,175 +701,6 @@ BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
FIXME("0x%08x stub\n",bShow);
return 0;
}
/*************************************************************************
* SHRegCloseKey [NT4.0:SHELL32.505]
*
*/
HRESULT WINAPI SHRegCloseKey (HKEY hkey)
{ TRACE("0x%04x\n",hkey);
return RegCloseKey( hkey );
}
/*************************************************************************
* SHRegOpenKeyA [SHELL32.506]
*
*/
HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
{
TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
return RegOpenKeyA(hKey, lpSubKey, phkResult);
}
/*************************************************************************
* SHRegOpenKeyW [NT4.0:SHELL32.507]
*
*/
HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
{ WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
return RegOpenKeyW( hkey, lpszSubKey, retkey );
}
/*************************************************************************
* SHRegQueryValueExA [SHELL32.509]
*
*/
HRESULT WINAPI SHRegQueryValueExA(
HKEY hkey,
LPSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
LPDWORD lpcbData)
{
TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
}
/*************************************************************************
* SHRegQueryValueW [NT4.0:SHELL32.510]
*
*/
HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
LPWSTR lpszData, LPDWORD lpcbData )
{ WARN("0x%04x %s %p %p semi-stub\n",
hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
return RegQueryValueW( hkey, lpszSubKey, lpszData, lpcbData );
}
/*************************************************************************
* SHRegQueryValueExW [NT4.0:SHELL32.511]
*
* FIXME
* if the datatype REG_EXPAND_SZ then expand the string and change
* *pdwType to REG_SZ.
*/
HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
{ DWORD ret;
WARN("0x%04x %s %p %p %p %p semi-stub\n",
hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
return ret;
}
/* SHGetValue: Gets a value from the registry */
/*************************************************************************
* SHGetValueA
*
* Gets a value from the registry
*/
DWORD WINAPI SHGetValueA(
HKEY hkey,
LPCSTR pSubKey,
LPCSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData
)
{
FIXME("(%p),stub!\n", pSubKey);
return ERROR_SUCCESS; /* return success */
}
/*************************************************************************
* SHGetValueW
*
* Gets a value from the registry
*/
DWORD WINAPI SHGetValueW(
HKEY hkey,
LPCWSTR pSubKey,
LPCWSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData
)
{
FIXME("(%p),stub!\n", pSubKey);
return ERROR_SUCCESS; /* return success */
}
/* gets a user-specific registry value. */
/*************************************************************************
* SHRegGetUSValueA
*
* Gets a user-specific registry value
*/
LONG WINAPI SHRegGetUSValueA(
LPCSTR pSubKey,
LPCSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData,
BOOL fIgnoreHKCU,
LPVOID pDefaultData,
DWORD wDefaultDataSize
)
{
FIXME("(%p),stub!\n", pSubKey);
return ERROR_SUCCESS; /* return success */
}
/*************************************************************************
* SHRegGetUSValueW
*
* Gets a user-specific registry value
*/
LONG WINAPI SHRegGetUSValueW(
LPCWSTR pSubKey,
LPCWSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData,
BOOL flagIgnoreHKCU,
LPVOID pDefaultData,
DWORD wDefaultDataSize
)
{
FIXME("(%p),stub!\n", pSubKey);
return ERROR_SUCCESS; /* return success */
}
/*************************************************************************
* SHRegDeleteKeyA and SHDeleteKeyA
*/
HRESULT WINAPI SHRegDeleteKeyA(HKEY hkey, LPCSTR pszSubKey)
{
FIXME("hkey=0x%08x, %s\n", hkey, debugstr_a(pszSubKey));
return 0;
}
/*************************************************************************
* SHRegDeleteKeyW and SHDeleteKeyA
*/
HRESULT WINAPI SHRegDeleteKeyW(HKEY hkey, LPCWSTR pszSubKey)
{
FIXME("hkey=0x%08x, %s\n", hkey, debugstr_w(pszSubKey));
return 0;
}
/*************************************************************************
* ReadCabinetState [NT 4.0:SHELL32.651]
*
@ -956,128 +734,6 @@ HRESULT WINAPI IsUserAdmin(void)
return TRUE;
}
/*************************************************************************
* StrRetToBufA [SHLWAPI.@]
*
* converts a STRRET to a normal string
*
* NOTES
* the pidl is for STRRET OFFSET
*/
HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD len)
{
return StrRetToStrNA(dest, len, src, pidl);
}
/*************************************************************************
* StrRetToBufW [SHLWAPI.@]
*
* converts a STRRET to a normal string
*
* NOTES
* the pidl is for STRRET OFFSET
*/
HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
{
return StrRetToStrNW(dest, len, src, pidl);
}
/*************************************************************************
* StrRetToStrN [SHELL32.96]
*
* converts a STRRET to a normal string
*
* NOTES
* the pidl is for STRRET OFFSET
*/
HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
{
TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
switch (src->uType)
{
case STRRET_WSTR:
WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
SHFree(src->u.pOleStr);
break;
case STRRET_CSTRA:
lstrcpynA((LPSTR)dest, src->u.cStr, len);
break;
case STRRET_OFFSETA:
lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
break;
default:
FIXME("unknown type!\n");
if (len)
{
*(LPSTR)dest = '\0';
}
return(FALSE);
}
return S_OK;
}
HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
{
TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
switch (src->uType)
{
case STRRET_WSTR:
lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
SHFree(src->u.pOleStr);
break;
case STRRET_CSTRA:
lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
break;
case STRRET_OFFSETA:
if (pidl)
{
lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
}
break;
default:
FIXME("unknown type!\n");
if (len)
{ *(LPSTR)dest = '\0';
}
return(FALSE);
}
return S_OK;
}
HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
{
if(VERSION_OsIsUnicode())
return StrRetToStrNW (dest, len, src, pidl);
return StrRetToStrNA (dest, len, src, pidl);
}
/*************************************************************************
* StrChrW [NT 4.0:SHELL32.651]
*
*/
LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
{
TRACE("%s 0x%04x\n",debugstr_w(str),x);
return CRTDLL_wcschr(str, x);
}
/*************************************************************************
* StrCmpNIW [NT 4.0:SHELL32.*]
*
*/
INT WINAPI StrCmpNIW ( LPWSTR wstr1, LPWSTR wstr2, INT len)
{
TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
return CRTDLL__wcsnicmp(wstr1, wstr2, len);
}
/*************************************************************************
* SHAllocShared [SHELL32.520]
*
@ -1199,49 +855,6 @@ HRESULT WINAPI SHFlushClipboard(void)
return 1;
}
/*************************************************************************
* StrFormatByteSizeA [SHLWAPI]
*/
LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
{ char buf[64];
TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
if ( dw<1024L )
{ sprintf (buf,"%3.1f bytes", (FLOAT)dw);
}
else if ( dw<1048576L)
{ sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
}
else if ( dw < 1073741824L)
{ sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
}
else
{ sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
}
lstrcpynA (pszBuf, buf, cchBuf);
return pszBuf;
}
/*************************************************************************
* StrFormatByteSizeW [SHLWAPI]
*/
LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
{ char buf[64];
TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
if ( dw<1024L )
{ sprintf (buf,"%3.1f bytes", (FLOAT)dw);
}
else if ( dw<1048576L)
{ sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
}
else if ( dw < 1073741824L)
{ sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
}
else
{ sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
}
lstrcpynAtoW (pszBuf, buf, cchBuf);
return pszBuf;
}
/*************************************************************************
* SHWaitForFileToOpen [SHELL32.97]
*
@ -1294,36 +907,6 @@ DWORD WINAPI RLBuildListOfPaths (void)
{ FIXME("stub\n");
return 0;
}
/************************************************************************
* StrToOleStr [SHELL32.163]
*
*/
int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
{
TRACE("(%p, %p %s)\n",
lpWideCharStr, lpMultiByteString, debugstr_a(lpMultiByteString));
return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
}
int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
{
TRACE("(%p, %p %s)\n",
lpWideCharStr, lpWString, debugstr_w(lpWString));
if (lstrcpyW (lpWideCharStr, lpWString ))
{ return lstrlenW (lpWideCharStr);
}
return 0;
}
BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
{
if (VERSION_OsIsUnicode())
return StrToOleStrW (lpWideCharStr, lpString);
return StrToOleStrA (lpWideCharStr, lpString);
}
/************************************************************************
* SHValidateUNC [SHELL32.173]
*
@ -1378,3 +961,360 @@ BOOL WINAPI shell32_243(DWORD a, DWORD b)
return FALSE;
}
/*************************************************************************
* SHCreateShellPalette
*/
HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
{
FIXME("stub\n");
return CreateHalftonePalette(hdc);
}
/*
NOTES: The most functions exported by ordinal seem to be superflous.
The reason for these functions to be there is to provide a wraper
for unicode functions to providing these functions on systems without
unicode functions eg. win95/win98. Since we have such functions we just
call these.
*/
/*************************************************************************
* SHLWAPI_1 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_1 (
LPSTR lpStr,
LPVOID x)
{
FIXME("(%p %s %p %s)\n",lpStr, debugstr_a(lpStr),x, debugstr_a(x));
return 0;
}
/*************************************************************************
* SHLWAPI_23 [SHLWAPI.23]
*
* NOTES
* converts a guid to a string
* returns strlen(str)
*/
DWORD WINAPI SHLWAPI_23 (
REFGUID guid, /* [in] clsid */
LPSTR str, /* [out] buffer */
INT cmax) /* [in] size of buffer */
{
char xguid[80];
TRACE("(%s %p 0x%08x)stub\n", debugstr_guid(guid), str, cmax);
if (WINE_StringFromCLSID(guid,xguid)) return 0;
if (strlen(xguid)>=cmax) return 0;
strcpy(str,xguid);
return strlen(xguid) + 1;
}
/*************************************************************************
* SHLWAPI_24 [SHLWAPI.24]
*
* NOTES
* converts a guid to a string
* returns strlen(str)
*/
DWORD WINAPI SHLWAPI_24 (
REFGUID guid, /* [in] clsid */
LPWSTR str, /* [out] buffer */
INT cmax) /* [in] size of buffer */
{
TRACE("(%s %p 0x%08x)stub\n", debugstr_guid(guid), str, cmax);
return StringFromGUID2(guid, str, cmax);
}
/*************************************************************************
* SHLWAPI_156 [SHLWAPI]
*
* FIXME: function guessed
*/
DWORD WINAPI SHLWAPI_156 (
LPWSTR str1, /* "shell32.dll" */
LPWSTR str2) /* "shell32.dll" */
{
FIXME("(%s %s)stub\n",debugstr_w(str1),debugstr_w(str2));
return lstrcmpW(str1,str2);
}
/*************************************************************************
* SHLWAPI_169 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_169 (IUnknown * lpUnknown)
{
TRACE("(%p)\n",lpUnknown);
#if 0
if(!lpUnknown || !*((LPDWORD)lpUnknown)) return 0;
return IUnknown_Release(lpUnknown);
#endif
return 0;
}
/*************************************************************************
* SHLWAPI_193 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_193 ()
{
HDC hdc;
DWORD ret;
TRACE("()\n");
hdc = GetDC(0);
ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
ReleaseDC(0, hdc);
return ret;
}
/*************************************************************************
* SHLWAPI_219 [SHLWAPI]
*/
HRESULT WINAPI SHLWAPI_219 (
LPVOID w, /* returned by LocalAlloc */
LPVOID x,
LPVOID y,
LPWSTR z) /* OUT: path */
{
FIXME("(%p %p %p %p)stub\n",w,x,y,z);
return 0xabba1252;
}
/*************************************************************************
* SHLWAPI_222 [SHLWAPI]
*
* NOTES
* securityattributes missing
*/
HANDLE WINAPI SHLWAPI_222 (LPCLSID guid)
{
char lpstrName[80];
strcpy( lpstrName,"shell.");
WINE_StringFromCLSID(guid, lpstrName + strlen(lpstrName));
FIXME("(%s) stub\n", lpstrName);
return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
}
/*************************************************************************
* SHLWAPI_223 [SHLWAPI]
*
* NOTES
* function guessed
*/
DWORD WINAPI SHLWAPI_223 (HANDLE handle)
{
DWORD oldCount;
FIXME("(0x%08x) stub\n",handle);
ReleaseSemaphore( handle, 1, &oldCount);
WaitForSingleObject( handle, 0 );
return 0;
}
/*************************************************************************
* SHLWAPI_237 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_237 (LPVOID x)
{
FIXME("(ptr=%p str=%s wstr=%s)\n",x,debugstr_a(x),debugstr_w(x));
return 0xabba1234;
}
/*************************************************************************
* SHLWAPI_241 [SHLWAPI]
*
*/
DWORD WINAPI SHLWAPI_241 ()
{
FIXME("()stub\n");
return 0xabba1243;
}
/*************************************************************************
* SHLWAPI_266 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_266 (
LPVOID w,
LPVOID x,
LPVOID y,
LPVOID z)
{
FIXME("(%p %p %p %p)stub\n",w,x,y,z);
return 0xabba1248;
}
/*************************************************************************
* SHLWAPI_267 [SHLWAPI]
*/
HRESULT WINAPI SHLWAPI_267 (
LPVOID w, /* same as 1th parameter of SHLWAPI_219 */
LPVOID x, /* same as 2nd parameter of SHLWAPI_219 */
LPVOID y,
LPVOID z)
{
FIXME("(%p %p %p %p)stub\n",w,x,y,z);
*((LPDWORD)z) = 0xabba1200;
return 0xabba1254;
}
/*************************************************************************
* SHLWAPI_268 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_268 (
LPVOID w,
LPVOID x)
{
FIXME("(%p %p)\n",w,x);
return 0xabba1251; /* 0 = failure */
}
/*************************************************************************
* SHLWAPI_276 [SHLWAPI]
*
*/
DWORD WINAPI SHLWAPI_276 ()
{
FIXME("()stub\n");
return 0xabba1244;
}
/*************************************************************************
* SHLWAPI_309 [SHLWAPI]
*
*/
DWORD WINAPI SHLWAPI_309 (LPVOID x)
{
FIXME("(%p)stub\n",x);
return 0xabba1245;
}
/*************************************************************************
* SHLWAPI_342 [SHLWAPI]
*
*/
DWORD WINAPI SHLWAPI_342 (
LPVOID w,
LPVOID x,
LPVOID y,
LPVOID z)
{
FIXME("(%p %p %p %p)stub\n",w,x,y,z);
return 0xabba1249;
}
/*************************************************************************
* SHLWAPI_346 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_346 (
LPCWSTR src,
LPWSTR dest,
int len)
{
FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
lstrcpynW(dest, src, len);
return lstrlenW(dest)+1;
}
/*************************************************************************
* SHLWAPI_377 [SHLWAPI]
*/
DWORD WINAPI SHLWAPI_377 (LPVOID x, LPVOID y, LPVOID z)
{
FIXME("(%p %p %p)stub\n", x,y,z);
return 0xabba1246;
}
/*************************************************************************
* SHLWAPI_437 [SHLWAPI]
*
* NOTES
* has to do something with switching the api between ascii and unicode
* observed values: 0 and 5
*
* accesses
* HKLM\System\CurrentControlSet\Control\ProductOptions
*
*/
DWORD WINAPI SHLWAPI_437 (DWORD x)
{
FIXME("(0x%08lx)stub\n", x);
return 0xabba1247;
}
/*************************************************************************
* wnsprintfA [SHLWAPI]
*/
int WINAPIV wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...)
{
va_list valist;
INT res;
va_start( valist, lpFmt );
res = wvsnprintfA( lpOut, cchLimitIn, lpFmt, valist );
va_end( valist );
return res;
}
/*************************************************************************
* wnsprintfW [SHLWAPI]
*/
int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...)
{
va_list valist;
INT res;
va_start( valist, lpFmt );
res = wvsnprintfW( lpOut, cchLimitIn, lpFmt, valist );
va_end( valist );
return res;
}
/*************************************************************************
* UrlEscapeA [SHLWAPI]
*/
HRESULT WINAPI UrlEscapeA(
LPCSTR pszUrl,
LPSTR pszEscaped,
LPDWORD pcchEscaped,
DWORD dwFlags)
{
FIXME("(%s %p %p 0x%08lx)stub\n",debugstr_a(pszUrl),
pszEscaped, pcchEscaped, dwFlags);
return 0;
}
/*************************************************************************
* UrlEscapeW [SHLWAPI]
*/
HRESULT WINAPI UrlEscapeW(
LPCWSTR pszUrl,
LPWSTR pszEscaped,
LPDWORD pcchEscaped,
DWORD dwFlags)
{
FIXME("(%s %p %p 0x%08lx)stub\n",debugstr_w(pszUrl),
pszEscaped, pcchEscaped, dwFlags);
return 0;
}
/*************************************************************************
* SHELL32_714 [SHELL32]
*/
DWORD WINAPI SHELL32_714(LPVOID x)
{
FIXME("(%s)stub\n", debugstr_w(x));
return 0;
}
/*************************************************************************
* SHIsLowMemoryMachine [SHLWAPI.@]
*/
DWORD WINAPI SHIsLowMemoryMachine (DWORD x)
{
FIXME("0x%08lx\n", x);
return 0;
}

153
dlls/shell32/shellpath.c
View File

@ -75,8 +75,6 @@ LPVOID WINAPI PathAppendAW(
*
* FIXME
* the resulting path is also canonicalized
* If lpszSrcPath2 starts with a backslash it is appended
* to the root of lpszSrcPath1.
*/
LPSTR WINAPI PathCombineA(
LPSTR szDest,
@ -94,10 +92,17 @@ LPSTR WINAPI PathCombineA(
}
/* if lpszFile is a complete path don't care about lpszDir */
if (PathIsRootA(lpszFile))
if (PathGetDriveNumberA(lpszFile) != -1)
{
strcpy(szDest,lpszFile);
}
else if (lpszFile[0] == '\\' )
{
strcpy(sTemp,lpszDir);
PathStripToRootA(sTemp);
strcat(sTemp,lpszFile);
strcpy(szDest,sTemp);
}
else
{
strcpy(sTemp,lpszDir);
@ -128,10 +133,17 @@ LPWSTR WINAPI PathCombineW(
}
/* if lpszFile is a complete path don't care about lpszDir */
if (PathIsRootW(lpszFile))
if (PathGetDriveNumberW(lpszFile) != -1)
{
CRTDLL_wcscpy(szDest,lpszFile);
}
else if (lpszFile[0] == (WCHAR)'\\' )
{
CRTDLL_wcscpy(sTemp,lpszDir);
PathStripToRootW(sTemp);
CRTDLL_wcscat(sTemp,lpszFile);
CRTDLL_wcscpy(szDest,sTemp);
}
else
{
CRTDLL_wcscpy(sTemp,lpszDir);
@ -769,7 +781,7 @@ LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
{
LPWSTR p = lpszPath;
while (*lpszPath); p = lpszPath++;
while (*lpszPath) p = lpszPath++;
if ( *p == (WCHAR)'\\') *p = (WCHAR)'\0';
return p;
}
@ -2188,3 +2200,134 @@ LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
}
return NULL;
}
/*************************************************************************
* PathAddExtensionA
*/
static void _PathAddDotA(LPSTR lpszPath)
{
int len = strlen(lpszPath);
if (len && lpszPath[len-1]!='.')
{
lpszPath[len] = '.';
lpszPath[len+1]= '\0';
}
}
BOOL WINAPI PathAddExtensionA(
LPSTR pszPath,
LPCSTR pszExtension)
{
if (*pszPath)
{
LPSTR pszExt = PathFindFileNameA(pszPath); /* last path component */
pszExt = PathFindExtensionA(pszExt);
if (*pszExt != '\0') return FALSE; /* already with extension */
_PathAddDotA(pszPath);
}
if (!pszExtension || *pszExtension=='\0')
strcat(pszPath, "exe");
else
strcat(pszPath, pszExtension);
return TRUE;
}
/*************************************************************************
* PathAddExtensionW
*/
static void _PathAddDotW(LPWSTR lpszPath)
{
int len = lstrlenW(lpszPath);
if (len && lpszPath[len-1]!='.')
{
lpszPath[len] = '.';
lpszPath[len+1]= '\0';
}
}
/*************************************************************************
* PathAddExtensionW
*/
BOOL WINAPI PathAddExtensionW(
LPWSTR pszPath,
LPCWSTR pszExtension)
{
static const WCHAR ext[] = { 'e','x','e',0 };
if (*pszPath)
{
LPWSTR pszExt = PathFindFileNameW(pszPath); /* last path component */
pszExt = PathFindExtensionW(pszExt);
if (*pszExt != '\0') return FALSE; /* already with extension */
_PathAddDotW(pszPath);
}
if (!pszExtension || *pszExtension=='\0')
lstrcatW(pszPath, ext);
else
lstrcatW(pszPath, pszExtension);
return TRUE;
}
/*************************************************************************
* PathIsUNCServerA
*/
BOOL WINAPI PathIsUNCServerA(
LPCSTR pszPath)
{
FIXME("%s\n", pszPath);
return FALSE;
}
/*************************************************************************
* PathIsUNCServerW
*/
BOOL WINAPI PathIsUNCServerW(
LPCWSTR pszPath)
{
FIXME("%s\n", debugstr_w(pszPath));
return FALSE;
}
/*************************************************************************
* PathIsUNCServerShareA
*/
BOOL WINAPI PathIsUNCServerShareA(
LPCSTR pszPath)
{
FIXME("%s\n", pszPath);
return FALSE;
}
/*************************************************************************
* PathIsUNCServerShareW
*/
BOOL WINAPI PathIsUNCServerShareW(
LPCWSTR pszPath)
{
FIXME("%s\n", debugstr_w(pszPath));
return FALSE;
}
/*************************************************************************
* PathMakePrettyA
*/
BOOL WINAPI PathMakePrettyA(
LPSTR lpPath)
{
FIXME("%s\n", lpPath);
return TRUE;
}
/*************************************************************************
* PathMakePrettyW
*/
BOOL WINAPI PathMakePrettyW(
LPWSTR lpPath)
{
FIXME("%s\n", debugstr_w(lpPath));
return TRUE;
}

307
dlls/shell32/shellreg.c 100644
View File

@ -0,0 +1,307 @@
/*
Shell Registry Access
*/
#include <string.h>
#include <stdio.h>
#include "winerror.h"
#include "winreg.h"
#include "debugtools.h"
#include "winnls.h"
#include "winversion.h"
#include "heap.h"
#include "crtdll.h"
#include "shellapi.h"
#include "shlobj.h"
#include "shell32_main.h"
#include "wine/undocshell.h"
DEFAULT_DEBUG_CHANNEL(shell);
/*************************************************************************
* SHRegOpenKeyA [SHELL32.506]
*
*/
HRESULT WINAPI SHRegOpenKeyA(
HKEY hKey,
LPSTR lpSubKey,
LPHKEY phkResult)
{
TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
return RegOpenKeyA(hKey, lpSubKey, phkResult);
}
/*************************************************************************
* SHRegOpenKeyW [NT4.0:SHELL32.507]
*
*/
HRESULT WINAPI SHRegOpenKeyW (
HKEY hkey,
LPCWSTR lpszSubKey,
LPHKEY retkey)
{
WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
return RegOpenKeyW( hkey, lpszSubKey, retkey );
}
/*************************************************************************
* SHRegQueryValueExA SHQueryValueExA [SHELL32.509][SHLWAPI.@]
*
*/
HRESULT WINAPI SHRegQueryValueExA(
HKEY hkey,
LPSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
LPDWORD lpcbData)
{
TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
}
/*************************************************************************
* SHRegQueryValueW [NT4.0:SHELL32.510]
*
*/
HRESULT WINAPI SHRegQueryValueW(
HKEY hkey,
LPWSTR lpszSubKey,
LPWSTR lpszData,
LPDWORD lpcbData )
{
WARN("0x%04x %s %p %p semi-stub\n",
hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
return RegQueryValueW( hkey, lpszSubKey, lpszData, lpcbData );
}
/*************************************************************************
* SHRegQueryValueExW, SHQueryValueExW [NT4.0:SHELL32.511][SHLWAPI.@]
*
* FIXME
* if the datatype REG_EXPAND_SZ then expand the string and change
* *pdwType to REG_SZ.
*/
HRESULT WINAPI SHRegQueryValueExW (
HKEY hkey,
LPWSTR pszValue,
LPDWORD pdwReserved,
LPDWORD pdwType,
LPVOID pvData,
LPDWORD pcbData)
{
DWORD ret;
WARN("0x%04x %s %p %p %p %p semi-stub\n",
hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
return ret;
}
/* SHGetValue: Gets a value from the registry */
/*************************************************************************
* SHGetValueA
*
* Gets a value from the registry
*/
DWORD WINAPI SHGetValueA(
HKEY hkey,
LPCSTR pSubKey,
LPCSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData)
{
HKEY hSubKey;
DWORD res;
TRACE("(%s %s)\n", pSubKey, pValue);
if((res = RegOpenKeyA(hkey, pSubKey, &hSubKey))) return res;
res = RegQueryValueExA(hSubKey, pValue, 0, pwType, pvData, pbData);
RegCloseKey( hSubKey );
return res;
}
/*************************************************************************
* SHGetValueW
*
* Gets a value from the registry
*/
DWORD WINAPI SHGetValueW(
HKEY hkey,
LPCWSTR pSubKey,
LPCWSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData)
{
HKEY hSubKey;
DWORD res;
TRACE("(%s %s)\n", debugstr_w(pSubKey), debugstr_w(pValue));
if((res = RegOpenKeyW(hkey, pSubKey, &hSubKey))) return res;
res = RegQueryValueExW(hSubKey, pValue, 0, pwType, pvData, pbData);
RegCloseKey( hSubKey );
return res;
}
/* gets a user-specific registry value. */
/*************************************************************************
* SHRegGetUSValueA
*
* Gets a user-specific registry value
*/
LONG WINAPI SHRegGetUSValueA(
LPCSTR pSubKey,
LPCSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData,
BOOL fIgnoreHKCU,
LPVOID pDefaultData,
DWORD wDefaultDataSize)
{
FIXME("(%p),stub!\n", pSubKey);
return ERROR_SUCCESS; /* return success */
}
/*************************************************************************
* SHRegGetUSValueW
*
* Gets a user-specific registry value
*/
LONG WINAPI SHRegGetUSValueW(
LPCWSTR pSubKey,
LPCWSTR pValue,
LPDWORD pwType,
LPVOID pvData,
LPDWORD pbData,
BOOL flagIgnoreHKCU,
LPVOID pDefaultData,
DWORD wDefaultDataSize)
{
FIXME("(%p),stub!\n", pSubKey);
return ERROR_SUCCESS; /* return success */
}
/*************************************************************************
* SHRegGetBoolUSValueA
*/
BOOL WINAPI SHRegGetBoolUSValueA(
LPCSTR pszSubKey,
LPCSTR pszValue,
BOOL fIgnoreHKCU,
BOOL fDefault)
{
FIXME("%s %s\n", pszSubKey,pszValue);
return fDefault;
}
/*************************************************************************
* SHRegGetBoolUSValueW
*/
BOOL WINAPI SHRegGetBoolUSValueW(
LPCWSTR pszSubKey,
LPCWSTR pszValue,
BOOL fIgnoreHKCU,
BOOL fDefault)
{
FIXME("%s %s\n", debugstr_w(pszSubKey),debugstr_w(pszValue));
return fDefault;
}
/*************************************************************************
* SHRegQueryUSValueA [SHLWAPI]
*/
LONG WINAPI SHRegQueryUSValueA(
HKEY/*HUSKEY*/ hUSKey,
LPCSTR pszValue,
LPDWORD pdwType,
void *pvData,
LPDWORD pcbData,
BOOL fIgnoreHKCU,
void *pvDefaultData,
DWORD dwDefaultDataSize)
{
FIXME("%s stub\n",pszValue);
return 1;
}
/*************************************************************************
* SHRegGetPathA
*/
DWORD WINAPI SHRegGetPathA(
HKEY hKey,
LPCSTR pcszSubKey,
LPCSTR pcszValue,
LPSTR pszPath,
DWORD dwFlags)
{
FIXME("%s %s\n", pcszSubKey, pcszValue);
return 0;
}
/*************************************************************************
* SHRegGetPathW
*/
DWORD WINAPI SHRegGetPathW(
HKEY hKey,
LPCWSTR pcszSubKey,
LPCWSTR pcszValue,
LPWSTR pszPath,
DWORD dwFlags)
{
FIXME("%s %s\n", debugstr_w(pcszSubKey), debugstr_w(pcszValue));
return 0;
}
/*************************************************************************
* SHRegDeleteKeyA and SHDeleteKeyA
*/
HRESULT WINAPI SHRegDeleteKeyA(
HKEY hkey,
LPCSTR pszSubKey)
{
FIXME("hkey=0x%08x, %s\n", hkey, debugstr_a(pszSubKey));
return 0;
}
/*************************************************************************
* SHRegDeleteKeyW and SHDeleteKeyA
*/
HRESULT WINAPI SHRegDeleteKeyW(
HKEY hkey,
LPCWSTR pszSubKey)
{
FIXME("hkey=0x%08x, %s\n", hkey, debugstr_w(pszSubKey));
return 0;
}
/*************************************************************************
* SHSetValueA [SHLWAPI]
*/
DWORD WINAPI SHSetValueA(
HKEY hkey,
LPCSTR pszSubKey,
LPCSTR pszValue,
DWORD dwType,
LPCVOID pvData,
DWORD cbData)
{
FIXME("(%s %s)stub\n",pszSubKey, pszValue);
return 1;
}
/*************************************************************************
* SHRegCloseKey [NT4.0:SHELL32.505]
*
*/
HRESULT WINAPI SHRegCloseKey (HKEY hkey)
{
TRACE("0x%04x\n",hkey);
return RegCloseKey( hkey );
}

467
dlls/shell32/shellstring.c 100644
View File

@ -0,0 +1,467 @@
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include "winnls.h"
#include "winerror.h"
#include "debugtools.h"
#include "winversion.h"
#include "crtdll.h"
#include "heap.h"
#include "shellapi.h"
#include "wine/undocshell.h"
DEFAULT_DEBUG_CHANNEL(shell);
/************************* STRRET functions ****************************/
/*************************************************************************
* StrRetToStrN [SHELL32.96]
*
* converts a STRRET to a normal string
*
* NOTES
* the pidl is for STRRET OFFSET
*/
HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
{
TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
switch (src->uType)
{
case STRRET_WSTR:
WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
SHFree(src->u.pOleStr);
break;
case STRRET_CSTRA:
lstrcpynA((LPSTR)dest, src->u.cStr, len);
break;
case STRRET_OFFSETA:
lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
break;
default:
FIXME("unknown type!\n");
if (len)
{
*(LPSTR)dest = '\0';
}
return(FALSE);
}
return S_OK;
}
HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
{
TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
switch (src->uType)
{
case STRRET_WSTR:
lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
SHFree(src->u.pOleStr);
break;
case STRRET_CSTRA:
lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
break;
case STRRET_OFFSETA:
if (pidl)
{
lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
}
break;
default:
FIXME("unknown type!\n");
if (len)
{ *(LPSTR)dest = '\0';
}
return(FALSE);
}
return S_OK;
}
HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
{
if(VERSION_OsIsUnicode())
return StrRetToStrNW (dest, len, src, pidl);
return StrRetToStrNA (dest, len, src, pidl);
}
/*************************************************************************
* StrRetToBufA [SHLWAPI.@]
*
* converts a STRRET to a normal string
*
* NOTES
* the pidl is for STRRET OFFSET
*/
HRESULT WINAPI StrRetToBufA (LPSTRRET src, LPITEMIDLIST pidl, LPSTR dest, DWORD len)
{
return StrRetToStrNA(dest, len, src, pidl);
}
/*************************************************************************
* StrRetToBufW [SHLWAPI.@]
*
* converts a STRRET to a normal string
*
* NOTES
* the pidl is for STRRET OFFSET
*/
HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
{
return StrRetToStrNW(dest, len, src, pidl);
}
/************************* string functions ****************************/
/*************************************************************************
* StrChrA [SHLWAPI]
*/
LPSTR WINAPI StrChrA (LPCSTR str, INT c)
{
TRACE("%s %i stub\n", str,c);
return strchr(str, c);
}
/*************************************************************************
* StrChrW [NT 4.0:SHELL32.651]
*
*/
LPWSTR WINAPI StrChrW (LPWSTR str, WCHAR x )
{
TRACE("%s 0x%04x\n",debugstr_w(str),x);
return CRTDLL_wcschr(str, x);
}
/*************************************************************************
* StrCmpNA [NT 4.0:SHELL32.*]
*/
INT WINAPI StrCmpNA ( LPCSTR str1, LPCSTR str2, INT len)
{
TRACE("%s %s %i stub\n", str1,str2,len);
return strncmp(str1, str2, len);
}
/*************************************************************************
* StrCmpNW [NT 4.0:SHELL32.*]
*/
INT WINAPI StrCmpNW ( LPCWSTR wstr1, LPCWSTR wstr2, INT len)
{
TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
return CRTDLL_wcsncmp(wstr1, wstr2, len);
}
/*************************************************************************
* StrCmpNIA [NT 4.0:SHELL32.*]
*/
int WINAPI StrCmpNIA ( LPCSTR str1, LPCSTR str2, int len)
{
TRACE("%s %s %i stub\n", str1,str2,len);
return strncasecmp(str1, str2, len);
}
/*************************************************************************
* StrCmpNIW [NT 4.0:SHELL32.*]
*/
int WINAPI StrCmpNIW ( LPCWSTR wstr1, LPCWSTR wstr2, int len)
{
TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
return CRTDLL__wcsnicmp(wstr1, wstr2, len);
}
/*************************************************************************
* StrStrA [SHLWAPI]
*/
LPSTR WINAPI StrStrA(LPCSTR lpFirst, LPCSTR lpSrch)
{
while (*lpFirst)
{
LPCSTR p1 = lpFirst, p2 = lpSrch;
while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
if (!*p2) return (LPSTR)lpFirst;
lpFirst++;
}
return NULL;
}
/*************************************************************************
* StrStrW [SHLWAPI]
*/
LPWSTR WINAPI StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch)
{
while (*lpFirst)
{
LPCWSTR p1 = lpFirst, p2 = lpSrch;
while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
if (!*p2) return (LPWSTR)lpFirst;
lpFirst++;
}
return NULL;
}
/*************************************************************************
* StrStrIA [SHLWAPI]
*/
LPSTR WINAPI StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch)
{
while (*lpFirst)
{
LPCSTR p1 = lpFirst, p2 = lpSrch;
while (*p1 && *p2 && toupper(*p1) == toupper(*p2)) { p1++; p2++; }
if (!*p2) return (LPSTR)lpFirst;
lpFirst++;
}
return NULL;
}
/*************************************************************************
* StrStrIW [SHLWAPI]
*/
LPWSTR WINAPI StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch)
{
while (*lpFirst)
{
LPCWSTR p1 = lpFirst, p2 = lpSrch;
while (*p1 && *p2 && CRTDLL_towupper(*p1) == CRTDLL_towupper(*p2)) { p1++; p2++; }
if (!*p2) return (LPWSTR)lpFirst;
lpFirst++;
}
return NULL;
}
/*************************************************************************
* StrToIntA [SHLWAPI]
*/
int WINAPI StrToIntA(LPCSTR lpSrc)
{
TRACE("%s\n", lpSrc);
return atol(lpSrc);
}
/*************************************************************************
* StrToIntW [SHLWAPI]
*/
int WINAPI StrToIntW(LPCWSTR lpSrc)
{
int ret;
LPSTR lpStr = HEAP_strdupWtoA(GetProcessHeap(),0,lpSrc);
TRACE("%s\n", debugstr_w(lpSrc));
ret = atol(lpStr);
HeapFree(GetProcessHeap(),0,lpStr);
return ret;
}
/*************************************************************************
* StrDupA [SHLWAPI]
*/
LPSTR WINAPI StrDupA (LPCSTR lpSrc)
{
int len = strlen(lpSrc);
LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
TRACE("%s\n", lpSrc);
if (lpDest) strcpy(lpDest, lpSrc);
return lpDest;
}
/*************************************************************************
* StrDupW [SHLWAPI]
*/
LPWSTR WINAPI StrDupW (LPCWSTR lpSrc)
{
int len = lstrlenW(lpSrc);
LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
TRACE("%s\n", debugstr_w(lpSrc));
if (lpDest) lstrcpyW(lpDest, lpSrc);
return lpDest;
}
/*************************************************************************
* StrCSpnA [SHLWAPI]
*/
int StrCSpnA (LPCSTR lpStr, LPCSTR lpSet)
{
int i,j, pos = strlen(lpStr);
TRACE("(%p %s %p %s)\n",
lpStr, debugstr_a(lpStr), lpSet, debugstr_a(lpSet));
for (i=0; i < strlen(lpSet) ; i++ )
{
for (j = 0; j < pos;j++)
{
if (lpStr[j] == lpSet[i])
{
pos = j;
}
}
}
TRACE("-- %u\n", pos);
return pos;
}
/*************************************************************************
* StrCSpnW [SHLWAPI]
*/
int StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
{
int i,j, pos = lstrlenW(lpStr);
TRACE("(%p %s %p %s)\n",
lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
for (i=0; i < lstrlenW(lpSet) ; i++ )
{
for (j = 0; j < pos;j++)
{
if (lpStr[j] == lpSet[i])
{
pos = j;
}
}
}
TRACE("-- %u\n", pos);
return pos;
}
/************************* OLESTR functions ****************************/
/************************************************************************
* StrToOleStr [SHELL32.163]
*
*/
int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
{
TRACE("(%p, %p %s)\n",
lpWideCharStr, lpMultiByteString, debugstr_a(lpMultiByteString));
return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
}
int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
{
TRACE("(%p, %p %s)\n",
lpWideCharStr, lpWString, debugstr_w(lpWString));
if (lstrcpyW (lpWideCharStr, lpWString ))
{ return lstrlenW (lpWideCharStr);
}
return 0;
}
BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
{
if (VERSION_OsIsUnicode())
return StrToOleStrW (lpWideCharStr, lpString);
return StrToOleStrA (lpWideCharStr, lpString);
}
/*************************************************************************
* StrToOleStrN [SHELL32.79]
* lpMulti, nMulti, nWide [IN]
* lpWide [OUT]
*/
BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
{
TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_an(lpStrA,nStr), nStr);
return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
}
BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
{
TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_wn(lpStrW, nStr), nStr);
if (lstrcpynW (lpWide, lpStrW, nWide))
{ return lstrlenW (lpWide);
}
return 0;
}
BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
{
if (VERSION_OsIsUnicode())
return StrToOleStrNW (lpWide, nWide, lpStr, nStr);
return StrToOleStrNA (lpWide, nWide, lpStr, nStr);
}
/*************************************************************************
* OleStrToStrN [SHELL32.78]
*/
BOOL WINAPI OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
{
TRACE("(%p, %x, %s, %x)\n", lpStr, nStr, debugstr_wn(lpOle,nOle), nOle);
return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
}
BOOL WINAPI OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
{
TRACE("(%p, %x, %s, %x)\n", lpwStr, nwStr, debugstr_wn(lpOle,nOle), nOle);
if (lstrcpynW ( lpwStr, lpOle, nwStr))
{ return lstrlenW (lpwStr);
}
return 0;
}
BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
{
if (VERSION_OsIsUnicode())
return OleStrToStrNW (lpOut, nOut, lpIn, nIn);
return OleStrToStrNA (lpOut, nOut, lpIn, nIn);
}
/*************************************************************************
* StrFormatByteSizeA [SHLWAPI]
*/
LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
{ char buf[64];
TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
if ( dw<1024L )
{ sprintf (buf,"%3.1f bytes", (FLOAT)dw);
}
else if ( dw<1048576L)
{ sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
}
else if ( dw < 1073741824L)
{ sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
}
else
{ sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
}
lstrcpynA (pszBuf, buf, cchBuf);
return pszBuf;
}
/*************************************************************************
* StrFormatByteSizeW [SHLWAPI]
*/
LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
{ char buf[64];
TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
if ( dw<1024L )
{ sprintf (buf,"%3.1f bytes", (FLOAT)dw);
}
else if ( dw<1048576L)
{ sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
}
else if ( dw < 1073741824L)
{ sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
}
else
{ sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
}
lstrcpynAtoW (pszBuf, buf, cchBuf);
return pszBuf;
}

8
dlls/shell32/shlfolder.c
View File

@ -1819,12 +1819,12 @@ static HRESULT WINAPI ISF_Desktop_fnCreateViewObject( IShellFolder2 * iface,
if(IsEqualIID(riid, &IID_IDropTarget))
{
FIXME("IDropTarget not implemented\n");
WARN("IDropTarget not implemented\n");
hr = E_NOTIMPL;
}
else if(IsEqualIID(riid, &IID_IContextMenu))
{
FIXME("IContextMenu not implemented\n");
WARN("IContextMenu not implemented\n");
hr = E_NOTIMPL;
}
else if(IsEqualIID(riid, &IID_IShellView))
@ -2242,12 +2242,12 @@ static HRESULT WINAPI ISF_MyComputer_fnCreateViewObject( IShellFolder2 * iface,
if(IsEqualIID(riid, &IID_IDropTarget))
{
FIXME("IDropTarget not implemented\n");
WARN("IDropTarget not implemented\n");
hr = E_NOTIMPL;
}
else if(IsEqualIID(riid, &IID_IContextMenu))
{
FIXME("IContextMenu not implemented\n");
WARN("IContextMenu not implemented\n");
hr = E_NOTIMPL;
}
else if(IsEqualIID(riid, &IID_IShellView))

2
dlls/shell32/shlmenu.c
View File

@ -106,7 +106,7 @@ static LPFMINFO FM_SetMenuParameter(
*/
static int FM_InitMenuPopup(HMENU hmenu, LPITEMIDLIST pAlternatePidl)
{ IShellFolder *lpsf, *lpsf2;
ULONG ulItemAttr;
ULONG ulItemAttr = SFGAO_FOLDER;
UINT uID, uFlags, uEnumFlags;
LPFNFMCALLBACK lpfnCallback;
LPITEMIDLIST pidl;

429
dlls/shell32/shlwapi.spec
View File

@ -1,8 +1,7 @@
name shlwapi
type win32
# ordinal exports
1 stub @
1 stdcall SHLWAPI_1(ptr ptr)SHLWAPI_1
2 stub @
3 stub @
4 stub @
@ -24,8 +23,8 @@ type win32
20 stub @
21 stub @
22 stub @
23 stub @
24 stub @
23 stdcall SHLWAPI_23(ptr ptr long)SHLWAPI_23
24 stdcall SHLWAPI_24(ptr ptr long)SHLWAPI_24
25 stub @
26 stub @
27 stub @
@ -68,9 +67,9 @@ type win32
64 stub @
65 stub @
66 stub @
67 stub @
68 stub @
69 stub @
67 forward SHLWAPI_67 user32.FindWindowW
68 forward SHLWAPI_68 kernel32.FormatMessageW
69 forward SHLWAPI_69 user32.GetClassInfoW
70 stub @
71 stub @
72 stub @
@ -81,10 +80,10 @@ type win32
77 stub @
78 stub @
79 stub @
80 stub @
81 stub @
82 stub @
83 stub @
80 forward SHLWAPI_80 kernel32.GetModuleFileNameW
81 forward SHLWAPI_81 kernel32.GetSystemDirectoryW
82 forward SHLWAPI_82 kernel32.SearchPathW
83 forward SHLWAPI_83 kernel32.GetModuleHandleW
84 stub @
85 stub @
86 stub @
@ -103,7 +102,7 @@ type win32
99 stub @
100 stub @
101 stub @
102 stub @
102 forward SHLWAPI_102 user32.LoadCursorW
103 stub @
104 stub @
105 stub @
@ -121,18 +120,18 @@ type win32
117 stub @
118 stub @
119 stub @
120 stub @
120 forward SHLWAPI_120 advapi32.RegCreateKeyExW
121 stub @
122 stub @
123 stub @
124 stub @
125 stub @
125 forward SHLWAPI_125 advapi32.RegOpenKeyExW
126 stub @
127 stub @
128 stub @
128 forward SHLWAPI_128 advapi32.RegQueryValueExW
129 stub @
130 stub @
131 stub @
131 forward SHLWAPI_131 user32.RegisterClassW
132 stub @
133 stub @
134 stub @
@ -148,7 +147,7 @@ type win32
144 stub @
145 stub @
146 stub @
147 stub @
147 forward SHLWAPI_147 user32.UnregisterClassW
148 stub @
149 stub @
150 stub @
@ -157,26 +156,309 @@ type win32
153 stub @
154 stub @
155 stub @
156 stub @
156 stdcall SHLWAPI_156 (wstr wstr) SHLWAPI_156
157 stub @
158 stub @
159 stub @
160 stub @
161 stub @
162 stub @
163 stub @
164 stub @
165 stub @
166 stub @
167 stub @
168 stub @
169 stdcall SHLWAPI_169(long)SHLWAPI_169
170 stub @
171 stub @
172 stub @
173 stub @
174 stub @
175 stub @
176 stub @
177 stub @
178 stub @
179 stub @
180 stub @
181 stub @
182 stub @
183 stub @
184 stub @
185 stub @
186 stub @
187 stub @
188 stub @
189 stub @
190 stub @
191 stub @
192 stub @
193 stdcall SHLWAPI_193()SHLWAPI_193
194 stub @
195 stub @
196 stub @
197 stub @
198 stub @
199 stub @
200 stub @
201 stub @
202 stub @
203 stub @
204 stub @
205 stub @
206 stub @
207 stub @
208 stub @
209 stub @
210 stub @
211 stub @
212 stub @
213 stub @
214 stub @
215 stub @
216 stub @
217 stub @
218 stub @
219 stdcall SHLWAPI_219(long long long long)SHLWAPI_219
220 stub @
221 stub @
222 stdcall SHLWAPI_222(long)SHLWAPI_222
223 stdcall SHLWAPI_223(long)SHLWAPI_223
224 stub @
225 stub @
226 stub @
227 stub @
228 stub @
229 stub @
230 stub @
231 stub @
232 stub @
233 stub @
234 stub @
235 stub @
236 stub @
237 stdcall SHLWAPI_237(ptr)SHLWAPI_237
238 stub @
239 stub @
240 stub @
241 stdcall SHLWAPI_241()SHLWAPI_241
242 stub @
243 stub @
244 stub @
245 stub @
246 stub @
247 stub @
248 stub @
249 stub @
250 stub @
251 stub @
252 stub @
253 stub AssocCreate
254 stub AssocQueryKeyA
255 stub AssocQueryKeyW
256 stub @
257 stub @
258 stub @
259 stub @
260 stub @
261 stub @
262 stub @
263 stub @
264 stub @
265 stub @
266 stdcall SHLWAPI_266(long long long long)SHLWAPI_266
267 stdcall SHLWAPI_267(long long long long)SHLWAPI_267
268 stdcall SHLWAPI_268(long long)SHLWAPI_268
269 stub @
270 stub @
271 stub @
272 stub @
273 stub @
274 stub @
275 stub @
276 stdcall SHLWAPI_276()SHLWAPI_276
277 stub @
278 stub @
279 stub @
280 stub @
281 stub @
282 stub @
283 stub @
284 stub @
285 stub @
286 stub @
287 stub @
288 stub @
289 stub @
290 stub @
291 stub @
292 stub @
293 stub @
294 stub @
295 stub @
296 stub @
297 stub @
298 stub @
299 stub @
300 stub @
301 stub @
302 stub @
303 stub @
304 stub @
305 stub @
306 stub @
307 stub @
308 stub @
309 stdcall SHLWAPI_309(ptr)SHLWAPI_309
310 stub @
311 stub @
312 stub @
313 stub @
314 stub @
315 stub @
316 stub SHCreateStreamOnFileAOld
317 stub SHCreateStreamOnFileWOld
318 stub @
319 stub @
320 stub @
321 stub @
322 stub @
323 stub @
324 stub @
325 stub @
326 stub @
327 stub @
328 stub @
329 stub @
330 stub @
331 stub @
332 stub @
333 stub @
334 stub @
335 stub @
336 stub @
337 stub @
338 stub @
339 stub @
340 stub @
341 stub @
342 stdcall SHLWAPI_342(long long long long)SHLWAPI_342
343 stub @
344 stub @
345 stub @
346 stdcall SHLWAPI_346(wstr ptr long)SHLWAPI_346
347 stub @
348 stub @
349 stub @
350 stub @
351 stub @
352 stub @
353 stub @
354 stub @
355 stub @
356 stub @
357 stub @
358 stub @
359 stub @
360 stub @
361 stub @
362 stub @
363 stub @
364 stub @
365 stub @
366 stub @
367 stub @
368 stub @
369 stub @
370 stub @
371 stub @
372 stub @
373 stub @
374 stub @
375 stub @
376 stub @
377 stdcall SHLWAPI_377(long long long)SHLWAPI_377
378 stub @
379 stub @
380 stub @
381 stub AssocQueryStringA
382 stub AssocQueryStringByKeyA
383 stub AssocQueryStringByKeyW
384 stub AssocQueryStringW
385 stub ChrCmpIA
386 stub ChrCmpIW
387 stub ColorAdjustLuma
388 stub @
389 stub @
390 stub @
391 stub @
392 stub @
393 stub @
394 stub @
395 stub @
396 stub @
397 stub @
398 stub @
399 stub @
400 stub @
401 stub @
402 stub @
403 stub @
404 stub @
405 stub @
406 stub @
407 stub @
408 stub @
409 stub @
410 stub @
411 stub @
412 stub @
413 stub @
414 stub @
415 stub @
416 stub @
417 stub @
418 stub @
419 stub @
420 stub @
421 stub @
422 stub @
423 stub @
424 stub @
425 stub @
426 stub @
427 stub @
428 stub @
429 stub @
430 stub @
431 stub @
432 stub @
433 stub @
434 stub @
435 stub @
436 stub @
437 stdcall SHLWAPI_437(long) SHLWAPI_437
438 stub @
439 stub @
440 stub @
441 stub @
442 stub @
443 stub @
444 stub @
445 stub @
446 stub @
@ stub ChrCmpIA
@ stub ChrCmpIW
@ stub DllGetVersion
@ stdcall DllGetVersion (ptr) SHLWAPI_DllGetVersion
@ stub GetMenuPosFromID
@ stub HashData
@ stub IntlStrEqWorkerA
@ stub IntlStrEqWorkerW
@ stdcall PathAddBackslashA (ptr) PathAddBackslashA
@ stdcall PathAddBackslashW (ptr) PathAddBackslashW
@ stub PathAddExtensionA
@ stub PathAddExtensionW
@ stdcall PathAddBackslashA (str) PathAddBackslashA
@ stdcall PathAddBackslashW (wstr) PathAddBackslashW
@ stdcall PathAddExtensionA (str str) PathAddExtensionA
@ stdcall PathAddExtensionW (wstr wstr) PathAddExtensionW
@ stdcall PathAppendA (str str) PathAppendA
@ stdcall PathAppendW (str str) PathAppendW
@ stdcall PathAppendW (wstr wstr) PathAppendW
@ stdcall PathBuildRootA (ptr long) PathBuildRootA
@ stdcall PathBuildRootW (ptr long) PathBuildRootW
@ stdcall PathCanonicalizeA (ptr str) PathCanonicalizeA
@ -224,23 +506,23 @@ type win32
@ stub PathIsSystemFolderA
@ stub PathIsSystemFolderW
@ stdcall PathIsUNCA (str) PathIsUNCA
@ stub PathIsUNCServerA
@ stub PathIsUNCServerShareA
@ stub PathIsUNCServerShareW
@ stub PathIsUNCServerW
@ stdcall PathIsUNCServerA(str)PathIsUNCServerA
@ stdcall PathIsUNCServerShareA(str)PathIsUNCServerShareA
@ stdcall PathIsUNCServerShareW(wstr)PathIsUNCServerShareW
@ stdcall PathIsUNCServerW(wstr)PathIsUNCServerW
@ stdcall PathIsUNCW(wstr) PathIsUNCW
@ stdcall PathIsURLA(str) PathIsURLA
@ stdcall PathIsURLW(wstr) PathIsURLW
@ stub PathMakePrettyA
@ stub PathMakePrettyW
@ stdcall PathMakePrettyA(str)PathMakePrettyA
@ stdcall PathMakePrettyW(wstr)PathMakePrettyW
@ stub PathMakeSystemFolderA
@ stub PathMakeSystemFolderW
@ stdcall PathMatchSpecA (str str) PathMatchSpecA
@ stdcall PathMatchSpecW (str str) PathMatchSpecW
@ stdcall PathMatchSpecW (wstr wstr) PathMatchSpecW
@ stdcall PathParseIconLocationA (str) PathParseIconLocationA
@ stdcall PathParseIconLocationW (wstr) PathParseIconLocationW
@ stdcall PathQuoteSpacesA (ptr) PathQuoteSpacesA
@ stdcall PathQuoteSpacesW (ptr) PathQuoteSpacesW
@ stdcall PathQuoteSpacesA (str) PathQuoteSpacesA
@ stdcall PathQuoteSpacesW (wstr) PathQuoteSpacesW
@ stub PathRelativePathToA
@ stub PathRelativePathToW
@ stdcall PathRemoveArgsA(str)PathRemoveArgsA
@ -269,7 +551,7 @@ type win32
@ stub PathUnmakeSystemFolderW
@ stdcall PathUnquoteSpacesA (str) PathUnquoteSpacesA
@ stdcall PathUnquoteSpacesW (wstr) PathUnquoteSpacesW
@ stub SHCreateShellPalette
@ stdcall SHCreateShellPalette(long)SHCreateShellPalette
@ stub SHDeleteEmptyKeyA
@ stub SHDeleteEmptyKeyW
@ stdcall SHDeleteKeyA(long str)SHRegDeleteKeyA
@ -283,15 +565,17 @@ type win32
@ stub SHEnumValueA
@ stub SHEnumValueW
@ stub SHGetInverseCMAP
@ stdcall SHGetValueA ( long ptr ptr ptr ptr ptr ) SHGetValueA
@ stdcall SHGetValueW ( long ptr ptr ptr ptr ptr ) SHGetValueW
@ stub SHIsLowMemoryMachine
@ stub SHOpenRegStreamA
@ stub SHOpenRegStreamW
@ stdcall SHGetValueA ( long str str ptr ptr ptr ) SHGetValueA
@ stdcall SHGetValueW ( long wstr wstr ptr ptr ptr ) SHGetValueW
@ stdcall SHIsLowMemoryMachine(long)SHIsLowMemoryMachine
@ stdcall SHOpenRegStreamA(long str str long)SHOpenRegStreamA
@ stdcall SHOpenRegStreamW(long wstr str long)SHOpenRegStreamW
@ stdcall SHOpenRegStream2A(long str str long)SHOpenRegStreamA
@ stdcall SHOpenRegStream2W(long wstr str long)SHOpenRegStreamW
@ stub SHQueryInfoKeyA
@ stub SHQueryInfoKeyW
@ stub SHQueryValueExA
@ stub SHQueryValueExW
@ stdcall SHQueryValueExA(long str ptr ptr ptr ptr)SHRegQueryValueExA
@ stdcall SHQueryValueExW(long wstr ptr ptr ptr ptr)SHRegQueryValueExW
@ stub SHRegCloseUSKey
@ stub SHRegCreateUSKeyA
@ stub SHRegCreateUSKeyW
@ -303,41 +587,41 @@ type win32
@ stub SHRegEnumUSKeyW
@ stub SHRegEnumUSValueA
@ stub SHRegEnumUSValueW
@ stub SHRegGetBoolUSValueA
@ stub SHRegGetBoolUSValueW
@ stdcall SHRegGetUSValueA ( ptr ptr ptr ptr ptr long ptr long ) SHRegGetUSValueA
@ stdcall SHRegGetUSValueW ( ptr ptr ptr ptr ptr long ptr long ) SHRegGetUSValueW
@ stdcall SHRegGetBoolUSValueA(str str long long)SHRegGetBoolUSValueA
@ stdcall SHRegGetBoolUSValueW(wstr wstr long long)SHRegGetBoolUSValueW
@ stdcall SHRegGetUSValueA ( ptr str ptr ptr ptr long ptr long ) SHRegGetUSValueA
@ stdcall SHRegGetUSValueW ( ptr wstr ptr ptr ptr long ptr long ) SHRegGetUSValueW
@ stub SHRegOpenUSKeyA
@ stub SHRegOpenUSKeyW
@ stub SHRegQueryInfoUSKeyA
@ stub SHRegQueryInfoUSKeyW
@ stub SHRegQueryUSValueA
@ stdcall SHRegQueryUSValueA(long str ptr ptr ptr long ptr long)SHRegQueryUSValueA
@ stub SHRegQueryUSValueW
@ stub SHRegSetUSValueA
@ stub SHRegSetUSValueW
@ stub SHRegWriteUSValueA
@ stub SHRegWriteUSValueW
@ stub SHSetValueA
@ stdcall SHSetValueA (long str str long ptr long) SHSetValueA
@ stub SHSetValueW
@ stub StrCSpnA
@ stdcall StrCSpnA (str str) StrCSpnA
@ stub StrCSpnIA
@ stub StrCSpnIW
@ stub StrCSpnW
@ stdcall StrCSpnW (wstr wstr) StrCSpnW
@ stub StrCatW
@ stdcall StrChrA (ptr long) strchr
@ stdcall StrChrA (str long) StrChrA
@ stub StrChrIA
@ stub StrChrIW
@ stdcall StrChrW (ptr long) StrChrW
@ stub StrCmpIW
@ stub StrCmpNA
@ stub StrCmpNIA
@ stdcall StrChrW (wstr long) StrChrW
@ stdcall StrCmpIW (wstr wstr) lstrcmpiW
@ stdcall StrCmpNA (str str long) StrCmpNA
@ stdcall StrCmpNIA (str str long) StrCmpNIA
@ stdcall StrCmpNIW (wstr wstr long) StrCmpNIW
@ stub StrCmpNW
@ stub StrCmpW
@ stub StrCpyNW
@ stub StrCpyW
@ stub StrDupA
@ stub StrDupW
@ stdcall StrCmpNW (wstr wstr long) StrCmpNW
@ stdcall StrCmpW (wstr wstr) lstrcmpW
@ stdcall StrCpyNW (ptr wstr long) lstrcpynW
@ stdcall StrCpyW (ptr wstr) lstrcpyW
@ stdcall StrDupA (str) StrDupA
@ stdcall StrDupW (wstr) StrDupW
@ stdcall StrFormatByteSizeA(long str long) StrFormatByteSizeA
@ stdcall StrFormatByteSizeW(long wstr long) StrFormatByteSizeW
@ stub StrFromTimeIntervalA
@ -356,14 +640,14 @@ type win32
@ stub StrRStrIW
@ stub StrSpnA
@ stub StrSpnW
@ stub StrStrA
@ stub StrStrIA
@ stub StrStrIW
@ stub StrStrW
@ stub StrToIntA
@ stdcall StrStrA(str str)StrStrA
@ stdcall StrStrIA(str str)StrStrIA
@ stdcall StrStrIW(wstr wstr)StrStrIW
@ stdcall StrStrW(wstr wstr)StrStrW
@ stdcall StrToIntA(str)StrToIntA
@ stub StrToIntExA
@ stub StrToIntExW
@ stub StrToIntW
@ stdcall StrToIntW(wstr)StrToIntW
@ stub StrTrimA
@ stub StrTrimW
@ stub UrlApplySchemeA
@ -376,8 +660,8 @@ type win32
@ stub UrlCompareW
@ stub UrlCreateFromPathA
@ stub UrlCreateFromPathW
@ stub UrlEscapeA
@ stub UrlEscapeW
@ stdcall UrlEscapeA(str ptr ptr long)UrlEscapeA
@ stdcall UrlEscapeW(wstr ptr ptr long)UrlEscapeW
@ stub UrlGetLocationA
@ stub UrlGetLocationW
@ stub UrlGetPartA
@ -392,9 +676,14 @@ type win32
@ stub UrlIsW
@ stub UrlUnescapeA
@ stub UrlUnescapeW
@ varargs wnsprintfA(ptr long str)wnsprintfA
@ varargs wnsprintfW(ptr long wstr)wnsprintfW
# exported in later versions
@ stdcall StrRetToBufA (ptr ptr ptr long) StrRetToBufA
@ stdcall StrRetToBufW (ptr ptr ptr long) StrRetToBufW
#@ stdcall StrRetToStrA (ptr ptr ptr) StrRetToStrA
#@ stdcall StrRetToStrW (ptr ptr ptr) StrRetToStrW
@ stdcall SHRegGetPathA(long str str ptr long)SHRegGetPathA
@ stdcall SHRegGetPathW(long wstr wstr ptr long)SHRegGetPathW

36
documentation/shell32
View File

@ -64,3 +64,39 @@ BUGS:
- many examples from MSDN
Feb-21-2000 <juergen.schmied@debitel.net>
4. native shell32
-----------------
4.1 win95/98
IShellFolder_GetAttributesOf sometimes returns more bits set
than the mask asked for
4.2 NT4
4.3 NT5
----------
SHGetSpecialFolderLocation needs the <winntdir>/Recent directory.
If the directory is missing it returns a x80070002.
needed Registry keys:
----------------------------
[MACHINE\\Software\\Classes\\CLSID\\{00021400-0000-0000-c000-000000000046}] 957887196
@="Desktop"
[MACHINE\\Software\\Classes\\CLSID\\{00021400-0000-0000-c000-000000000046}\\InProcServer32] 957887196
@="shell32.dll"
"ThreadingModel"="Apartment"
[MACHINE\\Software\\Classes\\CLSID\\{000214e6-0000-0000-c000-000000000046}] 957887196
@="Shellfolder"
[MACHINE\\Software\\Classes\\CLSID\\{000214e6-0000-0000-c000-000000000046}\\InProcServer32] 957887196
@="shell32.dll"
"ThreadingModel"="Apartment"
----------------------------

8
include/shlwapi.h
View File

@ -29,6 +29,14 @@ BOOL WINAPI PathIsURLA(LPCSTR pszPath);
BOOL WINAPI PathIsURLW(LPCWSTR pszPath);
#define PathIsURL WINELIB_NAME_AW(PathIsURL)
BOOL WINAPI PathAddExtensionA(LPSTR pszPath, LPCSTR pszExt);
BOOL WINAPI PathAddExtensionW(LPWSTR pszPath, LPCWSTR pszExt);
#define PathAddExtension WINELIB_NAME_AW(PathAddExtension)
BOOL WINAPI PathStripToRootA(LPSTR pszPath);
BOOL WINAPI PathStripToRootW(LPWSTR pszPath);
#define PathStripToRoot WINELIB_NAME_AW(PathStripToRoot)
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */