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     /* NULL is a valid parameter */
 234     if(!in) return;
 235
 236     /*
 237      * We have to be careful when we free a BSTR pointer, it points to
 238      * the beginning of the string but it skips the byte count contained
 239      * before the string.
 240      */
 241     bufferPointer = (DWORD*)in;
 242
 243     bufferPointer--;
 244
 245     /*
 246      * Free the memory from it's "real" origin.
 247      */
 248     HeapFree(GetProcessHeap(), 0, bufferPointer);
 249 }
 250
 251 /******************************************************************************
 252  *              SysStringLen16  [OLE2DISP.7]
 253  */
 254 int WINAPI SysStringLen16(BSTR16 str)
 255 {
 256         return strlen(BSTR_GetAddr(str));
 257 }
 258
 259 /******************************************************************************
 260  *             SysStringLen32  [OLEAUT32.7]
 261  *
 262  * The Windows documentation states that the length returned by this function
 263  * is not necessarely the same as the length returned by the _lstrlenW method.
 264  * It is the same number that was passed in as the "len" parameter if the
 265  * string was allocated with a SysAllocStringLen method call.
 266  */
 267 int WINAPI SysStringLen(BSTR str)
 268 {
 269     DWORD* bufferPointer;
 270
 271     /*
 272      * The length of the string (in bytes) is contained in a DWORD placed
 273      * just before the BSTR pointer
 274      */
 275     bufferPointer = (DWORD*)str;
 276
 277     bufferPointer--;
 278
 279     return (int)(*bufferPointer/sizeof(WCHAR));
 280 }
 281
 282 /******************************************************************************
 283  *             SysStringByteLen  [OLEAUT32.149]
 284  *
 285  * The Windows documentation states that the length returned by this function
 286  * is not necessarely the same as the length returned by the _lstrlenW method.
 287  * It is the same number that was passed in as the "len" parameter if the
 288  * string was allocated with a SysAllocStringLen method call.
 289  */
 290 int WINAPI SysStringByteLen(BSTR str)
 291 {
 292   return SysStringLen(str)*sizeof(WCHAR);
 293 }
 294
 295 /******************************************************************************
 296  * CreateDispTypeInfo [OLE2DISP.31]
 297  */
 298 HRESULT WINAPI CreateDispTypeInfo16(
 299         INTERFACEDATA *pidata,
 300         LCID lcid,
 301         ITypeInfo **pptinfo
 302 ) {
 303         FIXME(ole,"(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
 304         return 0;
 305 }
 306
 307 /******************************************************************************
 308  * RegisterActiveObject [OLE2DISP.35]
 309  */
 310 HRESULT WINAPI RegisterActiveObject16(
 311         IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
 312 ) {
 313         char    buf[80];
 314         WINE_StringFromCLSID(rclsid,buf);
 315         FIXME(ole,"(%p,%s,0x%08lx,%p):stub\n",punk,buf,dwFlags,pdwRegister);
 316         return 0;
 317 }
 318
 319 /******************************************************************************
 320  *              OleTranslateColor       [OLEAUT32.421]
 321  *
 322  * Converts an OLE_COLOR to a COLORREF.
 323  * See the documentation for conversion rules.
 324  * pColorRef can be NULL. In that case the user only wants to test the
 325  * conversion.
 326  */
 327 INT WINAPI OleTranslateColor(
 328   LONG clr,
 329   HPALETTE  hpal,
 330   COLORREF* pColorRef)
 331 {
 332   COLORREF colorref;
 333   BYTE b = HIBYTE(HIWORD(clr));
 334
 335   TRACE(ole,"(%08lx, %d, %p):stub\n", clr, hpal, pColorRef);
 336
 337   /*
 338    * In case pColorRef is NULL, provide our own to simplify the code.
 339    */
 340   if (pColorRef == NULL)
 341     pColorRef = &colorref;
 342
 343   switch (b)
 344   {
 345     case 0x00:
 346     {
 347       if (hpal != 0)
 348         *pColorRef =  PALETTERGB(GetRValue(clr),
 349                                  GetGValue(clr),
 350                                  GetBValue(clr));
 351       else
 352         *pColorRef = clr;
 353
 354       break;
 355     }
 356
 357     case 0x01:
 358     {
 359       if (hpal != 0)
 360       {
 361         PALETTEENTRY pe;
 362         /*
 363          * Validate the palette index.
 364          */
 365         if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
 366           return E_INVALIDARG;
 367       }
 368
 369       *pColorRef = clr;
 370
 371       break;
 372     }
 373
 374     case 0x02:
 375       *pColorRef = clr;
 376       break;
 377
 378     case 0x80:
 379     {
 380       int index = LOBYTE(LOWORD(clr));
 381
 382       /*
 383        * Validate GetSysColor index.
 384        */
 385       if ((index < COLOR_SCROLLBAR) || (index > COLOR_GRADIENTINACTIVECAPTION))
 386         return E_INVALIDARG;
 387
 388       *pColorRef =  GetSysColor(index);
 389
 390       break;
 391     }
 392
 393     default:
 394       return E_INVALIDARG;
 395   }
 396
 397   return S_OK;
 398 }
 399
 400 /******************************************************************************
 401  *             SysAllocStringByteLen     [OLEAUT32.150]
 402  *
 403  */
 404 BSTR WINAPI SysAllocStringByteLen(char *in, int len)
 405 {
 406     DWORD* newBuffer;
 407     char* stringBuffer;
 408
 409     /*
 410      * Allocate a new buffer to hold the string.
 411      * dont't forget to keep an empty spot at the begining of the
 412      * buffer for the character count and an extra character at the
 413      * end for the NULL.
 414      */
 415     newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
 416                                  0,
 417                                  len + sizeof(WCHAR) + sizeof(DWORD));
 418
 419     /*
 420      * If the memory allocation failed, return a null pointer.
 421      */
 422     if (newBuffer==0)
 423       return 0;
 424
 425     /*
 426      * Copy the length of the string in the placeholder.
 427      */
 428     *newBuffer = len;
 429
 430     /*
 431      * Skip the byte count.
 432      */
 433     newBuffer++;
 434
 435     /*
 436      * Copy the information in the buffer.
 437      * Since it is valid to pass a NULL pointer here, we'll initialize the
 438      * buffer to nul if it is the case.
 439      */
 440     if (in != 0)
 441       memcpy(newBuffer, in, len);
 442
 443     /*
 444      * Make sure that there is a nul character at the end of the
 445      * string.
 446      */
 447     stringBuffer = (char *)newBuffer;
 448     stringBuffer[len] = 0;
 449     stringBuffer[len+1] = 0;
 450
 451     return (LPWSTR)stringBuffer;
 452 }
 453
 454