controls/comctl32undoc.c

   1 /*
   2  * Undocumented functions from COMCTL32.DLL
   3  *
   4  * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
   5  *
   6  * NOTES
   7  *     All of these functions are UNDOCUMENTED!! And I mean UNDOCUMENTED!!!!
   8  *     Do NOT rely on names or contents of undocumented structures and types!!!
   9  *     These functions are used by EXPLORER.EXE, IEXPLORE.EXE and
  10  *     COMCTL32.DLL (internally).
  11  *
  12  * TODO
  13  *     - Fix DSA_InsertItem.
  14  *     - Fix DSA_GetItem.
  15  *     - Write documentation.
  16  */
  17
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <ctype.h>
  21 #include "windows.h"
  22 #include "heap.h"
  23 #include "debug.h"
  24
  25
  26 typedef struct _DSA_DATA
  27 {
  28     DWORD   dwEntryCount;
  29     DWORD   dwMaxCount;
  30     DWORD   dwInitial;
  31     DWORD   dwGrow;
  32     LPSTR   *ptrs;
  33 } DSA_DATA, *LPDSA_DATA;
  34
  35
  36 typedef struct _DPA_DATA
  37 {
  38     DWORD   dwEntryCount;
  39     DWORD   dwMaxCount;
  40     DWORD   dwGrow;
  41     LPDWORD ptrs;
  42 } DPA_DATA, *LPDPA_DATA;
  43
  44
  45 DWORD WINAPI DSA_Create (DWORD, DWORD);
  46
  47
  48 DWORD WINAPI DPA_Create (DWORD);
  49 DWORD WINAPI DPA_GetPtr (DWORD, DWORD);
  50 DWORD WINAPI DPA_InsertPtr (DWORD, DWORD, DWORD);
  51
  52
  53
  54
  55 /**************************************************************************
  56  * Alloc [COMCTL32.71]
  57  *
  58  */
  59
  60 LPVOID WINAPI
  61 COMCTL32_Alloc (DWORD dwParam)
  62 {
  63     LPVOID lpPtr;
  64
  65     lpPtr = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, dwParam);
  66
  67     TRACE (commctrl, "(0x%08lx) ret=0x%08lx\n", dwParam, (DWORD)lpPtr);
  68
  69     return lpPtr;
  70 }
  71
  72
  73 /**************************************************************************
  74  * ReAlloc [COMCTL32.72]
  75  *
  76  */
  77
  78 LPVOID WINAPI
  79 COMCTL32_ReAlloc (LPVOID dwParam1, DWORD dwParam2)
  80 {
  81     LPVOID dwPtr;
  82
  83     if (dwParam1 == 0)
  84         dwPtr = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
  85                            dwParam2);
  86     else
  87         dwPtr = HeapReAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
  88                              dwParam1, dwParam2);
  89
  90     TRACE (commctrl, "(0x%08lx 0x%08lx) ret=0x%08lx\n",
  91            (DWORD)dwParam1, dwParam2, (DWORD)dwPtr);
  92
  93     return dwPtr;
  94 }
  95
  96
  97 /**************************************************************************
  98  * Free [COMCTL32.73]
  99  *
 100  */
 101
 102 DWORD WINAPI
 103 COMCTL32_Free (LPVOID dwParam)
 104 {
 105     TRACE (commctrl, "(0x%08lx)\n", (DWORD)dwParam);
 106     HeapFree (GetProcessHeap (), 0, dwParam);
 107
 108     return 0;
 109 }
 110
 111
 112 /**************************************************************************
 113  * GetSize [COMCTL32.74]
 114  *
 115  */
 116
 117 DWORD WINAPI
 118 COMCTL32_GetSize (LPVOID dwParam)
 119 {
 120     TRACE (commctrl, "(0x%08lx)\n", (DWORD)dwParam);
 121     return (HeapSize (GetProcessHeap (), 0, dwParam));
 122 }
 123
 124
 125
 126 /**************************************************************************
 127  * Str_SetPtrA [COMCTL32.234]
 128  *
 129  * PARAMS
 130  *     dwParam1 [I]
 131  *     dwParam2 [I]
 132  */
 133
 134 BOOL32 WINAPI
 135 COMCTL32_Str_SetPtrA (LPSTR lpStr, LPVOID *lpPtr)
 136 {
 137     INT32 len;
 138     LPSTR ptr;
 139
 140     FIXME (commctrl, "(0x%08lx 0x%08lx)\n", (DWORD)lpStr, (DWORD)lpPtr);
 141     FIXME (commctrl, "(\"%s\" \"%s\")\n", lpStr, (LPSTR)*lpPtr);
 142
 143     if (lpStr) {
 144         len = lstrlen32A (lpStr);
 145         ptr = COMCTL32_ReAlloc (lpPtr, len + 1);
 146         if (!(ptr))
 147             return FALSE;
 148         lstrcpy32A (ptr, lpStr);
 149         *lpPtr = ptr;
 150         return TRUE;
 151     }
 152
 153     if (*lpPtr) {
 154         COMCTL32_Free (*lpPtr);
 155         return TRUE;
 156     }
 157
 158     return FALSE;
 159 }
 160
 161
 162
 163 /**************************************************************************
 164  * DSA_Create [COMCTL32.320] Creates a dynamic string array
 165  *
 166  * PARAMS
 167  *     dwParam1 [I]
 168  *     dwParam2 [I]
 169  */
 170
 171 DWORD WINAPI
 172 DSA_Create (DWORD dwParam1, DWORD dwParam2)
 173 {
 174     LPDSA_DATA dsaPtr;
 175
 176     dsaPtr = (LPDSA_DATA)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 177                                     sizeof(DSA_DATA));
 178     dsaPtr->dwInitial = dwParam1;
 179     dsaPtr->dwGrow = dwParam2;
 180
 181     TRACE (commctrl, "(0x%08lx 0x%08lx) ret=0x%08lx\n",
 182            dwParam1, dwParam2, (DWORD)dsaPtr);
 183
 184     return (DWORD)dsaPtr;
 185 }
 186
 187
 188 /**************************************************************************
 189  * DSA_Destroy [COMCTL32.321] Destroys a dynamic string array
 190  *
 191  * PARAMS
 192  *     dwParam1 [I]
 193  */
 194
 195 DWORD WINAPI
 196 DSA_Destroy (DWORD dwParam1)
 197 {
 198     LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
 199     DWORD i;
 200
 201     TRACE (commctrl, "(0x%08lx):semi-stub!\n", dwParam1);
 202
 203     if (dsaPtr->ptrs) {
 204         for (i = 0; i < dsaPtr->dwEntryCount; i++) {
 205             if (dsaPtr->ptrs[i])
 206                 HeapFree (GetProcessHeap (), 0, (LPSTR)dsaPtr->ptrs[i]);
 207         }
 208     }
 209
 210     HeapFree (GetProcessHeap (), 0, dsaPtr);
 211
 212     return 0;
 213 }
 214
 215
 216 DWORD WINAPI
 217 DSA_GetItem (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
 218 {
 219     LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
 220
 221     FIXME (commctrl, "(0x%08lx 0x%08lx 0x%08lx): stub!\n",
 222            dwParam1, dwParam2, dwParam3);
 223
 224     if (dsaPtr == NULL)
 225         return 0;
 226     if (dsaPtr->ptrs == NULL)
 227         return 0;
 228     if ((dwParam2 < 0) || (dwParam2 >= dsaPtr->dwEntryCount))
 229         return 0;
 230
 231 //    FIXME (commctrl, "\"%s\"\n", (LPSTR)dsaPtr->ptrs[dwParam2]);
 232
 233     return (DWORD)lstrcpy32A ((LPSTR)dwParam3, (LPSTR)dsaPtr->ptrs[dwParam2]);
 234 }
 235
 236
 237 DWORD WINAPI
 238 DSA_GetItemPtr (DWORD dwParam1, DWORD dwParam2)
 239 {
 240     LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
 241
 242     TRACE (commctrl, "(0x%08lx 0x%08lx)\n", dwParam1, dwParam2);
 243
 244     if (dsaPtr == NULL)
 245         return 0;
 246     if (dsaPtr->ptrs == NULL)
 247         return 0;
 248     if ((dwParam2 < 0) || (dwParam2 >= dsaPtr->dwEntryCount))
 249         return 0;
 250
 251     TRACE (commctrl, "ret=0x%08lx\n", (DWORD)dsaPtr->ptrs[dwParam2]);
 252
 253     return (DWORD)dsaPtr->ptrs[dwParam2];
 254 }
 255
 256
 257 DWORD WINAPI
 258 DSA_InsertItem (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
 259 {
 260     LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
 261     DWORD dwIndex;
 262     INT32 len;
 263
 264     TRACE (commctrl, "(0x%08lx 0x%08lx \"%s\"):semi-stub!\n",
 265            dwParam1, dwParam2, (LPSTR)dwParam3);
 266
 267     if (dsaPtr->ptrs == NULL) {
 268         dsaPtr->ptrs = (LPSTR*)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 269                                           dsaPtr->dwInitial * sizeof(LPVOID));
 270         dsaPtr->dwMaxCount = dsaPtr->dwInitial;
 271         dwIndex = 0;
 272         len = lstrlen32A ((LPSTR)dwParam3);
 273         dsaPtr->ptrs[dwIndex] =
 274             (LPSTR)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len+1);
 275         lstrcpy32A (dsaPtr->ptrs[dwIndex], (LPSTR)dwParam3);
 276     }
 277     else {
 278         TRACE (commctrl, "(0x%08lx 0x%08lx)\n",
 279                dsaPtr->dwEntryCount, dsaPtr->dwMaxCount);
 280         if (dwParam2 >= dsaPtr->dwEntryCount) {
 281             if (dsaPtr->dwEntryCount < dsaPtr->dwMaxCount) {
 282                 dwIndex = dsaPtr->dwEntryCount;
 283                 len = lstrlen32A ((LPSTR)dwParam3);
 284                 dsaPtr->ptrs[dwIndex] =
 285                     (LPSTR)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len+1);
 286                 lstrcpy32A (dsaPtr->ptrs[dwIndex], (LPSTR)dwParam3);
 287             }
 288             else {
 289                 /* allocate new pointer list and copy all pointers */
 290                 LPSTR *lpOldPtrs = dsaPtr->ptrs;
 291                 dsaPtr->ptrs = (LPSTR*)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY,
 292                                 (dsaPtr->dwInitial + dsaPtr->dwGrow) *
 293                                 sizeof(LPVOID));
 294                 memcpy (dsaPtr->ptrs, lpOldPtrs,
 295                         dsaPtr->dwMaxCount * sizeof(LPVOID));
 296                 dsaPtr->dwMaxCount += dsaPtr->dwGrow;
 297                 HeapFree (GetProcessHeap (), 0, lpOldPtrs);
 298
 299                 /* add new string */
 300                 dwIndex = dsaPtr->dwEntryCount;
 301                 len = lstrlen32A ((LPSTR)dwParam3);
 302                 dsaPtr->ptrs[dwIndex] =
 303                     (LPSTR)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len+1);
 304                 lstrcpy32A (dsaPtr->ptrs[dwIndex], (LPSTR)dwParam3);
 305             }
 306         }
 307         else {
 308             FIXME (commctrl, "inserting! stub!\n");
 309
 310             dwIndex = dwParam2;
 311         }
 312     }
 313
 314     dsaPtr->dwEntryCount++;
 315
 316     TRACE (commctrl, "ret=0x%08lx\n", dwIndex);
 317
 318     return (dwIndex);
 319 }
 320
 321
 322
 323
 324 DWORD WINAPI
 325 DSA_DeleteItem (DWORD dwParam1, DWORD dwParam2)
 326 {
 327     LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
 328
 329     TRACE (commctrl, "(0x%08lx 0x%08lx):semi-stub!\n",
 330            dwParam1, dwParam2);
 331
 332     if (dsaPtr->ptrs) {
 333         if (dsaPtr->dwEntryCount == 1) {
 334             if (dsaPtr->ptrs[dwParam2])
 335                 HeapFree (GetProcessHeap (), 0, dsaPtr->ptrs[dwParam2]);
 336             dsaPtr->dwEntryCount--;
 337         }
 338         else {
 339             LPSTR *oldPtrs = dsaPtr->ptrs;
 340             TRACE (commctrl, "complex delete!\n");
 341
 342             if (dsaPtr->ptrs[dwParam2])
 343                 HeapFree (GetProcessHeap (), 0, dsaPtr->ptrs[dwParam2]);
 344
 345             dsaPtr->dwEntryCount--;
 346             dsaPtr->ptrs =
 347                 (LPSTR*)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 348                                    dsaPtr->dwEntryCount * sizeof(LPVOID));
 349             if (dwParam2 > 0) {
 350                 memcpy (&dsaPtr->ptrs[0], &oldPtrs[0],
 351                         dwParam2 * sizeof(LPSTR));
 352             }
 353
 354             if (dwParam2 < dsaPtr->dwEntryCount) {
 355                 memcpy (&dsaPtr->ptrs[dwParam2], &oldPtrs[dwParam2+1],
 356                         (dsaPtr->dwEntryCount - dwParam2) * sizeof(LPSTR));
 357             }
 358             HeapFree (GetProcessHeap (), 0, oldPtrs);
 359         }
 360
 361         if (dsaPtr->dwEntryCount == 0) {
 362             HeapFree (GetProcessHeap (), 0, dsaPtr->ptrs);
 363             dsaPtr->ptrs = NULL;
 364         }
 365     }
 366
 367     return 0;
 368 }
 369
 370
 371
 372
 373
 374 DWORD WINAPI
 375 DPA_Create (DWORD dwParam1)
 376 {
 377     LPDPA_DATA dpaPtr;
 378
 379     TRACE (commctrl, "(0x%08lx)\n", dwParam1);
 380
 381     dpaPtr = (LPDPA_DATA)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, sizeof(DPA_DATA));
 382     dpaPtr->dwGrow = dwParam1;
 383
 384     TRACE (commctrl, "ret=0x%08lx\n", (DWORD)dpaPtr);
 385
 386     return (DWORD)dpaPtr;
 387 }
 388
 389
 390
 391 DWORD WINAPI
 392 DPA_GetPtr (DWORD dwParam1, DWORD dwParam2)
 393 {
 394     LPDPA_DATA dpaPtr = (LPDPA_DATA)dwParam1;
 395
 396     TRACE (commctrl, "(0x%08lx 0x%08lx)\n", dwParam1, dwParam2);
 397
 398     if (dpaPtr == NULL)
 399         return 0;
 400     if (dpaPtr->ptrs == NULL)
 401         return 0;
 402     if ((dwParam2 < 0) || (dwParam2 >= dpaPtr->dwEntryCount))
 403         return 0;
 404
 405     TRACE (commctrl, "ret=0x%08lx\n", (DWORD)dpaPtr->ptrs[dwParam2]);
 406
 407     return (DWORD)dpaPtr->ptrs[dwParam2];
 408 }
 409
 410
 411
 412 DWORD WINAPI
 413 DPA_InsertPtr (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
 414 {
 415     LPDPA_DATA dpaPtr = (LPDPA_DATA)dwParam1;
 416     DWORD dwIndex;
 417
 418     TRACE (commctrl, "(0x%08lx 0x%08lx 0x%lx)\n",
 419            dwParam1, dwParam2, dwParam3);
 420
 421     if (dpaPtr->ptrs == NULL) {
 422         dpaPtr->ptrs = (LPDWORD)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY,
 423                                            dpaPtr->dwGrow * sizeof(LPVOID));
 424         dpaPtr->dwMaxCount = dpaPtr->dwGrow;
 425         dwIndex = 0;
 426         dpaPtr->ptrs[dwIndex] = dwParam3;
 427     }
 428     else {
 429         FIXME (commctrl, "adding to existing array! stub!\n");
 430
 431
 432         dwIndex = dwParam2;
 433     }
 434
 435     dpaPtr->dwEntryCount++;
 436
 437     return (dwIndex);
 438 }
 439
 440
 441 /**************************************************************************
 442  * DPA_CreateEx [COMCTL32.340]
 443  *
 444  */
 445
 446 DWORD WINAPI
 447 DPA_CreateEx (DWORD dwParam1, DWORD dwParam2)
 448 {
 449     FIXME (commctrl, "(0x%08lx 0x%08lx)\n",
 450            dwParam1, dwParam2);
 451
 452     return 0;
 453 }
 454
 455
 456 /**************************************************************************
 457  * SendNotify [COMCTL32.341]
 458  *
 459  */
 460
 461 DWORD WINAPI
 462 COMCTL32_SendNotify (DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4)
 463 {
 464     FIXME (commctrl, "(0x%08lx 0x%08lx 0x%08lx 0x%08lx)\n",
 465            dw1, dw2, dw3, dw4);
 466
 467     return 0;
 468 }
 469
 470
 471
 472 /**************************************************************************
 473  * StrChrA [COMCTL32.350]
 474  *
 475  */
 476
 477 LPSTR WINAPI
 478 COMCTL32_StrChrA (LPCSTR lpString, CHAR cChar)
 479 {
 480     return strchr (lpString, cChar);
 481 }
 482
 483
 484 /**************************************************************************
 485  * StrStrIA [COMCTL32.355]
 486  */
 487
 488 LPSTR WINAPI
 489 COMCTL32_StrStrIA (LPCSTR lpStr1, LPCSTR lpStr2)
 490 {
 491     INT32 len1, len2, i;
 492     CHAR  first;
 493
 494     if (*lpStr2 == 0)
 495         return ((LPSTR)lpStr1);
 496     len1 = 0;
 497     while (lpStr1[len1] != 0) ++len1;
 498     len2 = 0;
 499     while (lpStr2[len2] != 0) ++len2;
 500     if (len2 == 0)
 501         return ((LPSTR)(lpStr1 + len1));
 502     first = tolower (*lpStr2);
 503     while (len1 >= len2) {
 504         if (tolower(*lpStr1) == first) {
 505             for (i = 1; i < len2; ++i)
 506                 if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
 507                     break;
 508             if (i >= len2)
 509                 return ((LPSTR)lpStr1);
 510         }
 511         ++lpStr1; --len1;
 512     }
 513     return (NULL);
 514 }
 515
 516
 517 /**************************************************************************
 518  * StrToIntA [COMCTL32.357] Converts a string to a signed integer.
 519  */
 520
 521 INT32 WINAPI
 522 COMCTL32_StrToIntA (LPSTR lpString)
 523 {
 524     return atoi(lpString);
 525 }
 526