git.oblomov.eu Git - wine/blob - dlls/shell32/shellstring.c

   1 #include <string.h>
   2 #include <stdio.h>
   3 #include <ctype.h>
   4 #include <stdlib.h>
   5
   6 #include "winnls.h"
   7 #include "winerror.h"
   8 #include "winreg.h"
   9
  10 #include "shlobj.h"
  11 #include "shellapi.h"
  12 #include "shell32_main.h"
  13 #include "undocshell.h"
  14 #include "wine/unicode.h"
  15 #include "debugtools.h"
  16
  17 DEFAULT_DEBUG_CHANNEL(shell);
  18
  19 /************************* STRRET functions ****************************/
  20
  21 /*************************************************************************
  22  * StrRetToStrN                         [SHELL32.96]
  23  *
  24  * converts a STRRET to a normal string
  25  *
  26  * NOTES
  27  *  the pidl is for STRRET OFFSET
  28  *
  29  * ***** NOTE *****
  30  *  This routine is identical to StrRetToBufA in dlls/shlwapi/string.c.
  31  *  It was duplicated here because not every version of Shlwapi.dll exports
  32  *  StrRetToBufA. If you change one routine, change them both. YOU HAVE BEEN
  33  *  WARNED.
  34  * ***** NOTE *****
  35  */
  36 HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
  37 {
  38         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
  39
  40         switch (src->uType)
  41         {
  42           case STRRET_WSTR:
  43             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
  44 /*          SHFree(src->u.pOleStr);  FIXME: is this right? */
  45             break;
  46
  47           case STRRET_CSTRA:
  48             lstrcpynA((LPSTR)dest, src->u.cStr, len);
  49             break;
  50
  51           case STRRET_OFFSETA:
  52             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
  53             break;
  54
  55           default:
  56             FIXME("unknown type!\n");
  57             if (len)
  58             {
  59               *(LPSTR)dest = '\0';
  60             }
  61             return(FALSE);
  62         }
  63         return S_OK;
  64 }
  65
  66 /*************************************************************************
  67  * StrRetToStrNW                                [SHELL32.96]
  68  *
  69  * converts a STRRET to a normal string
  70  *
  71  * NOTES
  72  *  the pidl is for STRRET OFFSET
  73  *
  74  * ***** NOTE *****
  75  *  This routine is identical to StrRetToBufW in dlls/shlwapi/string.c.
  76  *  It was duplicated here because not every version of Shlwapi.dll exports
  77  *  StrRetToBufW. If you change one routine, change them both. YOU HAVE BEEN
  78  *  WARNED.
  79  * ***** NOTE *****
  80  */
  81
  82 HRESULT WINAPI StrRetToStrNW (LPVOID dest1, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
  83 {
  84     LPWSTR dest = (LPWSTR) dest1;
  85         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
  86
  87         switch (src->uType)
  88         {
  89           case STRRET_WSTR:
  90             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
  91 /*          SHFree(src->u.pOleStr);  FIXME: is this right? */
  92             break;
  93
  94           case STRRET_CSTRA:
  95               if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ) && len)
  96                   dest[len-1] = 0;
  97             break;
  98
  99           case STRRET_OFFSETA:
 100             if (pidl)
 101             {
 102               if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
 103                                         dest, len ) && len)
 104                   dest[len-1] = 0;
 105             }
 106             break;
 107
 108           default:
 109             FIXME("unknown type!\n");
 110             if (len)
 111             { *(LPSTR)dest = '\0';
 112             }
 113             return(FALSE);
 114         }
 115         return S_OK;
 116 }
 117
 118 /*************************************************************************/
 119
 120 HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
 121 {
 122         if(SHELL_OsIsUnicode())
 123           return StrRetToStrNW (dest, len, src, pidl);
 124         return StrRetToStrNA (dest, len, src, pidl);
 125 }
 126
 127 /************************* OLESTR functions ****************************/
 128
 129 /************************************************************************
 130  *      StrToOleStr                     [SHELL32.163]
 131  *
 132  */
 133 int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
 134 {
 135         TRACE("(%p, %p %s)\n",
 136         lpWideCharStr, lpMultiByteString, debugstr_a(lpMultiByteString));
 137
 138         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
 139
 140 }
 141 int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
 142 {
 143         TRACE("(%p, %p %s)\n",
 144         lpWideCharStr, lpWString, debugstr_w(lpWString));
 145
 146         strcpyW (lpWideCharStr, lpWString );
 147         return strlenW(lpWideCharStr);
 148 }
 149
 150 BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
 151 {
 152         if (SHELL_OsIsUnicode())
 153           return StrToOleStrW (lpWideCharStr, lpString);
 154         return StrToOleStrA (lpWideCharStr, lpString);
 155 }
 156
 157 /*************************************************************************
 158  * StrToOleStrN                                 [SHELL32.79]
 159  *  lpMulti, nMulti, nWide [IN]
 160  *  lpWide [OUT]
 161  */
 162 BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
 163 {
 164         TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_an(lpStrA,nStr), nStr);
 165         return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
 166 }
 167 BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
 168 {
 169         TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_wn(lpStrW, nStr), nStr);
 170
 171         if (lstrcpynW (lpWide, lpStrW, nWide))
 172         { return lstrlenW (lpWide);
 173         }
 174         return 0;
 175 }
 176
 177 BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
 178 {
 179         if (SHELL_OsIsUnicode())
 180           return StrToOleStrNW (lpWide, nWide, lpStr, nStr);
 181         return StrToOleStrNA (lpWide, nWide, lpStr, nStr);
 182 }
 183
 184 /*************************************************************************
 185  * OleStrToStrN                                 [SHELL32.78]
 186  */
 187 BOOL WINAPI OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
 188 {
 189         TRACE("(%p, %x, %s, %x)\n", lpStr, nStr, debugstr_wn(lpOle,nOle), nOle);
 190         return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
 191 }
 192
 193 BOOL WINAPI OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
 194 {
 195         TRACE("(%p, %x, %s, %x)\n", lpwStr, nwStr, debugstr_wn(lpOle,nOle), nOle);
 196
 197         if (lstrcpynW ( lpwStr, lpOle, nwStr))
 198         { return lstrlenW (lpwStr);
 199         }
 200         return 0;
 201 }
 202
 203 BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
 204 {
 205         if (SHELL_OsIsUnicode())
 206           return OleStrToStrNW (lpOut, nOut, lpIn, nIn);
 207         return OleStrToStrNA (lpOut, nOut, lpIn, nIn);
 208 }