Changeset 44 for trunk/src/comctl32

Timestamp:

Jun 7, 1999, 5:37:34 PM (26 years ago)

Author:

achimha

Message:

* empty log message *

Location:

trunk/src/comctl32

Files:

• cache.c (added)
• comctl32.c (modified) (1 diff)
• comctl32.def (modified) (2 diffs)
• comctl32.h (modified) (2 diffs)
• comctl32undoc.c (modified) (2 diffs)
• header.c (added)
• initterm.c (modified) (2 diffs)
• listview.c (added)
• makefile (modified) (2 diffs)
• propsheet.c (added)
• tab.c (modified) (4 diffs)
• toolbar.c (added)
• trackbar.c (added)
• treeview.c (added)
• updown.c (added)

trunk/src/comctl32/comctl32.c

@@ -23 +23 @@
 #include "pager.h"
 #include "tab.h"
+#include "status.h"
+#include "header.h"
+#include "updown.h"
+#include "rebar.h"
+#include "trackbar.h"
+#include "tooltips.h"
+#include "toolbar.h"
+#include "treeview.h"
 
 HANDLE COMCTL32_hHeap = (HANDLE)NULL;
+HMODULE COMCTL32_hModule = 0;
+LPSTR    COMCTL32_aSubclass = (LPSTR)NULL;
 
-
-void RegisterCOMCTL32WindowClasses(void)
+void RegisterCOMCTL32WindowClasses(unsigned long hinstDLL)
 {
   /* create private heap */
   COMCTL32_hHeap = HeapCreate(0, 0x10000, 0);
+  /* add global subclassing atom (used by 'tooltip' and 'updown') */
+  COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtomA ("CC32SubclassInfo");
+  /* This will be wrong for any other process attching in this address-space! */
+  COMCTL32_hModule = (HMODULE)hinstDLL;
 
-  /* register progress control */
+  /* register controls */
   PROGRESS_Register();
-  /* register extended combobox control */
   COMBOEX_Register();
-  /* register animation control */
   ANIMATE_Register();
-  /* register date time control */
   DATETIME_Register();
-  /* register the flat scrollbar control */
   FLATSB_Register();
-  /* register hotkey control */
   HOTKEY_Register();
-  /* register IP address control */
 //  IPADDRESS_Register();
-  /* register month calender control */
   MONTHCAL_Register();
-  /* register native font control */
   NATIVEFONT_Register();
-  /* register pager control */
   PAGER_Register();
-  /* register tab control */
   TAB_Register();
+  STATUS_Register();
+  HEADER_Register();
+  UPDOWN_Register();
+  REBAR_Register();
+  TRACKBAR_Register();
+  TOOLTIPS_Register();
+  TOOLBAR_Register();
+  TREEVIEW_Register();
 } 
 
 void UnregisterCOMCTL32WindowClasses(void)
 {
-  /* unregister progress control */
+  /* unregister controls */
   PROGRESS_Unregister();
-  /* unregister extended combobox control */
   COMBOEX_Unregister();
-  /* unregister animation control */
   ANIMATE_Unregister();
-  /* unregister date time control */
   DATETIME_Unregister();
-  /* unregister flat scrollbar control */
   FLATSB_Unregister();
-  /* unregister hotkey control */
   HOTKEY_Unregister();
-  /* unregister IP address control */
 //  IPADDRESS_Unregister();
-  /* unregister month calendar control */
   MONTHCAL_Unregister();
-  /* unregister native font control */
   NATIVEFONT_Unregister();
-  /* unregister pager control */
   PAGER_Unregister();
-  /* unregister tab control */
   TAB_Unregister();
+  STATUS_Unregister();
+  HEADER_Unregister();
+  UPDOWN_Unregister();
+  REBAR_Unregister();
+  TRACKBAR_Unregister();
+  TOOLTIPS_Unregister();
+  TOOLBAR_Unregister();
+  TREEVIEW_Unregister();
 
   /* destroy private heap */

trunk/src/comctl32/comctl32.def

@@ -43 +43 @@
   ImageList_SetOverlayImage    = _ImageList_SetOverlayImage@12       @79
 
+  PropertySheetA               = _PropertySheetA@4                   @84
+  PropertySheetW               = _PropertySheetW@4                   @85
+  CreatePropertySheetPageA     = _CreatePropertySheetPageA@4         @19
+  CreatePropertySheetPageW     = _CreatePropertySheetPageW@4         @20
+  DestroyPropertySheetPage     = _DestroyPropertySheetPage@4         @24
+  
+
 
   COMCTL32_Alloc     = _COMCTL32_Alloc@4        @71
@@ -48 +55 @@
   COMCTL32_Free      = _COMCTL32_Free@4         @73
   COMCTL32_GetSize   = _COMCTL32_GetSize@4      @74
+
+  Str_GetPtrA        = _Str_GetPtrA@12          @233
+  Str_SetPtrA        = _Str_SetPtrA@8           @234
+  Str_GetPtrW        = _Str_GetPtrW@12          @235
+  Str_SetPtrW        = _Str_SetPtrW@8           @236
+
+  DSA_Create         = _DSA_Create@8            @320
+  DSA_Destroy        = _DSA_Destroy@4           @321
+  DSA_GetItem        = _DSA_GetItem@12          @322
+  DSA_GetItemPtr     = _DSA_GetItemPtr@8        @323
+  DSA_SetItem        = _DSA_SetItem@12          @324
+  DSA_InsertItem     = _DSA_InsertItem@12       @325
+  DSA_DeleteItem     = _DSA_DeleteItem@8        @326
+  DSA_DeleteAllItems = _DSA_DeleteAllItems@4    @327
+
+  DPA_Create         = _DPA_Create@4            @328
+  DPA_Destroy        = _DPA_Destroy@4           @329
+  DPA_Grow           = _DPA_Grow@8              @330
+  DPA_Clone          = _DPA_Clone@8             @331
+  DPA_GetPtr         = _DPA_GetPtr@8            @332
+  DPA_GetPtrIndex    = _DPA_GetPtrIndex@8       @333
+  DPA_InsertPtr      = _DPA_InsertPtr@12        @334
+  DPA_SetPtr         = _DPA_SetPtr@12           @335
+  DPA_DeletePtr      = _DPA_DeletePtr@8         @336
+  DPA_DeleteAllPtrs  = _DPA_DeleteAllPtrs@4     @337
+  DPA_Sort           = _DPA_Sort@12             @338
+  DPA_Search         = _DPA_Search@24           @339
+  DPA_CreateEx       = _DPA_CreateEx@8          @440

trunk/src/comctl32/comctl32.h

@@ -21 +21 @@
 
 /* registers window classes inside this DLL */
-void RegisterCOMCTL32WindowClasses(void);
+void RegisterCOMCTL32WindowClasses(unsigned long hinstDLL);
 
 
@@ -37 +37 @@
 
 
+extern HMODULE COMCTL32_hModule;
+
+/* Property sheet / Wizard */
+#define IDD_PROPSHEET 1006
+#define IDD_WIZARD    1020
+
+#define IDC_TABCONTROL   12320
+#define IDC_APPLY_BUTTON 12321
+
+/* Toolbar customization dialog */
+#define IDD_TBCUSTOMIZE     200
+
+#define IDC_AVAILBTN_LBOX   201
+#define IDC_RESET_BTN       202
+#define IDC_TOOLBARBTN_LBOX 203
+#define IDC_REMOVE_BTN      204
+#define IDC_HELP_BTN        205
+#define IDC_MOVEUP_BTN      206
+#define IDC_MOVEDN_BTN      207
+
+
 #endif /* _H_COMCTL32 */

trunk/src/comctl32/comctl32undoc.c

@@ -12 +12 @@
 
 #include "comctl32.h"
+#include <memory.h>
 
 extern HANDLE COMCTL32_hHeap; /* handle to the private heap */
@@ -110 +111 @@
     return HeapSize (COMCTL32_hHeap, 0, lpMem);
 }
