dll/win32/shell32/shellstring.cpp

   1 /*
   2  * Copyright 2000 Juergen Schmied
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "precomp.h"
  20
  21 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  22
  23 /************************* STRRET functions ****************************/
  24
  25 BOOL WINAPI StrRetToStrNA(LPSTR dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
  26 {
  27     TRACE("dest=%p len=0x%x strret=%p(%s) pidl=%p\n",
  28         dest,len,src,
  29         (src->uType == STRRET_WSTR) ? "STRRET_WSTR" :
  30         (src->uType == STRRET_CSTR) ? "STRRET_CSTR" :
  31         (src->uType == STRRET_OFFSET) ? "STRRET_OFFSET" : "STRRET_???",
  32         pidl);
  33
  34     if (!dest)
  35         return FALSE;
  36
  37     switch (src->uType)
  38     {
  39       case STRRET_WSTR:
  40         WideCharToMultiByte(CP_ACP, 0, src->pOleStr, -1, dest, len, NULL, NULL);
  41         CoTaskMemFree(src->pOleStr);
  42         break;
  43
  44       case STRRET_CSTR:
  45         lstrcpynA(dest, src->cStr, len);
  46         break;
  47
  48       case STRRET_OFFSET:
  49         lstrcpynA(dest, ((LPCSTR)&pidl->mkid)+src->uOffset, len);
  50         break;
  51
  52       default:
  53         FIXME("unknown type!\n");
  54         if (len) *dest = '\0';
  55         return FALSE;
  56     }
  57     TRACE("-- %s\n", debugstr_a(dest) );
  58     return TRUE;
  59 }
  60
  61 /************************************************************************/
  62
  63 BOOL WINAPI StrRetToStrNW(LPWSTR dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
  64 {
  65     TRACE("dest=%p len=0x%x strret=%p(%s) pidl=%p\n",
  66         dest,len,src,
  67         (src->uType == STRRET_WSTR) ? "STRRET_WSTR" :
  68         (src->uType == STRRET_CSTR) ? "STRRET_CSTR" :
  69         (src->uType == STRRET_OFFSET) ? "STRRET_OFFSET" : "STRRET_???",
  70         pidl);
  71
  72     if (!dest)
  73         return FALSE;
  74
  75     switch (src->uType)
  76     {
  77       case STRRET_WSTR:
  78         lstrcpynW(dest, src->pOleStr, len);
  79         CoTaskMemFree(src->pOleStr);
  80         break;
  81
  82       case STRRET_CSTR:
  83             if (!MultiByteToWideChar( CP_ACP, 0, src->cStr, -1, dest, len ) && len)
  84                   dest[len-1] = 0;
  85         break;
  86
  87       case STRRET_OFFSET:
  88             if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->uOffset, -1, dest, len ) && len)
  89                   dest[len-1] = 0;
  90         break;
  91
  92       default:
  93         FIXME("unknown type!\n");
  94         if (len) *dest = '\0';
  95         return FALSE;
  96     }
  97     return TRUE;
  98 }
  99
 100
 101 /*************************************************************************
 102  * StrRetToStrN                [SHELL32.96]
 103  *
 104  * converts a STRRET to a normal string
 105  *
 106  * NOTES
 107  *  the pidl is for STRRET OFFSET
 108  */
 109 EXTERN_C BOOL WINAPI StrRetToStrNAW(LPVOID dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
 110 {
 111     if(SHELL_OsIsUnicode())
 112         return StrRetToStrNW((LPWSTR)dest, len, src, pidl);
 113     else
 114         return StrRetToStrNA((LPSTR)dest, len, src, pidl);
 115 }
 116
 117 /************************* OLESTR functions ****************************/
 118
 119 /************************************************************************
 120  *    StrToOleStr            [SHELL32.163]
 121  *
 122  */
 123 static int StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
 124 {
 125     TRACE("(%p, %p %s)\n",
 126     lpWideCharStr, lpMultiByteString, debugstr_a(lpMultiByteString));
 127
 128     return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
 129
 130 }
 131 static int StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
 132 {
 133     TRACE("(%p, %p %s)\n",
 134     lpWideCharStr, lpWString, debugstr_w(lpWString));
 135
 136     wcscpy (lpWideCharStr, lpWString );
 137     return wcslen(lpWideCharStr);
 138 }
 139
 140 EXTERN_C BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
 141 {
 142     if (SHELL_OsIsUnicode())
 143       return StrToOleStrW (lpWideCharStr, (LPCWSTR)lpString);
 144     return StrToOleStrA (lpWideCharStr, (LPCSTR)lpString);
 145 }
 146
 147 /*************************************************************************
 148  * StrToOleStrN                    [SHELL32.79]
 149  *  lpMulti, nMulti, nWide [IN]
 150  *  lpWide [OUT]
 151  */
 152 static BOOL StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
 153 {
 154     TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_an(lpStrA,nStr), nStr);
 155     return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
 156 }
 157 static BOOL StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
 158 {
 159     TRACE("(%p, %x, %s, %x)\n", lpWide, nWide, debugstr_wn(lpStrW, nStr), nStr);
 160
 161     if (lstrcpynW (lpWide, lpStrW, nWide))
 162     { return wcslen (lpWide);
 163     }
 164     return 0;
 165 }
 166
 167 EXTERN_C BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
 168 {
 169     if (SHELL_OsIsUnicode())
 170       return StrToOleStrNW (lpWide, nWide, (LPCWSTR)lpStr, nStr);
 171     return StrToOleStrNA (lpWide, nWide, (LPCSTR)lpStr, nStr);
 172 }
 173
 174 /*************************************************************************
 175  * OleStrToStrN                    [SHELL32.78]
 176  */
 177 static BOOL OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
 178 {
 179     TRACE("(%p, %x, %s, %x)\n", lpStr, nStr, debugstr_wn(lpOle,nOle), nOle);
 180     return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
 181 }
 182
 183 static BOOL OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
 184 {
 185     TRACE("(%p, %x, %s, %x)\n", lpwStr, nwStr, debugstr_wn(lpOle,nOle), nOle);
 186
 187     if (lstrcpynW ( lpwStr, lpOle, nwStr))
 188     { return wcslen (lpwStr);
 189     }
 190     return 0;
 191 }
 192
 193 EXTERN_C BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
 194 {
 195     if (SHELL_OsIsUnicode())
 196       return OleStrToStrNW ((LPWSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
 197     return OleStrToStrNA ((LPSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
 198 }
 199
 200
 201 /*************************************************************************
 202  * CheckEscapesA             [SHELL32.@]
 203  *
 204  * Checks a string for special characters which are not allowed in a path
 205  * and encloses it in quotes if that is the case.
 206  *
 207  * PARAMS
 208  *  string     [I/O] string to check and on return eventually quoted
 209  *  len        [I]   length of string
 210  *
 211  * RETURNS
 212  *  length of actual string
 213  *
 214  * NOTES
 215  *  Not really sure if this function returns actually a value at all.
 216  */
 217 DWORD WINAPI CheckEscapesA(
 218     LPSTR    string,         /* [I/O]   string to check ??*/
 219     DWORD    len)            /* [I]      is 0 */
 220 {
 221     LPWSTR wString;
 222     DWORD ret = 0;
 223
 224     TRACE("(%s %d)\n", debugstr_a(string), len);
 225     wString = (LPWSTR)LocalAlloc(LPTR, len * sizeof(WCHAR));
 226     if (wString)
 227     {
 228       MultiByteToWideChar(CP_ACP, 0, string, len, wString, len);
 229       ret = CheckEscapesW(wString, len);
 230       WideCharToMultiByte(CP_ACP, 0, wString, len, string, len, NULL, NULL);
 231       LocalFree(wString);
 232     }
 233     return ret;
 234 }
 235
 236 static const WCHAR strEscapedChars[] = {' ','"',',',';','^',0};
 237
 238 /*************************************************************************
 239  * CheckEscapesW             [SHELL32.@]
 240  *
 241  * See CheckEscapesA.
 242  */
 243 DWORD WINAPI CheckEscapesW(
 244     LPWSTR    string,
 245     DWORD    len)
 246 {
 247     DWORD size = wcslen(string);
 248     LPWSTR s, d;
 249
 250     TRACE("(%s %d) stub\n", debugstr_w(string), len);
 251
 252     if (StrPBrkW(string, strEscapedChars) && size + 2 <= len)
 253     {
 254       s = &string[size - 1];
 255       d = &string[size + 2];
 256       *d-- = 0;
 257       *d-- = '"';
 258       for (;d > string;)
 259         *d-- = *s--;
 260       *d = '"';
 261       return size + 2;
 262     }
 263     return size;
 264 }