dll/win32/comctl32/dsa.c

   1 /*
   2  * Dynamic structure array (DSA) implementation
   3  *
   4  * Copyright 1998 Eric Kohl
   5  *           1998 Juergen Schmied <j.schmied@metronet.de>
   6  *           2000 Eric Kohl for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * NOTES
  23  *     These functions were involuntarily documented by Microsoft in 2002 as
  24  *     the outcome of an anti-trust suit brought by various U.S. governments.
  25  *     As a result the specifications on MSDN are inaccurate, incomplete
  26  *     and misleading. A much more complete (unofficial) documentation is
  27  *     available at:
  28  *
  29  *     http://members.ozemail.com.au/~geoffch/samples/win32/shell/comctl32
  30  */
  31
  32 #include <stdarg.h>
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winuser.h"
  37 #include "commctrl.h"
  38
  39 #include "comctl32.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(dsa);
  43
  44 struct _DSA
  45 {
  46     INT  nItemCount;
  47     LPVOID pData;
  48     INT  nMaxCount;
  49     INT  nItemSize;
  50     INT  nGrow;
  51 };
  52
  53 /**************************************************************************
  54  * DSA_Create [COMCTL32.320]
  55  *
  56  * Creates a dynamic storage array
  57  *
  58  * PARAMS
  59  *     nSize [I] size of the array elements
  60  *     nGrow [I] number of elements by which the array grows when it is filled
  61  *
  62  * RETURNS
  63  *     Success: pointer to an array control structure. Use this like a handle.
  64  *     Failure: NULL
  65  *
  66  * NOTES
  67  *     The DSA_ functions can be used to create and manipulate arrays of
  68  *     fixed-size memory blocks. These arrays can store any kind of data
  69  *     (e.g. strings and icons).
  70  */
  71 HDSA WINAPI DSA_Create (INT nSize, INT nGrow)
  72 {
  73     HDSA hdsa;
  74
  75     TRACE("(size=%d grow=%d)\n", nSize, nGrow);
  76
  77     hdsa = Alloc (sizeof(*hdsa));
  78     if (hdsa)
  79     {
  80         hdsa->nItemCount = 0;
  81         hdsa->pData = NULL;
  82         hdsa->nMaxCount = 0;
  83         hdsa->nItemSize = nSize;
  84         hdsa->nGrow = max(1, nGrow);
  85     }
  86
  87     return hdsa;
  88 }
  89
  90
  91 /**************************************************************************
  92  * DSA_Destroy [COMCTL32.321]
  93  *
  94  * Destroys a dynamic storage array
  95  *
  96  * PARAMS
  97  *     hdsa [I] pointer to the array control structure
  98  *
  99  * RETURNS
 100  *     Success: TRUE
 101  *     Failure: FALSE
 102  */
 103 BOOL WINAPI DSA_Destroy (const HDSA hdsa)
 104 {
 105     TRACE("(%p)\n", hdsa);
 106
 107     if (!hdsa)
 108         return FALSE;
 109
 110     if (hdsa->pData && (!Free (hdsa->pData)))
 111         return FALSE;
 112
 113     return Free (hdsa);
 114 }
 115
 116
 117 /**************************************************************************
 118  * DSA_GetItem [COMCTL32.322]
 119  *
 120  * Copies the specified item into a caller-supplied buffer.
 121  *
 122  * PARAMS
 123  *     hdsa   [I] pointer to the array control structure
 124  *     nIndex [I] number of the Item to get
 125  *     pDest  [O] destination buffer. Has to be >= dwElementSize.
 126  *
 127  * RETURNS
 128  *     Success: TRUE
 129  *     Failure: FALSE
 130  */
 131 BOOL WINAPI DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
 132 {
 133     LPVOID pSrc;
 134
 135     TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
 136
 137     if (!hdsa)
 138         return FALSE;
 139     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
 140         return FALSE;
 141
 142     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
 143     memmove (pDest, pSrc, hdsa->nItemSize);
 144
 145     return TRUE;
 146 }
 147
 148
 149 /**************************************************************************
 150  * DSA_GetItemPtr [COMCTL32.323]
 151  *
 152  * Retrieves a pointer to the specified item.
 153  *
 154  * PARAMS
 155  *     hdsa   [I] pointer to the array control structure
 156  *     nIndex [I] index of the desired item
 157  *
 158  * RETURNS
 159  *     Success: pointer to an item
 160  *     Failure: NULL
 161  */
 162 LPVOID WINAPI DSA_GetItemPtr (const HDSA hdsa, INT nIndex)
 163 {
 164     LPVOID pSrc;
 165
 166     TRACE("(%p %d)\n", hdsa, nIndex);
 167
 168     if (!hdsa)
 169         return NULL;
 170     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
 171         return NULL;
 172
 173     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
 174
 175     TRACE("-- ret=%p\n", pSrc);
 176
 177     return pSrc;
 178 }
 179
 180
 181 /**************************************************************************
 182  * DSA_SetItem [COMCTL32.325]
 183  *
 184  * Sets the contents of an item in the array.
 185  *
 186  * PARAMS
 187  *     hdsa   [I] pointer to the array control structure
 188  *     nIndex [I] index for the item
 189  *     pSrc   [I] pointer to the new item data
 190  *
 191  * RETURNS
 192  *     Success: TRUE
 193  *     Failure: FALSE
 194  */
 195 BOOL WINAPI DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
 196 {
 197     INT  nSize, nNewItems;
 198     LPVOID pDest, lpTemp;
 199
 200     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
 201
 202     if ((!hdsa) || nIndex < 0)
 203         return FALSE;
 204
 205     if (hdsa->nItemCount <= nIndex) {
 206         /* within the old array */
 207         if (hdsa->nMaxCount > nIndex) {
 208             /* within the allocated space, set a new boundary */
 209             hdsa->nItemCount = nIndex + 1;
 210         }
 211         else {
 212             /* resize the block of memory */
 213             nNewItems =
 214                 hdsa->nGrow * ((((nIndex + 1) - 1) / hdsa->nGrow) + 1);
 215             nSize = hdsa->nItemSize * nNewItems;
 216
 217             lpTemp = ReAlloc (hdsa->pData, nSize);
 218             if (!lpTemp)
 219                 return FALSE;
 220
 221             hdsa->nMaxCount = nNewItems;
 222             hdsa->nItemCount = nIndex + 1;
 223             hdsa->pData = lpTemp;
 224         }
 225     }
 226
 227     /* put the new entry in */
 228     pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
 229     TRACE("-- move dest=%p src=%p size=%d\n",
 230            pDest, pSrc, hdsa->nItemSize);
 231     memmove (pDest, pSrc, hdsa->nItemSize);
 232
 233     return TRUE;
 234 }
 235
 236
 237 /**************************************************************************
 238  * DSA_InsertItem [COMCTL32.324]
 239  *
 240  * Inserts an item into the array at the specified index.
 241  *
 242  * PARAMS
 243  *     hdsa   [I] pointer to the array control structure
 244  *     nIndex [I] index for the new item
 245  *     pSrc   [I] pointer to the element
 246  *
 247  * RETURNS
 248  *     Success: position of the new item
 249  *     Failure: -1
 250  */
 251 INT WINAPI DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
 252 {
 253     INT   nNewItems, nSize;
 254     LPVOID  lpTemp, lpDest;
 255
 256     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
 257
 258     if ((!hdsa) || nIndex < 0)
 259         return -1;
 260
 261     /* when nIndex >= nItemCount then append */
 262     if (nIndex >= hdsa->nItemCount)
 263          nIndex = hdsa->nItemCount;
 264
 265     /* do we need to resize ? */
 266     if (hdsa->nItemCount >= hdsa->nMaxCount) {
 267         nNewItems = hdsa->nMaxCount + hdsa->nGrow;
 268         nSize = hdsa->nItemSize * nNewItems;
 269
 270         lpTemp = ReAlloc (hdsa->pData, nSize);
 271         if (!lpTemp)
 272             return -1;
 273
 274         hdsa->nMaxCount = nNewItems;
 275         hdsa->pData = lpTemp;
 276     }
 277
 278     /* do we need to move elements ? */
 279     if (nIndex < hdsa->nItemCount) {
 280         lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
 281         lpDest = (char *) lpTemp + hdsa->nItemSize;
 282         nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
 283         TRACE("-- move dest=%p src=%p size=%d\n",
 284                lpDest, lpTemp, nSize);
 285         memmove (lpDest, lpTemp, nSize);
 286     }
 287
 288     /* ok, we can put the new Item in */
 289     hdsa->nItemCount++;
 290     lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
 291     TRACE("-- move dest=%p src=%p size=%d\n",
 292            lpDest, pSrc, hdsa->nItemSize);
 293     memmove (lpDest, pSrc, hdsa->nItemSize);
 294
 295     return nIndex;
 296 }
 297
 298
 299 /**************************************************************************
 300  * DSA_DeleteItem [COMCTL32.326]
 301  *
 302  * Deletes the specified item from the array.
 303  *
 304  * PARAMS
 305  *     hdsa   [I] pointer to the array control structure
 306  *     nIndex [I] index for the element to delete
 307  *
 308  * RETURNS
 309  *     Success: number of the deleted element
 310  *     Failure: -1
 311  */
 312 INT WINAPI DSA_DeleteItem (const HDSA hdsa, INT nIndex)
 313 {
 314     LPVOID lpDest,lpSrc;
 315     INT  nSize;
 316
 317     TRACE("(%p %d)\n", hdsa, nIndex);
 318
 319     if (!hdsa)
 320         return -1;
 321     if (nIndex < 0 || nIndex >= hdsa->nItemCount)
 322         return -1;
 323
 324     /* do we need to move ? */
 325     if (nIndex < hdsa->nItemCount - 1) {
 326         lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
 327         lpSrc = (char *) lpDest + hdsa->nItemSize;
 328         nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
 329         TRACE("-- move dest=%p src=%p size=%d\n",
 330                lpDest, lpSrc, nSize);
 331         memmove (lpDest, lpSrc, nSize);
 332     }
 333
 334     hdsa->nItemCount--;
 335
 336     /* free memory ? */
 337     if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
 338         nSize = hdsa->nItemSize * hdsa->nItemCount;
 339
 340         lpDest = ReAlloc (hdsa->pData, nSize);
 341         if (!lpDest)
 342             return -1;
 343
 344         hdsa->nMaxCount = hdsa->nItemCount;
 345         hdsa->pData = lpDest;
 346     }
 347
 348     return nIndex;
 349 }
 350
 351
 352 /**************************************************************************
 353  * DSA_DeleteAllItems [COMCTL32.327]
 354  *
 355  * Removes all items and reinitializes the array.
 356  *
 357  * PARAMS
 358  *     hdsa [I] pointer to the array control structure
 359  *
 360  * RETURNS
 361  *     Success: TRUE
 362  *     Failure: FALSE
 363  */
 364 BOOL WINAPI DSA_DeleteAllItems (const HDSA hdsa)
 365 {
 366     TRACE("(%p)\n", hdsa);
 367
 368     if (!hdsa)
 369         return FALSE;
 370     if (hdsa->pData && (!Free (hdsa->pData)))
 371         return FALSE;
 372
 373     hdsa->nItemCount = 0;
 374     hdsa->pData = NULL;
 375     hdsa->nMaxCount = 0;
 376
 377     return TRUE;
 378 }
 379
 380
 381 /**************************************************************************
 382  * DSA_EnumCallback [COMCTL32.387]
 383  *
 384  * Enumerates all items in a dynamic storage array.
 385  *
 386  * PARAMS
 387  *     hdsa     [I] handle to the dynamic storage array
 388  *     enumProc [I]
 389  *     lParam   [I]
 390  *
 391  * RETURNS
 392  *     none
 393  */
 394 VOID WINAPI DSA_EnumCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
 395                               LPVOID lParam)
 396 {
 397     INT i;
 398
 399     TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
 400
 401     if (!hdsa)
 402         return;
 403     if (hdsa->nItemCount <= 0)
 404         return;
 405
 406     for (i = 0; i < hdsa->nItemCount; i++) {
 407         LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
 408         if ((enumProc)(lpItem, lParam) == 0)
 409             return;
 410     }
 411
 412     return;
 413 }
 414
 415
 416 /**************************************************************************
 417  * DSA_DestroyCallback [COMCTL32.388]
 418  *
 419  * Enumerates all items in a dynamic storage array and destroys it.
 420  *
 421  * PARAMS
 422  *     hdsa     [I] handle to the dynamic storage array
 423  *     enumProc [I]
 424  *     lParam   [I]
 425  *
 426  * RETURNS
 427  *     none
 428  */
 429 void WINAPI DSA_DestroyCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
 430                                  LPVOID lParam)
 431 {
 432     TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
 433
 434     DSA_EnumCallback (hdsa, enumProc, lParam);
 435     DSA_Destroy (hdsa);
 436 }