+
+
+/**************************************************************************
+ * Str_GetPtrA [COMCTL32.233]
+ *
+ * PARAMS
+ *     lpSrc   [I]
+ *     lpDest  [O]
+ *     nMaxLen [I]
+ *
+ * RETURNS
+ */
+
+INT WINAPI
+Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen)
+{
+    INT len;
+
+//    TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
+
+    if (!lpDest && lpSrc)
+        return lstrlenA (lpSrc);
+
+    if (nMaxLen == 0)
+        return 0;
+
+    if (lpSrc == NULL) {
+        lpDest[0] = '\0';
+        return 0;
+    }
+
+    len = lstrlenA (lpSrc);
+    if (len >= nMaxLen)
+        len = nMaxLen - 1;
+
+    RtlMoveMemory (lpDest, lpSrc, len);
+    lpDest[len] = '\0';
+
+    return len;
+}
+
+
+/**************************************************************************
+ * Str_SetPtrA [COMCTL32.234]
+ *
+ * PARAMS
+ *     lppDest [O]
+ *     lpSrc   [I]
+ *
+ * RETURNS
+ */
+
+BOOL WINAPI
+Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
+{
+//    TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
+ 
+    if (lpSrc) {
+        LPSTR ptr = COMCTL32_ReAlloc (*lppDest, lstrlenA (lpSrc) + 1);
+        if (!ptr)
+            return FALSE;
+        lstrcpyA (ptr, lpSrc);
+        *lppDest = ptr;
+    }
+    else {
+        if (*lppDest) {
+            COMCTL32_Free (*lppDest);
+            *lppDest = NULL;
+        }
+    }
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * Str_GetPtrW [COMCTL32.235]
+ *
+ * PARAMS
+ *     lpSrc   [I]
+ *     lpDest  [O]
+ *     nMaxLen [I]
+ *
+ * RETURNS
+ */
+
+INT WINAPI
+Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
+{
+    INT len;
+
+//    TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
+
+    if (!lpDest && lpSrc)
+        return lstrlenW (lpSrc);
+
+    if (nMaxLen == 0)
+        return 0;
+
+    if (lpSrc == NULL) {
+        lpDest[0] = L'\0';
+        return 0;
+    }
+
+    len = lstrlenW (lpSrc);
+    if (len >= nMaxLen)
+        len = nMaxLen - 1;
+
+    RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
+    lpDest[len] = L'\0';
+
+    return len;
+}
+
+
+/**************************************************************************
+ * Str_SetPtrW [COMCTL32.236]
+ *
+ * PARAMS
+ *     lpDest [O]
+ *     lpSrc  [I]
+ *
+ * RETURNS
+ */
+
+BOOL WINAPI
+Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
+{
+//    TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
+ 
+    if (lpSrc) {
+        INT len = lstrlenW (lpSrc) + 1;
+        LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
+        if (!ptr)
+            return FALSE;
+        lstrcpyW (ptr, lpSrc);
+        *lppDest = ptr;
+    }
+    else {
+        if (*lppDest) {
+            COMCTL32_Free (*lppDest);
+            *lppDest = NULL;
+        }
+    }
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * The DSA-API is a set of functions to create and manipulate arrays of
+ * fix sized memory blocks. These arrays can store any kind of data
+ * (strings, icons...).
+ */
+
+/**************************************************************************
+ * DSA_Create [COMCTL32.320] Creates a dynamic storage array
+ *
+ * PARAMS
+ *     nSize [I] size of the array elements
+ *     nGrow [I] number of elements by which the array grows when it is filled
+ *
+ * RETURNS
+ *     Success: pointer to a array control structure. use this like a handle.
+ *     Failure: NULL
+ */
+
+HDSA WINAPI
+DSA_Create (INT nSize, INT nGrow)
+{
+    HDSA hdsa;
+
+//    TRACE (commctrl, "(size=%d grow=%d)\n", nSize, nGrow);
+
+    hdsa = (HDSA)COMCTL32_Alloc (sizeof(DSA));
+    if (hdsa)
+    {
+        hdsa->nItemCount = 0;
+        hdsa->pData = NULL;
+        hdsa->nMaxCount = 0;
+        hdsa->nItemSize = nSize;
+        hdsa->nGrow = MAX(1, nGrow);
+    }
+
+    return hdsa;
+}
+
+
+/**************************************************************************
+ * DSA_Destroy [COMCTL32.321] Destroys a dynamic storage array
+ *
+ * PARAMS
+ *     hdsa [I] pointer to the array control structure
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DSA_Destroy (const HDSA hdsa)
+{
+//    TRACE (commctrl, "(%p)\n", hdsa);
+
+    if (!hdsa)
+        return FALSE;
+
+    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
+        return FALSE;
+
+    return COMCTL32_Free (hdsa);
+}
+
+
+/**************************************************************************
+ * DSA_GetItem [COMCTL32.322] 
+ *
+ * PARAMS
+ *     hdsa   [I] pointer to the array control structure
+ *     nIndex [I] number of the Item to get
+ *     pDest  [O] destination buffer. Has to be >= dwElementSize.
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
+{
+    LPVOID pSrc;
+
+//    TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pDest);
+    
+    if (!hdsa)
+        return FALSE;
+    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
+        return FALSE;
+
+    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+    memmove (pDest, pSrc, hdsa->nItemSize);
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * DSA_GetItemPtr [COMCTL32.323] 
+ *
+ * Retrieves a pointer to the specified item.
+ *
+ * PARAMS
+ *     hdsa   [I] pointer to the array control structure
+ *     nIndex [I] index of the desired item
+ *
+ * RETURNS
+ *     Success: pointer to an item
+ *     Failure: NULL
+ */
+
+LPVOID WINAPI
+DSA_GetItemPtr (const HDSA hdsa, INT nIndex)
+{
+    LPVOID pSrc;
+
+//    TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
+
+    if (!hdsa)
+        return NULL;
+    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
+        return NULL;
+
+    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+    
+//    TRACE (commctrl, "-- ret=%p\n", pSrc);
+
+    return  pSrc;
+}
+
+
+/**************************************************************************
+ * DSA_SetItem [COMCTL32.325] 
+ *
+ * Sets the contents of an item in the array.
+ *
+ * PARAMS
+ *     hdsa   [I] pointer to the array control structure
+ *     nIndex [I] index for the item
+ *     pSrc   [I] pointer to the new item data
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
+{
+    INT  nSize, nNewItems;
+    LPVOID pDest, lpTemp;
+    
+//    TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pSrc);
+
+    if ((!hdsa) || nIndex < 0)
+        return FALSE;
+      
+    if (hdsa->nItemCount <= nIndex) {
+        /* within the old array */
+        if (hdsa->nMaxCount > nIndex) {
+            /* within the allocated space, set a new boundary */
+            hdsa->nItemCount = nIndex;
+        }
+        else {
+            /* resize the block of memory */
+            nNewItems =
+                hdsa->nGrow * ((INT)((nIndex - 1) / hdsa->nGrow) + 1);
+            nSize = hdsa->nItemSize * nNewItems;
+
+            lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
+            if (!lpTemp)
+                return FALSE;
+
+            hdsa->nMaxCount = nNewItems;
+            hdsa->pData = lpTemp;
+        }    
+    }
+
+    /* put the new entry in */
+    pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+//    TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
+//         pDest, pSrc, hdsa->nItemSize);
+    memmove (pDest, pSrc, hdsa->nItemSize);
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * DSA_InsertItem [COMCTL32.325] 
+ *
+ * PARAMS
+ *     hdsa   [I] pointer to the array control structure
+ *     nIndex [I] index for the new item
+ *     pSrc   [I] pointer to the element
+ *
+ * RETURNS
+ *     Success: position of the new item
+ *     Failure: -1
+ */
+
+INT WINAPI
+DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
+{
+    INT   nNewItems, nSize, i;
+    LPVOID  lpTemp, lpDest;
+    LPDWORD p;
+    
+//    TRACE(commctrl, "(%p %d %p)\n", hdsa, nIndex, pSrc);
+
+    if ((!hdsa) || nIndex < 0)
+        return -1;
+
+    for (i = 0; i < hdsa->nItemSize; i += 4) {
+        p = *(DWORD**)((char *) pSrc + i);
+//      if (IsBadStringPtrA ((char*)p, 256))
+//          TRACE (commctrl, "-- %d=%p\n", i, (DWORD*)p);
+//      else
+//          TRACE (commctrl, "-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
+    }
+   
+    /* when nIndex > nItemCount then append */
+    if (nIndex >= hdsa->nItemCount)
+        nIndex = hdsa->nItemCount;
+
+    /* do we need to resize ? */
+    if (hdsa->nItemCount >= hdsa->nMaxCount) {
+        nNewItems = hdsa->nMaxCount + hdsa->nGrow;
+        nSize = hdsa->nItemSize * nNewItems;
+
+        lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
+        if (!lpTemp)
+            return -1;
+
+        hdsa->nMaxCount = nNewItems;
+        hdsa->pData = lpTemp;         
+    }
+
+    /* do we need to move elements ? */
+    if (nIndex < hdsa->nItemCount) {
+        lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+        lpDest = (char *) lpTemp + hdsa->nItemSize;
+        nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
+//      TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
+//             lpDest, lpTemp, nSize);
+        memmove (lpDest, lpTemp, nSize);
+    }
+
+    /* ok, we can put the new Item in */
+    hdsa->nItemCount++;
+    lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+//    TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
+//         lpDest, pSrc, hdsa->nItemSize);
+    memmove (lpDest, pSrc, hdsa->nItemSize);
+
+    return hdsa->nItemCount;
+}
+
+
+/**************************************************************************
+ * DSA_DeleteItem [COMCTL32.326] 
+ *
+ * PARAMS
+ *     hdsa   [I] pointer to the array control structure
+ *     nIndex [I] index for the element to delete
+ *
+ * RETURNS
+ *     Success: number of the deleted element
+ *     Failure: -1
+ */
+
+INT WINAPI
+DSA_DeleteItem (const HDSA hdsa, INT nIndex)
+{
+    LPVOID lpDest,lpSrc;
+    INT  nSize;
+    
+//    TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
+
+    if (!hdsa)
+        return -1;
+    if (nIndex < 0 || nIndex >= hdsa->nItemCount)
+        return -1;
+
+    /* do we need to move ? */
+    if (nIndex < hdsa->nItemCount - 1) {
+        lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+        lpSrc = (char *) lpDest + hdsa->nItemSize;
+        nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
+//      TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
+//             lpDest, lpSrc, nSize);
+        memmove (lpDest, lpSrc, nSize);
+    }
+    
+    hdsa->nItemCount--;
+    
+    /* free memory ? */
+    if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
+        nSize = hdsa->nItemSize * hdsa->nItemCount;
+
+        lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
+        if (!lpDest)
+            return -1;
+
+        hdsa->nMaxCount = hdsa->nItemCount;
+        hdsa->pData = lpDest;
+    }
+
+    return nIndex;
+}
+
+
+/**************************************************************************
+ * DSA_DeleteAllItems [COMCTL32.326]
+ *
+ * Removes all items and reinitializes the array.
+ *
+ * PARAMS
+ *     hdsa [I] pointer to the array control structure
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DSA_DeleteAllItems (const HDSA hdsa)
+{
+//    TRACE (commctrl, "(%p)\n", hdsa);
+
+    if (!hdsa) 
+        return FALSE;
+    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
+        return FALSE;
+
+    hdsa->nItemCount = 0;
+    hdsa->pData = NULL;
+    hdsa->nMaxCount = 0;
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * The DPA-API is a set of functions to create and manipulate arrays of
+ * pointers.
+ */
+
+/**************************************************************************
+ * DPA_Create [COMCTL32.328] Creates a dynamic pointer array
+ *
+ * PARAMS
+ *     nGrow [I] number of items by which the array grows when it is filled
+ *
+ * RETURNS
+ *     Success: handle (pointer) to the pointer array.
+ *     Failure: NULL
+ */
+
+HDPA WINAPI
+DPA_Create (INT nGrow)
+{
+    HDPA hdpa;
+
+//    TRACE (commctrl, "(%d)\n", nGrow);
+
+    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
+    if (hdpa) {
+        hdpa->nGrow = MAX(8, nGrow);
+        hdpa->hHeap = COMCTL32_hHeap;
+        hdpa->nMaxCount = hdpa->nGrow * 2;
+        hdpa->ptrs =
+            (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
+    }
+
+//    TRACE (commctrl, "-- %p\n", hdpa);
+
+    return hdpa;
+}
+
+
+/**************************************************************************
+ * DPA_Destroy [COMCTL32.329] Destroys a dynamic pointer array
+ *
+ * PARAMS
+ *     hdpa [I] handle (pointer) to the pointer array
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DPA_Destroy (const HDPA hdpa)
+{
+//    TRACE (commctrl, "(%p)\n", hdpa);
+
+    if (!hdpa)
+        return FALSE;
+
+    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
+        return FALSE;
+
+    return HeapFree (hdpa->hHeap, 0, hdpa);
+}
+
+
+/**************************************************************************
+ * DPA_Grow [COMCTL32.330]
+ *
+ * Sets the growth amount.
+ *
+ * PARAMS
+ *     hdpa  [I] handle (pointer) to the existing (source) pointer array
+ *     nGrow [I] number of items, the array grows, when it's too small
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DPA_Grow (const HDPA hdpa, INT nGrow)
+{
+//    TRACE (commctrl, "(%p %d)\n", hdpa, nGrow);
+
+    if (!hdpa)
+        return FALSE;
+
+    hdpa->nGrow = MAX(8, nGrow);
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * DPA_Clone [COMCTL32.331]
+ *
+ * Copies a pointer array to an other one or creates a copy
+ *
+ * PARAMS
+ *     hdpa    [I] handle (pointer) to the existing (source) pointer array
+ *     hdpaNew [O] handle (pointer) to the destination pointer array
+ *
+ * RETURNS
+ *     Success: pointer to the destination pointer array.
+ *     Failure: NULL
+ *
+ * NOTES
+ *     - If the 'hdpaNew' is a NULL-Pointer, a copy of the source pointer
+ *       array will be created and it's handle (pointer) is returned.
+ *     - If 'hdpa' is a NULL-Pointer, the original implementation crashes,
+ *       this implementation just returns NULL.
+ */
+
+HDPA WINAPI
+DPA_Clone (const HDPA hdpa, const HDPA hdpaNew)
+{
+    INT nNewItems, nSize;
+    HDPA hdpaTemp;
+
+    if (!hdpa)
+        return NULL;
+
+//    TRACE (commctrl, "(%p %p)\n", hdpa, hdpaNew);
+
+    if (!hdpaNew) {
+        /* create a new DPA */
+        hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                                    sizeof(DPA));
+        hdpaTemp->hHeap = hdpa->hHeap;
+        hdpaTemp->nGrow = hdpa->nGrow;
+    }
+    else
+        hdpaTemp = hdpaNew;
+
+    if (hdpaTemp->ptrs) {
+        /* remove old pointer array */
+        HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
+        hdpaTemp->ptrs = NULL;
+        hdpaTemp->nItemCount = 0;
+        hdpaTemp->nMaxCount = 0;
+    }
+
+    /* create a new pointer array */
+    nNewItems = hdpaTemp->nGrow *
+                ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
+    nSize = nNewItems * sizeof(LPVOID);
+    hdpaTemp->ptrs =
+        (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
+    hdpaTemp->nMaxCount = nNewItems;
+
+    /* clone the pointer array */
+    hdpaTemp->nItemCount = hdpa->nItemCount;
+    memmove (hdpaTemp->ptrs, hdpa->ptrs,
+             hdpaTemp->nItemCount * sizeof(LPVOID));
+
+    return hdpaTemp;
+}
+
+
+/**************************************************************************
+ * DPA_GetPtr [COMCTL32.332]
+ *
+ * Retrieves a pointer from a dynamic pointer array
+ *
+ * PARAMS
+ *     hdpa   [I] handle (pointer) to the pointer array
+ *     nIndex [I] array index of the desired pointer
+ *
+ * RETURNS
+ *     Success: pointer
+ *     Failure: NULL
+ */
+
+LPVOID WINAPI
+DPA_GetPtr (const HDPA hdpa, INT i)
+{
+//    TRACE (commctrl, "(%p %d)\n", hdpa, i);
+
+    if (!hdpa)
+        return NULL;
+    if (!hdpa->ptrs)
+        return NULL;
+    if ((i < 0) || (i >= hdpa->nItemCount))
+        return NULL;
+
+//    TRACE (commctrl, "-- %p\n", hdpa->ptrs[i]);
+
+    return hdpa->ptrs[i];
+}
+
+
+/**************************************************************************
+ * DPA_GetPtrIndex [COMCTL32.333]
+ *
+ * Retrieves the index of the specified pointer
+ *
+ * PARAMS
+ *     hdpa   [I] handle (pointer) to the pointer array
+ *     p      [I] pointer
+ *
+ * RETURNS
+ *     Success: index of the specified pointer
+ *     Failure: -1
+ */
+
+INT WINAPI
+DPA_GetPtrIndex (const HDPA hdpa, LPVOID p)
+{
+    INT i;
+
+    if (!hdpa->ptrs)
+        return -1;
+
+    for (i = 0; i < hdpa->nItemCount; i++) {
+        if (hdpa->ptrs[i] == p)
+            return i;
+    }
+
+    return -1;
+}
+
+
+/**************************************************************************
+ * DPA_InsertPtr [COMCTL32.334]
+ *
+ * Inserts a pointer into a dynamic pointer array
+ *
+ * PARAMS
+ *     hdpa [I] handle (pointer) to the array
+ *     i    [I] array index
+ *     p    [I] pointer to insert
+ *
+ * RETURNS
+ *     Success: index of the inserted pointer
+ *     Failure: -1
+ */
+
+INT WINAPI
+DPA_InsertPtr (const HDPA hdpa, INT i, LPVOID p)
+{
+    INT   nNewItems, nSize, nIndex = 0;
+    LPVOID  *lpTemp, *lpDest;
+
+//    TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
+
+    if ((!hdpa) || (i < 0))
+        return -1;
+
+    if (!hdpa->ptrs) {
+        hdpa->ptrs =
+            (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                                2 * hdpa->nGrow * sizeof(LPVOID));
+        if (!hdpa->ptrs)
+            return -1;
+        hdpa->nMaxCount = hdpa->nGrow * 2;
+        nIndex = 0;
+    }
+    else {
+        if (hdpa->nItemCount >= hdpa->nMaxCount) {
+//          TRACE (commctrl, "-- resizing\n");
+            nNewItems = hdpa->nMaxCount + hdpa->nGrow;
+            nSize = nNewItems * sizeof(LPVOID);
+
+            lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                                           hdpa->ptrs, nSize);
+            if (!lpTemp)
+                return -1;
+            hdpa->nMaxCount = nNewItems;
+            hdpa->ptrs = lpTemp;
+        }
+
+        if (i >= hdpa->nItemCount) {
+            nIndex = hdpa->nItemCount;
+//          TRACE (commctrl, "-- appending at %d\n", nIndex);
+        }
+        else {
+//          TRACE (commctrl, "-- inserting at %d\n", i);
+            lpTemp = hdpa->ptrs + i;
+            lpDest = lpTemp + 1;
+            nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
+//          TRACE (commctrl, "-- move dest=%p src=%p size=%x\n",
+//                 lpDest, lpTemp, nSize);
+            memmove (lpDest, lpTemp, nSize);
+            nIndex = i;
+        }
+    }
+
+    /* insert item */
+    hdpa->nItemCount++;
+    hdpa->ptrs[nIndex] = p;
+
+    return nIndex;
+}
+
+
+/**************************************************************************
+ * DPA_SetPtr [COMCTL32.335]
+ *
+ * Sets a pointer in the pointer array
+ *
+ * PARAMS
+ *     hdpa [I] handle (pointer) to the pointer array
+ *     i    [I] index of the pointer that will be set
+ *     p    [I] pointer to be set
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DPA_SetPtr (const HDPA hdpa, INT i, LPVOID p)
+{
+    LPVOID *lpTemp;
+    
+//    TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
+
+    if ((!hdpa) || i < 0)
+        return FALSE;
+      
+    if (hdpa->nItemCount <= i) {
+        /* within the old array */
+        if (hdpa->nMaxCount > i) {
+            /* within the allocated space, set a new boundary */
+            hdpa->nItemCount = i;
+        }
+        else {
+            /* resize the block of memory */
+            INT nNewItems =
+                hdpa->nGrow * ((INT)((i - 1) / hdpa->nGrow) + 1);
+            INT nSize = nNewItems * sizeof(LPVOID);
+
+            lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                                           hdpa->ptrs, nSize);
+            if (!lpTemp)
+                return FALSE;
+
+            hdpa->nItemCount = nNewItems;
+            hdpa->ptrs = lpTemp;        
+        }    
+    }
+
+    /* put the new entry in */
+    hdpa->ptrs[i] = p;
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * DPA_DeletePtr [COMCTL32.336]
+ *
+ * Removes a pointer from the pointer array.
+ *
+ * PARAMS
+ *     hdpa [I] handle (pointer) to the pointer array
+ *     i    [I] index of the pointer that will be deleted
+ *
+ * RETURNS
+ *     Success: deleted pointer
+ *     Failure: NULL
+ */
+
+LPVOID WINAPI
+DPA_DeletePtr (const HDPA hdpa, INT i)
+{
+    LPVOID *lpDest, *lpSrc, lpTemp = NULL;
+    INT  nSize;
+    
+//    TRACE (commctrl, "(%p %d)\n", hdpa, i);
+
+    if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
+        return NULL;
+
+    lpTemp = hdpa->ptrs[i];
+
+    /* do we need to move ?*/
+    if (i < hdpa->nItemCount - 1) {
+        lpDest = hdpa->ptrs + i;
+        lpSrc = lpDest + 1;
+        nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
+//      TRACE (commctrl,"-- move dest=%p src=%p size=%x\n",
+//             lpDest, lpSrc, nSize);
+        memmove (lpDest, lpSrc, nSize);
+    }
+    
+    hdpa->nItemCount --;
+    
+    /* free memory ?*/
+    if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
+        INT nNewItems = MIN(hdpa->nGrow * 2, hdpa->nItemCount);
+        nSize = nNewItems * sizeof(LPVOID);
+        lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                                      hdpa->ptrs, nSize);
+        if (!lpDest)
+            return NULL;
+
+        hdpa->nMaxCount = nNewItems;
+        hdpa->ptrs = (LPVOID*)lpDest;         
+    }
+
+    return lpTemp;
+}
+
+
+/**************************************************************************
+ * DPA_DeleteAllPtrs [COMCTL32.337]
+ *
+ * Removes all pointers and reinitializes the array.
+ *
+ * PARAMS
+ *     hdpa [I] handle (pointer) to the pointer array
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DPA_DeleteAllPtrs (const HDPA hdpa)
+{
+//    TRACE (commctrl, "(%p)\n", hdpa);
+
+    if (!hdpa) 
+        return FALSE;
+
+    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
+        return FALSE;
+
+    hdpa->nItemCount = 0;
+    hdpa->nMaxCount = hdpa->nGrow * 2;
+    hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                                     hdpa->nMaxCount * sizeof(LPVOID));
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * DPA_QuickSort [Internal]
+ *
+ * Ordinary quicksort (used by DPA_Sort).
+ *
+ * PARAMS
+ *     lpPtrs     [I] pointer to the pointer array
+ *     l          [I] index of the "left border" of the partition
+ *     r          [I] index of the "right border" of the partition
+ *     pfnCompare [I] pointer to the compare function
+ *     lParam     [I] user defined value (3rd parameter in compare function)
+ *
+ * RETURNS
+ *     NONE
+ */
+
+static VOID
+DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
+               PFNDPACOMPARE pfnCompare, LPARAM lParam)
+{
+    LPVOID t, v;
+    INT  i, j;
+
+//    TRACE (commctrl, "l=%i r=%i\n", l, r);
+ 
+    i = l;
+    j = r;
+    v = lpPtrs[(int)(l+r)/2];
+    do {
+        while ((pfnCompare)(lpPtrs[i], v, lParam) > 0) i++;
+        while ((pfnCompare)(lpPtrs[j], v, lParam) < 0) j--;
+        if (i <= j) 
+        {
+            t = lpPtrs[i];
+            lpPtrs[i++] = lpPtrs[j];
+            lpPtrs[j--] = t;
+        }
+    } while (i <= j);
+    if (l < j) DPA_QuickSort (lpPtrs, l, j, pfnCompare, lParam);
+    if (i < r) DPA_QuickSort (lpPtrs, i, r, pfnCompare, lParam);
+}
+
+
+/**************************************************************************
+ * DPA_Sort [COMCTL32.338]
+ *
+ * Sorts a pointer array using a user defined compare function
+ *
+ * PARAMS
+ *     hdpa       [I] handle (pointer) to the pointer array
+ *     pfnCompare [I] pointer to the compare function
+ *     lParam     [I] user defined value (3rd parameter of compare function)
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam)
+{
+    if (!hdpa || !pfnCompare)
+        return FALSE;
+
+//    TRACE (commctrl, "(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
+
+    if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
+        DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
+                       pfnCompare, lParam);
+
+    return TRUE;
+}
+
+
+/**************************************************************************
+ * DPA_Search [COMCTL32.339]
+ *
+ * Searches a pointer array for a specified pointer
+ *
+ * PARAMS
+ *     hdpa       [I] handle (pointer) to the pointer array
+ *     pFind      [I] pointer to search for
+ *     nStart     [I] start index
+ *     pfnCompare [I] pointer to the compare function
+ *     lParam     [I] user defined value (3rd parameter of compare function)
+ *     uOptions   [I] search options
+ *
+ * RETURNS
+ *     Success: index of the pointer in the array.
+ *     Failure: -1
+ *
+ * NOTES
+ *     Binary search taken from R.Sedgewick "Algorithms in C"!
+ *     Function is NOT tested!
+ *     If something goes wrong, blame HIM not ME! (Eric Kohl)
+ */
+
+INT WINAPI
+DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
+            PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
+{
+    if (!hdpa || !pfnCompare || !pFind)
+        return -1;
+
+//    TRACE (commctrl, "(%p %p %d %p 0x%08lx 0x%08x)\n",
+//         hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
+
+    if (uOptions & DPAS_SORTED) {
+        /* array is sorted --> use binary search */
+        INT l, r, x, n;
+        LPVOID *lpPtr;
+
+//      TRACE (commctrl, "binary search\n");
+
+        l = (nStart == -1) ? 0 : nStart;
+        r = hdpa->nItemCount - 1;
+        lpPtr = hdpa->ptrs;
+        while (r >= l) {
+            x = (l + r) / 2;
+            n = (pfnCompare)(pFind, lpPtr[x], lParam);
+            if (n < 0)
+                r = x - 1;
+            else
+                l = x + 1;
+            if (n == 0) {
+//              TRACE (commctrl, "-- ret=%d\n", n);
+                return n;
+            }
+        }
+
+        if (uOptions & DPAS_INSERTBEFORE) {
+//          TRACE (commctrl, "-- ret=%d\n", r);
+            return r;
+        }
+
+        if (uOptions & DPAS_INSERTAFTER) {
+//          TRACE (commctrl, "-- ret=%d\n", l);
+            return l;
+        }
+    }
+    else {
+        /* array is not sorted --> use linear search */
+        LPVOID *lpPtr;
+        INT  nIndex;
+
+//      TRACE (commctrl, "linear search\n");
+        
+        nIndex = (nStart == -1)? 0 : nStart;
+        lpPtr = hdpa->ptrs;
+        for (; nIndex < hdpa->nItemCount; nIndex++) {
+            if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
+//              TRACE (commctrl, "-- ret=%d\n", nIndex);
+                return nIndex;
+            }
+        }
+    }
+
+//    TRACE (commctrl, "-- not found: ret=-1\n");
+    return -1;
+}
+
+
+/**************************************************************************
+ * DPA_CreateEx [COMCTL32.340]
+ *
+ * Creates a dynamic pointer array using the specified size and heap.
+ *
+ * PARAMS
+ *     nGrow [I] number of items by which the array grows when it is filled
+ *     hHeap [I] handle to the heap where the array is stored
+ *
+ * RETURNS
+ *     Success: handle (pointer) to the pointer array.
+ *     Failure: NULL
+ */
+
+HDPA WINAPI
+DPA_CreateEx (INT nGrow, HANDLE hHeap)
+{
+    HDPA hdpa;
+
+//    TRACE (commctrl, "(%d 0x%x)\n", nGrow, hHeap);
+
+    if (hHeap)
+        hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
+    else
+        hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
+
+    if (hdpa) {
+        hdpa->nGrow = MIN(8, nGrow);
+        hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
+        hdpa->nMaxCount = hdpa->nGrow * 2;
+        hdpa->ptrs =
+            (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
+                                hdpa->nMaxCount * sizeof(LPVOID));
+    }
+
+//    TRACE (commctrl, "-- %p\n", hdpa);
+
+    return hdpa;
+}

