ole/ole2disp.c

   1 /*
   2  *      OLE2DISP library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  */
   6
   7 #include <string.h>
   8 #include "winerror.h"
   9 #include "ole2.h"
  10 #include "oleauto.h"
  11 #include "wine/obj_base.h"
  12 #include "heap.h"
  13 #include "ldt.h"
  14 #include "debug.h"
  15
  16 DEFAULT_DEBUG_CHANNEL(ole)
  17
  18 /* This implementation of the BSTR API is 16-bit only. It
  19    represents BSTR as a 16:16 far pointer, and the strings
  20    as ISO-8859 */
  21
  22 /******************************************************************************
  23  *              BSTR_AllocBytes [Internal]
  24  */
  25 static BSTR16 BSTR_AllocBytes(int n)
  26 {
  27     void *ptr = SEGPTR_ALLOC(n);
  28     return (BSTR16)SEGPTR_GET(ptr);
  29 }
  30
  31 /******************************************************************************
  32  * BSTR_Free [INTERNAL]
  33  */
  34 static void BSTR_Free(BSTR16 in)
  35 {
  36     SEGPTR_FREE( PTR_SEG_TO_LIN(in) );
  37 }
  38
  39 /******************************************************************************
  40  * BSTR_GetAddr [INTERNAL]
  41  */
  42 static void* BSTR_GetAddr(BSTR16 in)
  43 {
  44     return in ? PTR_SEG_TO_LIN(in) : 0;
  45 }
  46
  47 /******************************************************************************
  48  *              SysAllocString16        [OLE2DISP.2]
  49  */
  50 BSTR16 WINAPI SysAllocString16(LPCOLESTR16 in)
  51 {
  52         BSTR16 out=BSTR_AllocBytes(strlen(in)+1);
  53         if(!out)return 0;
  54         strcpy(BSTR_GetAddr(out),in);
  55         return out;
  56 }
  57
  58 /******************************************************************************
  59  *              SysAllocString32        [OLEAUT32.2]
  60  */
  61 BSTR WINAPI SysAllocString(LPCOLESTR in)
  62 {
  63     /* Delegate this to the SysAllocStringLen32 method. */
  64     return SysAllocStringLen(in, lstrlenW(in));
  65 }
  66
  67 /******************************************************************************
  68  *              SysReAllocString16      [OLE2DISP.3]
  69  */
  70 INT16 WINAPI SysReAllocString16(LPBSTR16 old,LPCOLESTR16 in)
  71 {
  72         BSTR16 new=SysAllocString16(in);
  73         BSTR_Free(*old);
  74         *old=new;
  75         return 1;
  76 }
  77
  78 /******************************************************************************
  79  *              SysReAllocString32      [OLEAUT32.3]
  80  */
  81 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR in)
  82 {
  83     /*
  84      * Sanity check
  85      */
  86     if (old==NULL)
  87       return 0;
  88
  89     /*
  90      * Make sure we free the old string.
  91      */
  92     if (*old!=NULL)
  93       SysFreeString(*old);
  94
  95     /*
  96      * Allocate the new string
  97      */
  98     *old = SysAllocString(in);
  99
 100      return 1;
 101 }
 102
 103 /******************************************************************************
 104  *              SysAllocStringLen16     [OLE2DISP.4]
 105  */
 106 BSTR16 WINAPI SysAllocStringLen16(const char *in, int len)
 107 {
 108         BSTR16 out=BSTR_AllocBytes(len+1);
 109         if(!out)return 0;
 110         strcpy(BSTR_GetAddr(out),in);
 111         return out;
 112 }
 113
 114 /******************************************************************************
 115  *             SysAllocStringLen32     [OLEAUT32.4]
 116  *
 117  * In "Inside OLE, second edition" by Kraig Brockshmidt. In the Automation
 118  * section, he describes the DWORD value placed before the BSTR data type.
 119  * he describes it as a "DWORD count of characters". By experimenting with
 120  * a windows application, this count seems to be a DWORD count of bytes in
 121  * the string. Meaning that the count is double the number of wide
 122  * characters in the string.
 123  */
 124 BSTR WINAPI SysAllocStringLen(const OLECHAR *in, unsigned int len)
 125 {
 126     DWORD  bufferSize;
 127     DWORD* newBuffer;
 128     WCHAR* stringBuffer;
 129
 130     /*
 131      * Find the lenth of the buffer passed-in in bytes.
 132      */
 133     bufferSize = len * sizeof (WCHAR);
 134
 135     /*
 136      * Allocate a new buffer to hold the string.
 137      * dont't forget to keep an empty spot at the begining of the
 138      * buffer for the character count and an extra character at the
 139      * end for the NULL.
 140      */
 141     newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
 142                                  0,
 143                                  bufferSize + sizeof(WCHAR) + sizeof(DWORD));
 144
 145     /*
 146      * If the memory allocation failed, return a null pointer.
 147      */
 148     if (newBuffer==0)
 149       return 0;
 150
 151     /*
 152      * Copy the length of the string in the placeholder.
 153      */
 154     *newBuffer = bufferSize;
 155
 156     /*
 157      * Skip the byte count.
 158      */
 159     newBuffer++;
 160
 161     /*
 162      * Copy the information in the buffer.
 163      * Since it is valid to pass a NULL pointer here, we'll initialize the
 164      * buffer to nul if it is the case.
 165      */
 166     if (in != 0)
 167       memcpy(newBuffer, in, bufferSize);
 168     else
 169       memset(newBuffer, 0, bufferSize);
 170
 171     /*
 172      * Make sure that there is a nul character at the end of the
 173      * string.
 174      */
 175     stringBuffer = (WCHAR*)newBuffer;
 176     stringBuffer[len] = L'\0';
 177
 178     return (LPWSTR)stringBuffer;
 179 }
 180
 181 /******************************************************************************
 182  *              SysReAllocStringLen16   [OLE2DISP.5]
 183  */
 184 int WINAPI SysReAllocStringLen16(BSTR16 *old,const char *in,int len)
 185 {
 186         BSTR16 new=SysAllocStringLen16(in,len);
 187         BSTR_Free(*old);
 188         *old=new;
 189         return 1;
 190 }
 191
 192
 193 /******************************************************************************
 194  *             SysReAllocStringLen32   [OLEAUT32.5]
 195  */
 196 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* in, unsigned int len)
 197 {
 198     /*
 199      * Sanity check
 200      */
 201     if (old==NULL)
 202       return 0;
 203
 204     /*
 205      * Make sure we free the old string.
 206      */
 207     if (*old!=NULL)
 208       SysFreeString(*old);
 209
 210     /*
 211      * Allocate the new string
 212      */
 213     *old = SysAllocStringLen(in, len);
 214
 215     return 1;
 216 }
 217
 218 /******************************************************************************
 219  *              SysFreeString16 [OLE2DISP.6]
 220  */
 221 void WINAPI SysFreeString16(BSTR16 in)
 222 {
 223         BSTR_Free(in);
 224 }
 225
 226 /******************************************************************************
 227  *              SysFreeString32 [OLEAUT32.6]
 228  */
 229 void WINAPI SysFreeString(BSTR in)
 230 {
 231     DWORD* bufferPointer;
 232
 233     /*
 234      * We have to be careful when we free a BSTR pointer, it points to
 235      * the beginning of the string but it skips the byte count contained
 236      * before the string.
 237      */
 238     bufferPointer = (DWORD*)in;
 239
 240     bufferPointer--;
 241
 242     /*
 243      * Free the memory from it's "real" origin.
 244      */
 245     HeapFree(GetProcessHeap(), 0, bufferPointer);
 246 }
 247
 248 /******************************************************************************
 249  *              SysStringLen16  [OLE2DISP.7]
 250  */
 251 int WINAPI SysStringLen16(BSTR16 str)
 252 {
 253         return strlen(BSTR_GetAddr(str));
 254 }
 255
 256 /******************************************************************************
 257  *             SysStringLen32  [OLEAUT32.7]
 258  *
 259  * The Windows documentation states that the length returned by this function
 260  * is not necessarely the same as the length returned by the _lstrlenW method.
 261  * It is the same number that was passed in as the "len" parameter if the
 262  * string was allocated with a SysAllocStringLen method call.
 263  */
 264 int WINAPI SysStringLen(BSTR str)
 265 {
 266     DWORD* bufferPointer;
 267
 268     /*
 269      * The length of the string (in bytes) is contained in a DWORD placed
 270      * just before the BSTR pointer
 271      */
 272     bufferPointer = (DWORD*)str;
 273
 274     bufferPointer--;
 275
 276     return (int)(*bufferPointer/sizeof(WCHAR));
 277 }
 278
 279 /******************************************************************************
 280  *             SysStringByteLen  [OLEAUT32.149]
 281  *
 282  * The Windows documentation states that the length returned by this function
 283  * is not necessarely the same as the length returned by the _lstrlenW method.
 284  * It is the same number that was passed in as the "len" parameter if the
 285  * string was allocated with a SysAllocStringLen method call.
 286  */
 287 int WINAPI SysStringByteLen(BSTR str)
 288 {
 289   return SysStringLen(str)*sizeof(WCHAR);
 290 }
 291
 292 /******************************************************************************
 293  * CreateDispTypeInfo [OLE2DISP.31]
 294  */
 295 HRESULT WINAPI CreateDispTypeInfo16(
 296         INTERFACEDATA *pidata,
 297         LCID lcid,
 298         ITypeInfo **pptinfo
 299 ) {
 300         FIXME(ole,"(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
 301         return 0;
 302 }
 303
 304 /******************************************************************************
 305  * RegisterActiveObject [OLE2DISP.35]
 306  */
 307 HRESULT WINAPI RegisterActiveObject16(
 308         IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
 309 ) {
 310         char    buf[80];
 311         WINE_StringFromCLSID(rclsid,buf);
 312         FIXME(ole,"(%p,%s,0x%08lx,%p):stub\n",punk,buf,dwFlags,pdwRegister);
 313         return 0;
 314 }
 315
 316 /******************************************************************************
 317  *              OleTranslateColor       [OLEAUT32.421]
 318  *
 319  * Converts an OLE_COLOR to a COLORREF.
 320  * See the documentation for conversion rules.
 321  * pColorRef can be NULL. In that case the user only wants to test the
 322  * conversion.
 323  */
 324 INT WINAPI OleTranslateColor(
 325   LONG clr,
 326   HPALETTE  hpal,
 327   COLORREF* pColorRef)
 328 {
 329   COLORREF colorref;
 330   BYTE b = HIBYTE(HIWORD(clr));
 331
 332   TRACE(ole,"(%08lx, %d, %p):stub\n", clr, hpal, pColorRef);
 333
 334   /*
 335    * In case pColorRef is NULL, provide our own to simplify the code.
 336    */
 337   if (pColorRef == NULL)
 338     pColorRef = &colorref;
 339
 340   switch (b)
 341   {
 342     case 0x00:
 343     {
 344       if (hpal != 0)
 345         *pColorRef =  PALETTERGB(GetRValue(clr),
 346                                  GetGValue(clr),
 347                                  GetBValue(clr));
 348       else
 349         *pColorRef = clr;
 350
 351       break;
 352     }
 353
 354     case 0x01:
 355     {
 356       if (hpal != 0)
 357       {
 358         PALETTEENTRY pe;
 359         /*
 360          * Validate the palette index.
 361          */
 362         if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
 363           return E_INVALIDARG;
 364       }
 365
 366       *pColorRef = clr;
 367
 368       break;
 369     }
 370
 371     case 0x02:
 372       *pColorRef = clr;
 373       break;
 374
 375     case 0x80:
 376     {
 377       int index = LOBYTE(LOWORD(clr));
 378
 379       /*
 380        * Validate GetSysColor index.
 381        */
 382       if ((index < COLOR_SCROLLBAR) || (index > COLOR_GRADIENTINACTIVECAPTION))
 383         return E_INVALIDARG;
 384
 385       *pColorRef =  GetSysColor(index);
 386
 387       break;
 388     }
 389
 390     default:
 391       return E_INVALIDARG;
 392   }
 393
 394   return S_OK;
 395 }
 396
 397 /******************************************************************************
 398  *             SysAllocStringByteLen     [OLEAUT32.150]
 399  *
 400  */
 401 BSTR WINAPI SysAllocStringByteLen(char *in, int len)
 402 {
 403     DWORD* newBuffer;
 404     char* stringBuffer;
 405
 406     /*
 407      * Allocate a new buffer to hold the string.
 408      * dont't forget to keep an empty spot at the begining of the
 409      * buffer for the character count and an extra character at the
 410      * end for the NULL.
 411      */
 412     newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
 413                                  0,
 414                                  len + sizeof(WCHAR) + sizeof(DWORD));
 415
 416     /*
 417      * If the memory allocation failed, return a null pointer.
 418      */
 419     if (newBuffer==0)
 420       return 0;
 421
 422     /*
 423      * Copy the length of the string in the placeholder.
 424      */
 425     *newBuffer = len;
 426
 427     /*
 428      * Skip the byte count.
 429      */
 430     newBuffer++;
 431
 432     /*
 433      * Copy the information in the buffer.
 434      * Since it is valid to pass a NULL pointer here, we'll initialize the
 435      * buffer to nul if it is the case.
 436      */
 437     if (in != 0)
 438       memcpy(newBuffer, in, len);
 439
 440     /*
 441      * Make sure that there is a nul character at the end of the
 442      * string.
 443      */
 444     stringBuffer = (char *)newBuffer;
 445     stringBuffer[len] = 0;
 446     stringBuffer[len+1] = 0;
 447
 448     return (LPWSTR)stringBuffer;
 449 }
 450
 451