trunk/src/comctl32/initterm.c

@@ -47 +47 @@
 void __ctordtorTerm( void );
 
-void RegisterCOMCTL32WindowClasses(void);
+void RegisterCOMCTL32WindowClasses(unsigned long hinstDLL);
 void UnregisterCOMCTL32WindowClasses(void);
 
@@ -104 +104 @@
 
         /* register Win32 window classes implemented in this DLL */
-        RegisterCOMCTL32WindowClasses();
+        RegisterCOMCTL32WindowClasses(hModule);
 
          break;

trunk/src/comctl32/makefile

@@ -19 +19 @@
 TARGET = comctl32
 
-OBJS =  comctl32.obj initterm.obj progress.obj comctl32undoc.obj imagelist.obj comboex.obj animate.obj datetime.obj flatsb.obj hotkey.obj monthcal.obj nativefont.obj pager.obj tab.obj
+OBJS =  comctl32.obj initterm.obj progress.obj comctl32undoc.obj imagelist.obj \
+        comboex.obj animate.obj datetime.obj flatsb.obj hotkey.obj monthcal.obj \
+        nativefont.obj pager.obj tab.obj status.obj header.obj updown.obj \
+        rebar.obj cache.obj trackbar.obj tooltips.obj toolbar.obj treeview.obj \
+        propsheet.obj listview.obj
 
 all: $(TARGET).dll $(TARGET).lib
@@ -51 +55 @@
 pager.obj: pager.c
 tab.obj: tab.c
-#status.obj: status.c
+status.obj: status.c
+header.obj: header.c
+updown.obj: updown.c
+rebar:obj: rebar.c
+cache.obj: cache.c
+trackbar.obj: trackbar.c
+tooltips.obj: tooltips.c
+toolbar.obj: toolbar.c
+treeview.obj: treeview.c
+propsheet.obj: propsheet.c
+listview.obj: listview.c
 
 clean:

trunk/src/comctl32/tab.c

@@ -395 +395 @@
   pt.y = (INT)HIWORD(lParam);
   
-  newItem=TAB_InternalHitTest (hwnd, infoPtr,pt,&dummy);
+  newItem=TAB_InternalHitTest (hwnd, infoPtr,pt,(unsigned int*)&dummy);
   
 //  TRACE(tab, "On Tab, item %d\n", newItem);
@@ -1330 +1330 @@
   iItem=(INT) wParam;
   tabItem=(LPTCITEMA ) lParam;
-  TRACE (tab,"%d %p\n",iItem, tabItem);
+//  TRACE (tab,"%d %p\n",iItem, tabItem);
   if ((iItem<0) || (iItem>infoPtr->uNumItem)) return FALSE;
 
@@ -1376 +1376 @@
   iItem=(INT) wParam;
   tabItem=(LPTCITEMA) lParam;
-  TRACE (tab,"\n");
+//  TRACE (tab,"\n");
   if ((iItem<0) || (iItem>infoPtr->uNumItem)) return FALSE;
 
@@ -1460 +1460 @@
   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 
-  TRACE (tab,"\n");
+//  TRACE (tab,"\n");
   return (LRESULT)infoPtr->hFont;
 }