diff --git a/reactos/dll/win32/comctl32/comboex.c b/reactos/dll/win32/comctl32/comboex.c
index 25c2dbff824..04464fd94a8 100644
--- a/reactos/dll/win32/comctl32/comboex.c
+++ b/reactos/dll/win32/comctl32/comboex.c
@@ -1535,11 +1535,11 @@ static LRESULT COMBOEX_DrawItem (COMBOEX_INFO *infoPtr, DRAWITEMSTRUCT const *di
 
 	/* now draw the text */
 	if (!IsWindowVisible (infoPtr->hwndEdit)) {
-	    nbkc = GetSysColor ((dis->itemState & ODS_SELECTED) ?
-				COLOR_HIGHLIGHT : COLOR_WINDOW);
+	    nbkc = (dis->itemState & ODS_SELECTED) ?
+	            comctl32_color.clrHighlight : comctl32_color.clrWindow;
 	    bkc = SetBkColor (dis->hDC, nbkc);
-	    ntxc = GetSysColor ((dis->itemState & ODS_SELECTED) ?
-				COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT);
+	    ntxc = (dis->itemState & ODS_SELECTED) ?
+	            comctl32_color.clrHighlightText : comctl32_color.clrWindowText;
 	    txc = SetTextColor (dis->hDC, ntxc);
 	    x = xbase + xioff;
 	    y = dis->rcItem.top +
@@ -1750,7 +1750,7 @@ COMBOEX_EditWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 	     * The following was determined by traces of the native
 	     */
             hDC = (HDC) wParam;
-	    obkc = SetBkColor (hDC, GetSysColor (COLOR_WINDOW));
+	    obkc = SetBkColor (hDC, comctl32_color.clrWindow);
             GetClientRect (hwnd, &rect);
             TRACE("erasing (%s)\n", wine_dbgstr_rect(&rect));
 	    ExtTextOutW (hDC, 0, 0, ETO_OPAQUE, &rect, 0, 0, 0);
@@ -1953,7 +1953,7 @@ COMBOEX_ComboWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 	     * The following was determined by traces of the native
 	     */
             hDC = (HDC) wParam;
-	    obkc = SetBkColor (hDC, GetSysColor (COLOR_WINDOW));
+	    obkc = SetBkColor (hDC, comctl32_color.clrWindow);
             GetClientRect (hwnd, &rect);
             TRACE("erasing (%s)\n", wine_dbgstr_rect(&rect));
 	    ExtTextOutW (hDC, 0, 0, ETO_OPAQUE, &rect, 0, 0, 0);
@@ -2320,6 +2320,10 @@ COMBOEX_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
             SetFocus(infoPtr->hwndCombo);
             return 0;
 
+        case WM_SYSCOLORCHANGE:
+            COMCTL32_RefreshSysColors();
+            return 0;
+
 	default:
 	    if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
 		ERR("unknown msg %04x wp=%08lx lp=%08lx\n",uMsg,wParam,lParam);
diff --git a/reactos/dll/win32/comctl32/header.c b/reactos/dll/win32/comctl32/header.c
index 7e6e0ff378e..40718c78340 100644
--- a/reactos/dll/win32/comctl32/header.c
+++ b/reactos/dll/win32/comctl32/header.c
@@ -64,6 +64,7 @@ typedef struct
 
 typedef struct
 {
+    HWND      hwndSelf;		/* Control window */
     HWND      hwndNotify;	/* Owner window to send notifications to */
     INT       nNotifyFormat;	/* format used for WM_NOTIFY messages */
     UINT      uNumItem;		/* number of items (columns) */
@@ -77,6 +78,7 @@ typedef struct
     BOOL      bDragging;        /* Are we dragging an item? */
     BOOL      bTracking;	/* Is in tracking mode? */
     POINT     ptLButtonDown;    /* The point where the left button was pressed */
+    DWORD     dwStyle;		/* the cached window GWL_STYLE */
     INT       iMoveItem;	/* index of tracked item. (Tracking mode) */
     INT       xTrackOffset;	/* distance between the right side of the tracked item and the cursor */
     INT       xOldTrack;	/* track offset (see above) after the last WM_MOUSEMOVE */
@@ -103,12 +105,11 @@ typedef struct
 #define HDI_UNKNOWN_FIELDS (~(HDI_SUPPORTED_FIELDS|HDI_UNSUPPORTED_FIELDS|HDI_DI_SETITEM))
 #define HDI_COMCTL32_4_0_FIELDS (HDI_WIDTH|HDI_TEXT|HDI_FORMAT|HDI_LPARAM|HDI_BITMAP)
 
-#define HEADER_GetInfoPtr(hwnd) ((HEADER_INFO *)GetWindowLongPtrW(hwnd,0))
 
-static BOOL HEADER_PrepareCallbackItems(HWND hwnd, INT iItem, INT reqMask);
+static BOOL HEADER_PrepareCallbackItems(const HEADER_INFO *infoPtr, INT iItem, INT reqMask);
 static void HEADER_FreeCallbackItems(HEADER_ITEM *lpItem);
-static LRESULT HEADER_SendNotify(HWND hwnd, UINT code, NMHDR *hdr);
-static LRESULT HEADER_SendCtrlCustomDraw(HWND hwnd, DWORD dwDrawStage, HDC hdc, const RECT *rect);
+static LRESULT HEADER_SendNotify(const HEADER_INFO *infoPtr, UINT code, NMHDR *hdr);
+static LRESULT HEADER_SendCtrlCustomDraw(const HEADER_INFO *infoPtr, DWORD dwDrawStage, HDC hdc, const RECT *rect);
 
 static const WCHAR themeClass[] = {'H','e','a','d','e','r',0};
 
@@ -163,20 +164,16 @@ static void HEADER_StoreHDItemInHeader(HEADER_ITEM *lpItem, UINT mask, const HDI
 }
 
 static inline LRESULT
-HEADER_IndexToOrder (HWND hwnd, INT iItem)
+HEADER_IndexToOrder (const HEADER_INFO *infoPtr, INT iItem)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *lpItem = &infoPtr->items[iItem];
     return lpItem->iOrder;
 }
 
 
 static INT
-HEADER_OrderToIndex(HWND hwnd, WPARAM wParam)
+HEADER_OrderToIndex(const HEADER_INFO *infoPtr, INT iorder)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-    INT iorder = (INT)wParam;
-
     if ((iorder <0) || iorder >= infoPtr->uNumItem)
       return iorder;
     return infoPtr->order[iorder];
@@ -210,21 +207,20 @@ HEADER_ChangeItemOrder(const HEADER_INFO *infoPtr, INT iItem, INT iNewOrder)
 
 /* Note: if iItem is the last item then this function returns infoPtr->uNumItem */
 static INT
-HEADER_NextItem(HWND hwnd, INT iItem)
+HEADER_NextItem(const HEADER_INFO *infoPtr, INT iItem)
 {
-    return HEADER_OrderToIndex(hwnd, HEADER_IndexToOrder(hwnd, iItem)+1);
+    return HEADER_OrderToIndex(infoPtr, HEADER_IndexToOrder(infoPtr, iItem)+1);
 }
 
 static INT
-HEADER_PrevItem(HWND hwnd, INT iItem)
+HEADER_PrevItem(const HEADER_INFO *infoPtr, INT iItem)
 {
-    return HEADER_OrderToIndex(hwnd, HEADER_IndexToOrder(hwnd, iItem)-1);
+    return HEADER_OrderToIndex(infoPtr, HEADER_IndexToOrder(infoPtr, iItem)-1);
 }
 
 static void
-HEADER_SetItemBounds (HWND hwnd)
+HEADER_SetItemBounds (HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *phdi;
     RECT rect;
     unsigned int i;
@@ -235,11 +231,11 @@ HEADER_SetItemBounds (HWND hwnd)
     if (infoPtr->uNumItem == 0)
         return;
 
-    GetClientRect (hwnd, &rect);
+    GetClientRect (infoPtr->hwndSelf, &rect);
 
     x = rect.left;
     for (i = 0; i < infoPtr->uNumItem; i++) {
-        phdi = &infoPtr->items[HEADER_OrderToIndex(hwnd,i)];
+        phdi = &infoPtr->items[HEADER_OrderToIndex(infoPtr,i)];
         phdi->rect.top = rect.top;
         phdi->rect.bottom = rect.bottom;
         phdi->rect.left = x;
@@ -249,16 +245,14 @@ HEADER_SetItemBounds (HWND hwnd)
 }
 
 static LRESULT
-HEADER_Size (HWND hwnd)
+HEADER_Size (HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
     infoPtr->bRectsValid = FALSE;
 
     return 0;
 }
 
-static void HEADER_GetHotDividerRect(HWND hwnd, const HEADER_INFO *infoPtr, RECT *r)
+static void HEADER_GetHotDividerRect(const HEADER_INFO *infoPtr, RECT *r)
 {
     INT iDivider = infoPtr->iHotDivider;
     if (infoPtr->uNumItem > 0)
@@ -273,7 +267,7 @@ static void HEADER_GetHotDividerRect(HWND hwnd, const HEADER_INFO *infoPtr, RECT
         }
         else
         {
-            lpItem = &infoPtr->items[HEADER_OrderToIndex(hwnd, infoPtr->uNumItem-1)];
+            lpItem = &infoPtr->items[HEADER_OrderToIndex(infoPtr, infoPtr->uNumItem-1)];
             r->left  = lpItem->rect.right - HOT_DIVIDER_WIDTH/2;
             r->right = lpItem->rect.right + HOT_DIVIDER_WIDTH/2;
         }
@@ -283,7 +277,7 @@ static void HEADER_GetHotDividerRect(HWND hwnd, const HEADER_INFO *infoPtr, RECT
     else
     {
         RECT clientRect;
-        GetClientRect(hwnd, &clientRect);
+        GetClientRect(infoPtr->hwndSelf, &clientRect);
         *r = clientRect;
         r->right = r->left + HOT_DIVIDER_WIDTH/2;
     }
@@ -291,13 +285,12 @@ static void HEADER_GetHotDividerRect(HWND hwnd, const HEADER_INFO *infoPtr, RECT
 
 
 static INT
-HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags)
+HEADER_DrawItem (HEADER_INFO *infoPtr, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *phdi = &infoPtr->items[iItem];
     RECT r;
     INT  oldBkMode;
-    HTHEME theme = GetWindowTheme (hwnd);
+    HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
     NMCUSTOMDRAW nmcd;
 
     TRACE("DrawItem(iItem %d bHotTrack %d unicode flag %d)\n", iItem, bHotTrack, (infoPtr->nNotifyFormat == NFR_UNICODE));
@@ -308,7 +301,7 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
 
     /* Set the colors before sending NM_CUSTOMDRAW so that it can change them */
     SetTextColor(hdc, (bHotTrack && !theme) ? COLOR_HIGHLIGHT : COLOR_BTNTEXT);
-    SetBkColor(hdc, GetSysColor(COLOR_3DFACE));
+    SetBkColor(hdc, comctl32_color.clr3dFace);
 
     if (lCDFlags & CDRF_NOTIFYITEMDRAW && !(phdi->fmt & HDF_OWNERDRAW))
     {
@@ -321,7 +314,7 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
         nmcd.uItemState   = phdi->bDown ? CDIS_SELECTED : 0;
         nmcd.lItemlParam  = phdi->lParam;
 
-        lCDItemFlags = HEADER_SendNotify(hwnd, NM_CUSTOMDRAW, (NMHDR *)&nmcd);
+        lCDItemFlags = HEADER_SendNotify(infoPtr, NM_CUSTOMDRAW, (NMHDR *)&nmcd);
         if (lCDItemFlags & CDRF_SKIPDEFAULT)
             return phdi->rect.right;
     }
@@ -337,7 +330,7 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
     else {
         HBRUSH hbr;
     
-        if (GetWindowLongW (hwnd, GWL_STYLE) & HDS_BUTTONS) {
+        if (infoPtr->dwStyle & HDS_BUTTONS) {
             if (phdi->bDown) {
                 DrawEdge (hdc, &r, BDR_RAISEDOUTER,
                             BF_RECT | BF_FLAT | BF_MIDDLE | BF_ADJUST);
@@ -362,11 +355,11 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
 	DRAWITEMSTRUCT dis;
 
 	dis.CtlType    = ODT_HEADER;
-	dis.CtlID      = GetWindowLongPtrW (hwnd, GWLP_ID);
+	dis.CtlID      = GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_ID);
 	dis.itemID     = iItem;
 	dis.itemAction = ODA_DRAWENTIRE;
 	dis.itemState  = phdi->bDown ? ODS_SELECTED : 0;
-	dis.hwndItem   = hwnd;
+	dis.hwndItem   = infoPtr->hwndSelf;
 	dis.hDC        = hdc;
 	dis.rcItem     = phdi->rect;
 	dis.itemData   = phdi->lParam;
@@ -384,7 +377,7 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
 	     cw, tw, iw, bw;
 	BITMAP bmp;
 
-        HEADER_PrepareCallbackItems(hwnd, iItem, HDI_TEXT|HDI_IMAGE);
+        HEADER_PrepareCallbackItems(infoPtr, iItem, HDI_TEXT|HDI_IMAGE);
 	cw = tw = iw = bw = 0;
 	rw = r.right - r.left;
 	rh = r.bottom - r.top;
@@ -458,7 +451,7 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
 	}
 
 	if (iw || bw) {
-	    HDC hClipDC = GetDC(hwnd);
+	    HDC hClipDC = GetDC(infoPtr->hwndSelf);
 	    HRGN hClipRgn = CreateRectRgn(r.left, r.top, r.right, r.bottom);
 	    SelectClipRgn(hClipDC, hClipRgn);
 	    
@@ -477,7 +470,7 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
 	    }
 
 	    DeleteObject(hClipRgn);
-	    ReleaseDC(hwnd, hClipDC);
+	    ReleaseDC(infoPtr->hwndSelf, hClipDC);
 	}
         
 	if (((phdi->fmt & HDF_STRING)
@@ -499,36 +492,34 @@ HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack, LRESULT lCDFlags
 }
 
 static void
-HEADER_DrawHotDivider(HWND hwnd, HDC hdc)
+HEADER_DrawHotDivider(const HEADER_INFO *infoPtr, HDC hdc)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HBRUSH brush;
     RECT r;
     
-    HEADER_GetHotDividerRect(hwnd, infoPtr, &r);
-    brush = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
+    HEADER_GetHotDividerRect(infoPtr, &r);
+    brush = CreateSolidBrush(comctl32_color.clrHighlight);
     FillRect(hdc, &r, brush);
     DeleteObject(brush);
 }
 
 static void
-HEADER_Refresh (HWND hwnd, HDC hdc)
+HEADER_Refresh (HEADER_INFO *infoPtr, HDC hdc)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HFONT hFont, hOldFont;
     RECT rect, rcRest;
     HBRUSH hbrBk;
     UINT i;
     INT x;
     LRESULT lCDFlags;
-    HTHEME theme = GetWindowTheme (hwnd);
+    HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
 
     if (!infoPtr->bRectsValid)
-        HEADER_SetItemBounds(hwnd);
+        HEADER_SetItemBounds(infoPtr);
 
     /* get rect for the bar, adjusted for the border */
-    GetClientRect (hwnd, &rect);
-    lCDFlags = HEADER_SendCtrlCustomDraw(hwnd, CDDS_PREPAINT, hdc, &rect);
+    GetClientRect (infoPtr->hwndSelf, &rect);
+    lCDFlags = HEADER_SendCtrlCustomDraw(infoPtr, CDDS_PREPAINT, hdc, &rect);
     
     if (infoPtr->bDragging)
 	ImageList_DragShowNolock(FALSE);
@@ -544,9 +535,9 @@ HEADER_Refresh (HWND hwnd, HDC hdc)
 
     x = rect.left;
     for (i = 0; x <= rect.right && i < infoPtr->uNumItem; i++) {
-        int idx = HEADER_OrderToIndex(hwnd,i);
+        int idx = HEADER_OrderToIndex(infoPtr,i);
         if (RectVisible(hdc, &infoPtr->items[idx].rect))
-            HEADER_DrawItem(hwnd, hdc, idx, infoPtr->iHotItem == idx, lCDFlags);
+            HEADER_DrawItem(infoPtr, hdc, idx, infoPtr->iHotItem == idx, lCDFlags);
         x = infoPtr->items[idx].rect.right;
     }
 
@@ -557,7 +548,7 @@ HEADER_Refresh (HWND hwnd, HDC hdc)
             DrawThemeBackground(theme, hdc, HP_HEADERITEM, HIS_NORMAL, &rcRest, NULL);
         }
         else {
-            if (GetWindowLongW (hwnd, GWL_STYLE) & HDS_BUTTONS)
+            if (infoPtr->dwStyle & HDS_BUTTONS)
                 DrawEdge (hdc, &rcRest, EDGE_RAISED, BF_TOP|BF_LEFT|BF_BOTTOM|BF_SOFT|BF_MIDDLE);
             else
                 DrawEdge (hdc, &rcRest, EDGE_ETCHED, BF_BOTTOM|BF_MIDDLE);
@@ -565,39 +556,36 @@ HEADER_Refresh (HWND hwnd, HDC hdc)
     }
     
     if (infoPtr->iHotDivider != -1)
-        HEADER_DrawHotDivider(hwnd, hdc);
+        HEADER_DrawHotDivider(infoPtr, hdc);
 
     if (infoPtr->bDragging)
 	ImageList_DragShowNolock(TRUE);
     SelectObject (hdc, hOldFont);
     
     if (lCDFlags & CDRF_NOTIFYPOSTPAINT)
-        HEADER_SendCtrlCustomDraw(hwnd, CDDS_POSTPAINT, hdc, &rect);
+        HEADER_SendCtrlCustomDraw(infoPtr, CDDS_POSTPAINT, hdc, &rect);
 }
 
 
 static void
-HEADER_RefreshItem (HWND hwnd, INT iItem)
+HEADER_RefreshItem (HEADER_INFO *infoPtr, INT iItem)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
     if (!infoPtr->bRectsValid)
-        HEADER_SetItemBounds(hwnd);
+        HEADER_SetItemBounds(infoPtr);
 
-    InvalidateRect(hwnd, &infoPtr->items[iItem].rect, FALSE);
+    InvalidateRect(infoPtr->hwndSelf, &infoPtr->items[iItem].rect, FALSE);
 }
 
 
 static void
-HEADER_InternalHitTest (HWND hwnd, const POINT *lpPt, UINT *pFlags, INT *pItem)
+HEADER_InternalHitTest (const HEADER_INFO *infoPtr, const POINT *lpPt, UINT *pFlags, INT *pItem)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     RECT rect, rcTest;
     UINT iCount;
     INT width;
     BOOL bNoWidth;
 
-    GetClientRect (hwnd, &rect);
+    GetClientRect (infoPtr->hwndSelf, &rect);
 
     *pFlags = 0;
     bNoWidth = FALSE;
@@ -625,19 +613,19 @@ HEADER_InternalHitTest (HWND hwnd, const POINT *lpPt, UINT *pFlags, INT *pItem)
 			TRACE("ON HEADER %d\n", iCount);
 			return;
 		    }
-                    if (HEADER_IndexToOrder(hwnd, iCount) > 0) {
+                    if (HEADER_IndexToOrder(infoPtr, iCount) > 0) {
 			rcTest = rect;
 			rcTest.right = rcTest.left + DIVIDER_WIDTH;
 			if (PtInRect (&rcTest, *lpPt)) {
 			    if (bNoWidth) {
 				*pFlags |= HHT_ONDIVOPEN;
-                                *pItem = HEADER_PrevItem(hwnd, iCount);
+                                *pItem = HEADER_PrevItem(infoPtr, iCount);
 				TRACE("ON DIVOPEN %d\n", *pItem);
 				return;
 			    }
 			    else {
 				*pFlags |= HHT_ONDIVIDER;
-                                *pItem = HEADER_PrevItem(hwnd, iCount);
+                                *pItem = HEADER_PrevItem(infoPtr, iCount);
 				TRACE("ON DIVIDER %d\n", *pItem);
 				return;
 			    }
@@ -711,13 +699,13 @@ HEADER_InternalHitTest (HWND hwnd, const POINT *lpPt, UINT *pFlags, INT *pItem)
 
 
 static void
-HEADER_DrawTrackLine (HWND hwnd, HDC hdc, INT x)
+HEADER_DrawTrackLine (const HEADER_INFO *infoPtr, HDC hdc, INT x)
 {
     RECT rect;
     HPEN hOldPen;
     INT  oldRop;
 
-    GetClientRect (hwnd, &rect);
+    GetClientRect (infoPtr->hwndSelf, &rect);
 
     hOldPen = SelectObject (hdc, GetStockObject (BLACK_PEN));
     oldRop = SetROP2 (hdc, R2_XORPEN);
@@ -775,12 +763,10 @@ static UINT HEADER_NotifyCodeWtoA(UINT code)
 }
 
 static LRESULT
-HEADER_SendNotify(HWND hwnd, UINT code, NMHDR *nmhdr)
+HEADER_SendNotify(const HEADER_INFO *infoPtr, UINT code, NMHDR *nmhdr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
-    nmhdr->hwndFrom = hwnd;
-    nmhdr->idFrom   = GetWindowLongPtrW (hwnd, GWLP_ID);
+    nmhdr->hwndFrom = infoPtr->hwndSelf;
+    nmhdr->idFrom   = GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_ID);
     nmhdr->code     = code;
 
     return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY,
@@ -788,14 +774,14 @@ HEADER_SendNotify(HWND hwnd, UINT code, NMHDR *nmhdr)
 }
 
 static BOOL
-HEADER_SendSimpleNotify (HWND hwnd, UINT code)
+HEADER_SendSimpleNotify (const HEADER_INFO *infoPtr, UINT code)
 {
     NMHDR nmhdr;
-    return (BOOL)HEADER_SendNotify(hwnd, code, &nmhdr);
+    return (BOOL)HEADER_SendNotify(infoPtr, code, &nmhdr);
 }
 
 static LRESULT
-HEADER_SendCtrlCustomDraw(HWND hwnd, DWORD dwDrawStage, HDC hdc, const RECT *rect)
+HEADER_SendCtrlCustomDraw(const HEADER_INFO *infoPtr, DWORD dwDrawStage, HDC hdc, const RECT *rect)
 {
     NMCUSTOMDRAW nm;
     nm.dwDrawStage = dwDrawStage;
@@ -805,13 +791,12 @@ HEADER_SendCtrlCustomDraw(HWND hwnd, DWORD dwDrawStage, HDC hdc, const RECT *rec
     nm.uItemState = 0;
     nm.lItemlParam = 0;
 
-    return HEADER_SendNotify(hwnd, NM_CUSTOMDRAW, (NMHDR *)&nm);
+    return HEADER_SendNotify(infoPtr, NM_CUSTOMDRAW, (NMHDR *)&nm);
 }
 
 static BOOL
-HEADER_SendNotifyWithHDItemT(HWND hwnd, UINT code, INT iItem, HDITEMW *lpItem)
+HEADER_SendNotifyWithHDItemT(const HEADER_INFO *infoPtr, UINT code, INT iItem, HDITEMW *lpItem)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     NMHEADERW nmhdr;
     
     if (infoPtr->nNotifyFormat != NFR_UNICODE)
@@ -820,13 +805,12 @@ HEADER_SendNotifyWithHDItemT(HWND hwnd, UINT code, INT iItem, HDITEMW *lpItem)
     nmhdr.iButton = 0;
     nmhdr.pitem = lpItem;
 
-    return (BOOL)HEADER_SendNotify(hwnd, code, (NMHDR *)&nmhdr);
+    return (BOOL)HEADER_SendNotify(infoPtr, code, (NMHDR *)&nmhdr);
 }
 
 static BOOL
-HEADER_SendNotifyWithIntFieldT(HWND hwnd, UINT code, INT iItem, INT mask, INT iValue)
+HEADER_SendNotifyWithIntFieldT(const HEADER_INFO *infoPtr, UINT code, INT iItem, INT mask, INT iValue)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HDITEMW nmitem;
 
     /* copying only the iValue should be ok but to make the code more robust we copy everything */
@@ -852,7 +836,7 @@ HEADER_SendNotifyWithIntFieldT(HWND hwnd, UINT code, INT iItem, INT mask, INT iV
 	    ERR("invalid mask value 0x%x\n", iValue);
     }
 
-    return HEADER_SendNotifyWithHDItemT(hwnd, code, iItem, &nmitem);
+    return HEADER_SendNotifyWithHDItemT(infoPtr, code, iItem, &nmitem);
 }
 
 /**
@@ -871,9 +855,8 @@ HEADER_SendNotifyWithIntFieldT(HWND hwnd, UINT code, INT iItem, INT mask, INT iV
  * @return TRUE on success, else FALSE
  */
 static BOOL
-HEADER_PrepareCallbackItems(HWND hwnd, INT iItem, INT reqMask)
+HEADER_PrepareCallbackItems(const HEADER_INFO *infoPtr, INT iItem, INT reqMask)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *lpItem = &infoPtr->items[iItem];
     DWORD mask = reqMask & lpItem->callbackMask;
     NMHDDISPINFOW dispInfo;
@@ -889,8 +872,8 @@ HEADER_PrepareCallbackItems(HWND hwnd, INT iItem, INT reqMask)
     }
     
     memset(&dispInfo, 0, sizeof(NMHDDISPINFOW));
-    dispInfo.hdr.hwndFrom = hwnd;
-    dispInfo.hdr.idFrom   = GetWindowLongPtrW (hwnd, GWLP_ID);
+    dispInfo.hdr.hwndFrom = infoPtr->hwndSelf;
+    dispInfo.hdr.idFrom   = GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_ID);
     if (infoPtr->nNotifyFormat == NFR_UNICODE)
     {
         dispInfo.hdr.code = HDN_GETDISPINFOW;
@@ -967,9 +950,8 @@ HEADER_FreeCallbackItems(HEADER_ITEM *lpItem)
 }
 
 static LRESULT
-HEADER_CreateDragImage (HWND hwnd, WPARAM wParam)
+HEADER_CreateDragImage (HEADER_INFO *infoPtr, INT iItem)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
     HEADER_ITEM *lpItem;
     HIMAGELIST himl;
     HBITMAP hMemory, hOldBitmap;
@@ -980,13 +962,13 @@ HEADER_CreateDragImage (HWND hwnd, WPARAM wParam)
     int height, width;
     HFONT hFont;
     
-    if (wParam >= infoPtr->uNumItem)
+    if (iItem >= infoPtr->uNumItem)
         return FALSE;
 
     if (!infoPtr->bRectsValid)
-    	HEADER_SetItemBounds(hwnd);
+        HEADER_SetItemBounds(infoPtr);
 
-    lpItem = &infoPtr->items[wParam];
+    lpItem = &infoPtr->items[iItem];
     width = lpItem->rect.right - lpItem->rect.left;
     height = lpItem->rect.bottom - lpItem->rect.top;
     
@@ -999,11 +981,11 @@ HEADER_CreateDragImage (HWND hwnd, WPARAM wParam)
     hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject(SYSTEM_FONT);
     SelectObject(hMemoryDC, hFont);
 
-    GetClientRect(hwnd, &rc);
-    lCDFlags = HEADER_SendCtrlCustomDraw(hwnd, CDDS_PREPAINT, hMemoryDC, &rc);
-    HEADER_DrawItem(hwnd, hMemoryDC, wParam, FALSE, lCDFlags);
+    GetClientRect(infoPtr->hwndSelf, &rc);
+    lCDFlags = HEADER_SendCtrlCustomDraw(infoPtr, CDDS_PREPAINT, hMemoryDC, &rc);
+    HEADER_DrawItem(infoPtr, hMemoryDC, iItem, FALSE, lCDFlags);
     if (lCDFlags & CDRF_NOTIFYPOSTPAINT)
-        HEADER_SendCtrlCustomDraw(hwnd, CDDS_POSTPAINT, hMemoryDC, &rc);
+        HEADER_SendCtrlCustomDraw(infoPtr, CDDS_POSTPAINT, hMemoryDC, &rc);
     
     hMemory = SelectObject(hMemoryDC, hOldBitmap);
     DeleteDC(hMemoryDC);
@@ -1018,9 +1000,8 @@ HEADER_CreateDragImage (HWND hwnd, WPARAM wParam)
 }
 
 static LRESULT
-HEADER_SetHotDivider(HWND hwnd, WPARAM wParam, LPARAM lParam)
+HEADER_SetHotDivider(HEADER_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
     INT iDivider;
     RECT r;
     
@@ -1030,7 +1011,7 @@ HEADER_SetHotDivider(HWND hwnd, WPARAM wParam, LPARAM lParam)
         UINT flags;
         pt.x = (INT)(SHORT)LOWORD(lParam);
         pt.y = 0;
-        HEADER_InternalHitTest (hwnd, &pt, &flags, &iDivider);
+        HEADER_InternalHitTest (infoPtr, &pt, &flags, &iDivider);
         
         if (flags & HHT_TOLEFT)
             iDivider = 0;
@@ -1040,7 +1021,7 @@ HEADER_SetHotDivider(HWND hwnd, WPARAM wParam, LPARAM lParam)
         {
             HEADER_ITEM *lpItem = &infoPtr->items[iDivider];
             if (pt.x > (lpItem->rect.left+lpItem->rect.right)/2)
-                iDivider = HEADER_NextItem(hwnd, iDivider);
+                iDivider = HEADER_NextItem(infoPtr, iDivider);
         }
     }
     else
@@ -1054,24 +1035,22 @@ HEADER_SetHotDivider(HWND hwnd, WPARAM wParam, LPARAM lParam)
     {
         if (infoPtr->iHotDivider != -1)
         {
-            HEADER_GetHotDividerRect(hwnd, infoPtr, &r);
-            InvalidateRect(hwnd, &r, FALSE);
+            HEADER_GetHotDividerRect(infoPtr, &r);
+            InvalidateRect(infoPtr->hwndSelf, &r, FALSE);
         }
         infoPtr->iHotDivider = iDivider;
         if (iDivider != -1)
         {
-            HEADER_GetHotDividerRect(hwnd, infoPtr, &r);
-            InvalidateRect(hwnd, &r, FALSE);
+            HEADER_GetHotDividerRect(infoPtr, &r);
+            InvalidateRect(infoPtr->hwndSelf, &r, FALSE);
         }
     }
     return iDivider;
 }
 
 static LRESULT
-HEADER_DeleteItem (HWND hwnd, WPARAM wParam)
+HEADER_DeleteItem (HEADER_INFO *infoPtr, INT iItem)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
-    INT iItem = (INT)wParam;
     INT iOrder;
     UINT i;
 
@@ -1105,26 +1084,23 @@ HEADER_DeleteItem (HWND hwnd, WPARAM wParam)
     for (i = 0; i < infoPtr->uNumItem; i++)
        TRACE("%d: order=%d, iOrder=%d, ->iOrder=%d\n", i, infoPtr->order[i], infoPtr->items[i].iOrder, infoPtr->items[infoPtr->order[i]].iOrder);
 
-    HEADER_SetItemBounds (hwnd);
-    InvalidateRect(hwnd, NULL, FALSE);
+    HEADER_SetItemBounds (infoPtr);
+    InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
 
     return TRUE;
 }
 
 
 static LRESULT
-HEADER_GetImageList (HWND hwnd)
+HEADER_GetImageList (const HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
     return (LRESULT)infoPtr->himl;
 }
 
 
 static LRESULT
-HEADER_GetItemT (HWND hwnd, INT nItem, LPHDITEMW phdi, BOOL bUnicode)
+HEADER_GetItemT (const HEADER_INFO *infoPtr, INT nItem, LPHDITEMW phdi, BOOL bUnicode)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *lpItem;
     UINT mask;
 
@@ -1147,7 +1123,7 @@ HEADER_GetItemT (HWND hwnd, INT nItem, LPHDITEMW phdi, BOOL bUnicode)
     }
     
     lpItem = &infoPtr->items[nItem];
-    HEADER_PrepareCallbackItems(hwnd, nItem, mask);
+    HEADER_PrepareCallbackItems(infoPtr, nItem, mask);
 
     if (mask & HDI_BITMAP)
         phdi->hbm = lpItem->hbm;
@@ -1181,20 +1157,15 @@ HEADER_GetItemT (HWND hwnd, INT nItem, LPHDITEMW phdi, BOOL bUnicode)
 
 
 static inline LRESULT
-HEADER_GetItemCount (HWND hwnd)
+HEADER_GetItemCount (const HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     return infoPtr->uNumItem;
 }
 
 
 static LRESULT
-HEADER_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
+HEADER_GetItemRect (const HEADER_INFO *infoPtr, INT iItem, LPRECT lpRect)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-    INT iItem = (INT)wParam;
-    LPRECT lpRect = (LPRECT)lParam;
-
     if ((iItem < 0) || (iItem >= (INT)infoPtr->uNumItem))
         return FALSE;
 
@@ -1208,12 +1179,9 @@ HEADER_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-HEADER_GetOrderArray(HWND hwnd, WPARAM wParam, LPARAM lParam)
+HEADER_GetOrderArray(const HEADER_INFO *infoPtr, INT size, LPINT order)
 {
-    LPINT order = (LPINT) lParam;
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
-    if ((unsigned int)wParam <infoPtr->uNumItem)
+    if ((UINT)size <infoPtr->uNumItem)
       return FALSE;
 
     memcpy(order, infoPtr->order, infoPtr->uNumItem * sizeof(INT));
@@ -1221,40 +1189,35 @@ HEADER_GetOrderArray(HWND hwnd, WPARAM wParam, LPARAM lParam)
 }
 
 static LRESULT
-HEADER_SetOrderArray(HWND hwnd, WPARAM wParam, LPARAM lParam)
+HEADER_SetOrderArray(HEADER_INFO *infoPtr, INT size, LPINT order)
 {
-    int i;
-    LPINT order = (LPINT) lParam;
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
+    INT i;
     HEADER_ITEM *lpItem;
 
-    if ((unsigned int)wParam <infoPtr->uNumItem)
+    if ((UINT)size <infoPtr->uNumItem)
       return FALSE;
     memcpy(infoPtr->order, order, infoPtr->uNumItem * sizeof(INT));
-    for (i=0; i<(int)wParam; i++)
+    for (i=0; i<size; i++)
       {
         lpItem = &infoPtr->items[*order++];
 	lpItem->iOrder=i;
       }
     infoPtr->bRectsValid=0;
-    InvalidateRect(hwnd, NULL, FALSE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
     return TRUE;
 }
 
 static inline LRESULT
-HEADER_GetUnicodeFormat (HWND hwnd)
+HEADER_GetUnicodeFormat (const HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     return (infoPtr->nNotifyFormat == NFR_UNICODE);
 }
 
 
 static LRESULT
-HEADER_HitTest (HWND hwnd, LPARAM lParam)
+HEADER_HitTest (const HEADER_INFO *infoPtr, LPHDHITTESTINFO phti)
 {
-    LPHDHITTESTINFO phti = (LPHDHITTESTINFO)lParam;
-
-    HEADER_InternalHitTest (hwnd, &phti->pt, &phti->flags, &phti->iItem);
+    HEADER_InternalHitTest (infoPtr, &phti->pt, &phti->flags, &phti->iItem);
 
     if (phti->flags == HHT_NOWHERE)
         return -1;
@@ -1264,9 +1227,8 @@ HEADER_HitTest (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_InsertItemT (HWND hwnd, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
+HEADER_InsertItemT (HEADER_INFO *infoPtr, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *lpItem;
     INT       iOrder;
     UINT      i;
@@ -1324,25 +1286,22 @@ HEADER_InsertItemT (HWND hwnd, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
     if (phdi->mask & HDI_IMAGE)
         lpItem->fmt |= HDF_IMAGE;
 
-    HEADER_SetItemBounds (hwnd);
-    InvalidateRect(hwnd, NULL, FALSE);
+    HEADER_SetItemBounds (infoPtr);
+    InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
 
     return nItem;
 }
 
 
 static LRESULT
-HEADER_Layout (HWND hwnd, LPARAM lParam)
+HEADER_Layout (HEADER_INFO *infoPtr, LPHDLAYOUT lpLayout)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-    LPHDLAYOUT lpLayout = (LPHDLAYOUT)lParam;
-
-    lpLayout->pwpos->hwnd = hwnd;
+    lpLayout->pwpos->hwnd = infoPtr->hwndSelf;
     lpLayout->pwpos->hwndInsertAfter = 0;
     lpLayout->pwpos->x = lpLayout->prc->left;
     lpLayout->pwpos->y = lpLayout->prc->top;
     lpLayout->pwpos->cx = lpLayout->prc->right - lpLayout->prc->left;
-    if (GetWindowLongW (hwnd, GWL_STYLE) & HDS_HIDDEN)
+    if (infoPtr->dwStyle & HDS_HIDDEN)
         lpLayout->pwpos->cy = 0;
     else {
         lpLayout->pwpos->cy = infoPtr->nHeight;
@@ -1361,9 +1320,8 @@ HEADER_Layout (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_SetImageList (HWND hwnd, HIMAGELIST himl)
+HEADER_SetImageList (HEADER_INFO *infoPtr, HIMAGELIST himl)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HIMAGELIST himlOld;
 
     TRACE("(himl %p)\n", himl);
@@ -1377,28 +1335,24 @@ HEADER_SetImageList (HWND hwnd, HIMAGELIST himl)
 
 
 static LRESULT
-HEADER_GetBitmapMargin(HWND hwnd)
+HEADER_GetBitmapMargin(const HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
-    
     return infoPtr->iMargin;
 }
 
 static LRESULT
-HEADER_SetBitmapMargin(HWND hwnd, WPARAM wParam)
+HEADER_SetBitmapMargin(HEADER_INFO *infoPtr, INT iMargin)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     INT oldMargin = infoPtr->iMargin;
 
-    infoPtr->iMargin = (INT)wParam;
+    infoPtr->iMargin = iMargin;
 
     return oldMargin;
 }
 
 static LRESULT
-HEADER_SetItemT (HWND hwnd, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
+HEADER_SetItemT (HEADER_INFO *infoPtr, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *lpItem;
     HDITEMW hdNotify;
     void *pvScratch;
@@ -1411,7 +1365,7 @@ HEADER_SetItemT (HWND hwnd, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
     TRACE("[nItem=%d]\n", nItem);
 
     HEADER_CopyHDItemForNotify(infoPtr, &hdNotify, phdi, bUnicode, &pvScratch);
-    if (HEADER_SendNotifyWithHDItemT(hwnd, HDN_ITEMCHANGINGW, nItem, &hdNotify))
+    if (HEADER_SendNotifyWithHDItemT(infoPtr, HDN_ITEMCHANGINGW, nItem, &hdNotify))
     {
         Free(pvScratch);
 	return FALSE;
@@ -1424,20 +1378,19 @@ HEADER_SetItemT (HWND hwnd, INT nItem, const HDITEMW *phdi, BOOL bUnicode)
         if (phdi->iOrder >= 0 && phdi->iOrder < infoPtr->uNumItem)
             HEADER_ChangeItemOrder(infoPtr, nItem, phdi->iOrder);
 
-    HEADER_SendNotifyWithHDItemT(hwnd, HDN_ITEMCHANGEDW, nItem, &hdNotify);
+    HEADER_SendNotifyWithHDItemT(infoPtr, HDN_ITEMCHANGEDW, nItem, &hdNotify);
 
-    HEADER_SetItemBounds (hwnd);
+    HEADER_SetItemBounds (infoPtr);
 
-    InvalidateRect(hwnd, NULL, FALSE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
 
     Free(pvScratch);
     return TRUE;
 }
 
 static inline LRESULT
-HEADER_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
+HEADER_SetUnicodeFormat (HEADER_INFO *infoPtr, WPARAM wParam)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     BOOL bTemp = (infoPtr->nNotifyFormat == NFR_UNICODE);
 
     infoPtr->nNotifyFormat = ((BOOL)wParam ? NFR_UNICODE : NFR_ANSI);
@@ -1447,7 +1400,7 @@ HEADER_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-HEADER_Create (HWND hwnd, LPARAM lParam)
+HEADER_Create (HWND hwnd, LPCREATESTRUCTW lpcs)
 {
     HEADER_INFO *infoPtr;
     TEXTMETRICW tm;
@@ -1457,7 +1410,8 @@ HEADER_Create (HWND hwnd, LPARAM lParam)
     infoPtr = Alloc (sizeof(HEADER_INFO));
     SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
 
-    infoPtr->hwndNotify = ((LPCREATESTRUCTA)lParam)->hwndParent;
+    infoPtr->hwndSelf = hwnd;
+    infoPtr->hwndNotify = lpcs->hwndParent;
     infoPtr->uNumItem = 0;
     infoPtr->hFont = 0;
     infoPtr->items = 0;
@@ -1468,6 +1422,7 @@ HEADER_Create (HWND hwnd, LPARAM lParam)
     infoPtr->hcurDivopen = LoadCursorW (COMCTL32_hModule, MAKEINTRESOURCEW(IDC_DIVIDEROPEN));
     infoPtr->bPressed  = FALSE;
     infoPtr->bTracking = FALSE;
+    infoPtr->dwStyle = lpcs->style;
     infoPtr->iMoveItem = 0;
     infoPtr->himl = 0;
     infoPtr->iHotItem = -1;
@@ -1490,17 +1445,16 @@ HEADER_Create (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_Destroy (HWND hwnd)
+HEADER_Destroy (HEADER_INFO *infoPtr)
 {
-    HTHEME theme = GetWindowTheme(hwnd);
+    HTHEME theme = GetWindowTheme(infoPtr->hwndSelf);
     CloseThemeData(theme);
     return 0;
 }
 
 static LRESULT
-HEADER_NCDestroy (HWND hwnd)
+HEADER_NCDestroy (HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     HEADER_ITEM *lpItem;
     INT nItem;
 
@@ -1517,7 +1471,7 @@ HEADER_NCDestroy (HWND hwnd)
     if (infoPtr->himl)
       ImageList_Destroy (infoPtr->himl);
 
-    SetWindowLongPtrW (hwnd, 0, 0);
+    SetWindowLongPtrW (infoPtr->hwndSelf, 0, 0);
     Free (infoPtr);
 
     return 0;
@@ -1525,10 +1479,8 @@ HEADER_NCDestroy (HWND hwnd)
 
 
 static inline LRESULT
-HEADER_GetFont (HWND hwnd)
+HEADER_GetFont (const HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
     return (LRESULT)infoPtr->hFont;
 }
 
@@ -1544,41 +1496,39 @@ HEADER_IsDragDistance(const HEADER_INFO *infoPtr, const POINT *pt)
 }
 
 static LRESULT
-HEADER_LButtonDblClk (HWND hwnd, LPARAM lParam)
+HEADER_LButtonDblClk (HEADER_INFO *infoPtr, INT x, INT y)
 {
     POINT pt;
     UINT  flags;
     INT   nItem;
 
-    pt.x = (short)LOWORD(lParam);
-    pt.y = (short)HIWORD(lParam);
-    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
+    pt.x = x;
+    pt.y = y;
+    HEADER_InternalHitTest (infoPtr, &pt, &flags, &nItem);
 
-    if ((GetWindowLongW (hwnd, GWL_STYLE) & HDS_BUTTONS) && (flags == HHT_ONHEADER))
-        HEADER_SendNotifyWithHDItemT(hwnd, HDN_ITEMDBLCLICKW, nItem, NULL);
+    if ((infoPtr->dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER))
+        HEADER_SendNotifyWithHDItemT(infoPtr, HDN_ITEMDBLCLICKW, nItem, NULL);
     else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN))
-        HEADER_SendNotifyWithHDItemT(hwnd, HDN_DIVIDERDBLCLICKW, nItem, NULL);
+        HEADER_SendNotifyWithHDItemT(infoPtr, HDN_DIVIDERDBLCLICKW, nItem, NULL);
 
     return 0;
 }
 
 
 static LRESULT
-HEADER_LButtonDown (HWND hwnd, LPARAM lParam)
+HEADER_LButtonDown (HEADER_INFO *infoPtr, INT x, INT y)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-    DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
     POINT pt;
     UINT  flags;
     INT   nItem;
     HDC   hdc;
 
-    pt.x = (short)LOWORD(lParam);
-    pt.y = (short)HIWORD(lParam);
-    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
+    pt.x = x;
+    pt.y = y;
+    HEADER_InternalHitTest (infoPtr, &pt, &flags, &nItem);
 
-    if ((dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER)) {
-	SetCapture (hwnd);
+    if ((infoPtr->dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER)) {
+	SetCapture (infoPtr->hwndSelf);
 	infoPtr->bCaptured = TRUE;
 	infoPtr->bPressed  = TRUE;
 	infoPtr->bDragging = FALSE;
@@ -1588,27 +1538,27 @@ HEADER_LButtonDown (HWND hwnd, LPARAM lParam)
 	infoPtr->items[nItem].bDown = TRUE;
 
 	/* Send WM_CUSTOMDRAW */
-	hdc = GetDC (hwnd);
-	HEADER_RefreshItem (hwnd, nItem);
-	ReleaseDC (hwnd, hdc);
+	hdc = GetDC (infoPtr->hwndSelf);
+	HEADER_RefreshItem (infoPtr, nItem);
+	ReleaseDC (infoPtr->hwndSelf, hdc);
 
 	TRACE("Pressed item %d!\n", nItem);
     }
     else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN)) {
         INT iCurrWidth = infoPtr->items[nItem].cxy;
-        if (!HEADER_SendNotifyWithIntFieldT(hwnd, HDN_BEGINTRACKW, nItem, HDI_WIDTH, iCurrWidth))
+        if (!HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_BEGINTRACKW, nItem, HDI_WIDTH, iCurrWidth))
         {
-	    SetCapture (hwnd);
+	    SetCapture (infoPtr->hwndSelf);
 	    infoPtr->bCaptured = TRUE;
 	    infoPtr->bTracking = TRUE;
 	    infoPtr->iMoveItem = nItem;
 	    infoPtr->xTrackOffset = infoPtr->items[nItem].rect.right - pt.x;
 
-	    if (!(dwStyle & HDS_FULLDRAG)) {
+	    if (!(infoPtr->dwStyle & HDS_FULLDRAG)) {
 		infoPtr->xOldTrack = infoPtr->items[nItem].rect.right;
-		hdc = GetDC (hwnd);
-		HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
-		ReleaseDC (hwnd, hdc);
+		hdc = GetDC (infoPtr->hwndSelf);
+		HEADER_DrawTrackLine (infoPtr, hdc, infoPtr->xOldTrack);
+		ReleaseDC (infoPtr->hwndSelf, hdc);
 	    }
 
 	    TRACE("Begin tracking item %d!\n", nItem);
@@ -1620,18 +1570,16 @@ HEADER_LButtonDown (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_LButtonUp (HWND hwnd, LPARAM lParam)
+HEADER_LButtonUp (HEADER_INFO *infoPtr, INT x, INT y)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-    DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
     POINT pt;
     UINT  flags;
     INT   nItem;
     HDC   hdc;
 
-    pt.x = (INT)(SHORT)LOWORD(lParam);
-    pt.y = (INT)(SHORT)HIWORD(lParam);
-    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
+    pt.x = x;
+    pt.y = y;
+    HEADER_InternalHitTest (infoPtr, &pt, &flags, &nItem);
 
     if (infoPtr->bPressed) {
 	if (infoPtr->bDragging)
@@ -1649,32 +1597,32 @@ HEADER_LButtonUp (HWND hwnd, LPARAM lParam)
                 iNewOrder = infoPtr->uNumItem-1;
             else
 	    {
-                iNewOrder = HEADER_IndexToOrder(hwnd, infoPtr->iHotDivider);
+                iNewOrder = HEADER_IndexToOrder(infoPtr, infoPtr->iHotDivider);
                 if (iNewOrder > lpItem->iOrder)
                     iNewOrder--;
             }
 
             if (iNewOrder != -1 &&
-                !HEADER_SendNotifyWithIntFieldT(hwnd, HDN_ENDDRAG, infoPtr->iMoveItem, HDI_ORDER, iNewOrder))
+                !HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_ENDDRAG, infoPtr->iMoveItem, HDI_ORDER, iNewOrder))
             {
                 HEADER_ChangeItemOrder(infoPtr, infoPtr->iMoveItem, iNewOrder);
 		infoPtr->bRectsValid = FALSE;
-		InvalidateRect(hwnd, NULL, FALSE);
+		InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
 	    }
 	    else
-		InvalidateRect(hwnd, &infoPtr->items[infoPtr->iMoveItem].rect, FALSE);
+		InvalidateRect(infoPtr->hwndSelf, &infoPtr->items[infoPtr->iMoveItem].rect, FALSE);
 
             infoPtr->bDragging = FALSE;
-            HEADER_SetHotDivider(hwnd, FALSE, -1);
+            HEADER_SetHotDivider(infoPtr, FALSE, -1);
 	}
-	else if (!(dwStyle&HDS_DRAGDROP) || !HEADER_IsDragDistance(infoPtr, &pt))
+	else if (!(infoPtr->dwStyle & HDS_DRAGDROP) || !HEADER_IsDragDistance(infoPtr, &pt))
 	{
 	    infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
-	    hdc = GetDC (hwnd);
-	    HEADER_RefreshItem (hwnd, infoPtr->iMoveItem);
-	    ReleaseDC (hwnd, hdc);
+	    hdc = GetDC (infoPtr->hwndSelf);
+	    HEADER_RefreshItem (infoPtr, infoPtr->iMoveItem);
+	    ReleaseDC (infoPtr->hwndSelf, hdc);
 
-	    HEADER_SendNotifyWithHDItemT(hwnd, HDN_ITEMCLICKW, infoPtr->iMoveItem, NULL);
+	    HEADER_SendNotifyWithHDItemT(infoPtr, HDN_ITEMCLICKW, infoPtr->iMoveItem, NULL);
 	}
 
 	TRACE("Released item %d!\n", infoPtr->iMoveItem);
@@ -1687,28 +1635,28 @@ HEADER_LButtonUp (HWND hwnd, LPARAM lParam)
 	TRACE("End tracking item %d!\n", infoPtr->iMoveItem);
 	infoPtr->bTracking = FALSE;
 
-        HEADER_SendNotifyWithIntFieldT(hwnd, HDN_ENDTRACKW, infoPtr->iMoveItem, HDI_WIDTH, iNewWidth);
+        HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_ENDTRACKW, infoPtr->iMoveItem, HDI_WIDTH, iNewWidth);
 
-        if (!(dwStyle & HDS_FULLDRAG)) {
-	    hdc = GetDC (hwnd);
-	    HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
-            ReleaseDC (hwnd, hdc);
+        if (!(infoPtr->dwStyle & HDS_FULLDRAG)) {
+	    hdc = GetDC (infoPtr->hwndSelf);
+	    HEADER_DrawTrackLine (infoPtr, hdc, infoPtr->xOldTrack);
+            ReleaseDC (infoPtr->hwndSelf, hdc);
         }
           
-        if (!HEADER_SendNotifyWithIntFieldT(hwnd, HDN_ITEMCHANGINGW, infoPtr->iMoveItem, HDI_WIDTH, iNewWidth))
+        if (!HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_ITEMCHANGINGW, infoPtr->iMoveItem, HDI_WIDTH, iNewWidth))
         {
             infoPtr->items[infoPtr->iMoveItem].cxy = iNewWidth;
-            HEADER_SendNotifyWithIntFieldT(hwnd, HDN_ITEMCHANGEDW, infoPtr->iMoveItem, HDI_WIDTH, iNewWidth);
+            HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_ITEMCHANGEDW, infoPtr->iMoveItem, HDI_WIDTH, iNewWidth);
         }
 
-	HEADER_SetItemBounds (hwnd);
-	InvalidateRect(hwnd, NULL, TRUE);
+	HEADER_SetItemBounds (infoPtr);
+	InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     }
 
     if (infoPtr->bCaptured) {
 	infoPtr->bCaptured = FALSE;
 	ReleaseCapture ();
-	HEADER_SendSimpleNotify (hwnd, NM_RELEASEDCAPTURE);
+	HEADER_SendSimpleNotify (infoPtr, NM_RELEASEDCAPTURE);
     }
 
     return 0;
@@ -1716,10 +1664,8 @@ HEADER_LButtonUp (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_NotifyFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
+HEADER_NotifyFormat (HEADER_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-
     switch (lParam)
     {
 	case NF_QUERY:
@@ -1728,7 +1674,7 @@ HEADER_NotifyFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	case NF_REQUERY:
 	    infoPtr->nNotifyFormat =
 		SendMessageW ((HWND)wParam, WM_NOTIFYFORMAT,
-			      (WPARAM)hwnd, (LPARAM)NF_QUERY);
+			      (WPARAM)infoPtr->hwndSelf, (LPARAM)NF_QUERY);
 	    return infoPtr->nNotifyFormat;
     }
 
@@ -1736,39 +1682,36 @@ HEADER_NotifyFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
 }
 
 static LRESULT
-HEADER_MouseLeave (HWND hwnd)
+HEADER_MouseLeave (HEADER_INFO *infoPtr)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     /* Reset hot-tracked item when mouse leaves control. */
     INT oldHotItem = infoPtr->iHotItem;
-    HDC hdc = GetDC (hwnd);
+    HDC hdc = GetDC (infoPtr->hwndSelf);
 
     infoPtr->iHotItem = -1;
-    if (oldHotItem != -1) HEADER_RefreshItem (hwnd, oldHotItem);
-    ReleaseDC (hwnd, hdc);
+    if (oldHotItem != -1) HEADER_RefreshItem (infoPtr, oldHotItem);
+    ReleaseDC (infoPtr->hwndSelf, hdc);
 
     return 0;
 }
 
 
 static LRESULT
-HEADER_MouseMove (HWND hwnd, LPARAM lParam)
+HEADER_MouseMove (HEADER_INFO *infoPtr, LPARAM lParam)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
-    DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
     POINT pt;
     UINT  flags;
     INT   nItem, nWidth;
     HDC   hdc;
     /* With theming, hottracking is always enabled */
     BOOL  hotTrackEnabled =
-        ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK))
-        || (GetWindowTheme (hwnd) != NULL);
+        ((infoPtr->dwStyle & HDS_BUTTONS) && (infoPtr->dwStyle & HDS_HOTTRACK))
+        || (GetWindowTheme (infoPtr->hwndSelf) != NULL);
     INT oldHotItem = infoPtr->iHotItem;
 
     pt.x = (INT)(SHORT)LOWORD(lParam);
     pt.y = (INT)(SHORT)HIWORD(lParam);
-    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
+    HEADER_InternalHitTest (infoPtr, &pt, &flags, &nItem);
 
     if (hotTrackEnabled) {
 	if (flags & (HHT_ONHEADER | HHT_ONDIVIDER | HHT_ONDIVOPEN))
@@ -1779,12 +1722,12 @@ HEADER_MouseMove (HWND hwnd, LPARAM lParam)
 
     if (infoPtr->bCaptured) {
         /* check if we should drag the header */
-	if (infoPtr->bPressed && !infoPtr->bDragging && dwStyle&HDS_DRAGDROP
+	if (infoPtr->bPressed && !infoPtr->bDragging && (infoPtr->dwStyle & HDS_DRAGDROP)
 	    && HEADER_IsDragDistance(infoPtr, &pt))
 	{
-            if (!HEADER_SendNotifyWithHDItemT(hwnd, HDN_BEGINDRAG, infoPtr->iMoveItem, NULL))
+            if (!HEADER_SendNotifyWithHDItemT(infoPtr, HDN_BEGINDRAG, infoPtr->iMoveItem, NULL))
 	    {
-		HIMAGELIST hDragItem = (HIMAGELIST)HEADER_CreateDragImage(hwnd, infoPtr->iMoveItem);
+		HIMAGELIST hDragItem = (HIMAGELIST)HEADER_CreateDragImage(infoPtr, infoPtr->iMoveItem);
 		if (hDragItem != NULL)
 		{
 		    HEADER_ITEM *lpItem = &infoPtr->items[infoPtr->iMoveItem];
@@ -1802,9 +1745,9 @@ HEADER_MouseMove (HWND hwnd, LPARAM lParam)
 	    POINT drag;
 	    drag.x = pt.x;
 	    drag.y = 0;
-	    ClientToScreen(hwnd, &drag);
+	    ClientToScreen(infoPtr->hwndSelf, &drag);
 	    ImageList_DragMove(drag.x, drag.y);
-	    HEADER_SetHotDivider(hwnd, TRUE, lParam);
+	    HEADER_SetHotDivider(infoPtr, TRUE, lParam);
 	}
 	
 	if (infoPtr->bPressed && !infoPtr->bDragging) {
@@ -1814,18 +1757,18 @@ HEADER_MouseMove (HWND hwnd, LPARAM lParam)
 	    else
 		infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
             if (oldState != infoPtr->items[infoPtr->iMoveItem].bDown) {
-                hdc = GetDC (hwnd);
-	        HEADER_RefreshItem (hwnd, infoPtr->iMoveItem);
-	        ReleaseDC (hwnd, hdc);
+                hdc = GetDC (infoPtr->hwndSelf);
+	        HEADER_RefreshItem (infoPtr, infoPtr->iMoveItem);
+	        ReleaseDC (infoPtr->hwndSelf, hdc);
             }
 
 	    TRACE("Moving pressed item %d!\n", infoPtr->iMoveItem);
 	}
 	else if (infoPtr->bTracking) {
-	    if (dwStyle & HDS_FULLDRAG) {
+	    if (infoPtr->dwStyle & HDS_FULLDRAG) {
                 HEADER_ITEM *lpItem = &infoPtr->items[infoPtr->iMoveItem];
                 nWidth = pt.x - lpItem->rect.left + infoPtr->xTrackOffset;
-                if (!HEADER_SendNotifyWithIntFieldT(hwnd, HDN_ITEMCHANGINGW, infoPtr->iMoveItem, HDI_WIDTH, nWidth))
+                if (!HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_ITEMCHANGINGW, infoPtr->iMoveItem, HDI_WIDTH, nWidth))
 		{
                     INT nOldWidth = lpItem->rect.right - lpItem->rect.left;
                     RECT rcClient;
@@ -1833,30 +1776,30 @@ HEADER_MouseMove (HWND hwnd, LPARAM lParam)
                     
                     if (nWidth < 0) nWidth = 0;
                     infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
-                    HEADER_SetItemBounds(hwnd);
+                    HEADER_SetItemBounds(infoPtr);
                     
-                    GetClientRect(hwnd, &rcClient);
+                    GetClientRect(infoPtr->hwndSelf, &rcClient);
                     rcScroll = rcClient;
                     rcScroll.left = lpItem->rect.left + nOldWidth;
-                    ScrollWindowEx(hwnd, nWidth - nOldWidth, 0, &rcScroll, &rcClient, NULL, NULL, 0);
-                    InvalidateRect(hwnd, &lpItem->rect, FALSE);
-                    UpdateWindow(hwnd);
+                    ScrollWindowEx(infoPtr->hwndSelf, nWidth - nOldWidth, 0, &rcScroll, &rcClient, NULL, NULL, 0);
+                    InvalidateRect(infoPtr->hwndSelf, &lpItem->rect, FALSE);
+                    UpdateWindow(infoPtr->hwndSelf);
                     
-                    HEADER_SendNotifyWithIntFieldT(hwnd, HDN_ITEMCHANGEDW, infoPtr->iMoveItem, HDI_WIDTH, nWidth);
+                    HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_ITEMCHANGEDW, infoPtr->iMoveItem, HDI_WIDTH, nWidth);
 		}
 	    }
 	    else {
                 INT iTrackWidth;
-		hdc = GetDC (hwnd);
-		HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
+		hdc = GetDC (infoPtr->hwndSelf);
+		HEADER_DrawTrackLine (infoPtr, hdc, infoPtr->xOldTrack);
 		infoPtr->xOldTrack = pt.x + infoPtr->xTrackOffset;
 		if (infoPtr->xOldTrack < infoPtr->items[infoPtr->iMoveItem].rect.left)
 		    infoPtr->xOldTrack = infoPtr->items[infoPtr->iMoveItem].rect.left;
-		HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
-		ReleaseDC (hwnd, hdc);
+		HEADER_DrawTrackLine (infoPtr, hdc, infoPtr->xOldTrack);
+		ReleaseDC (infoPtr->hwndSelf, hdc);
                 iTrackWidth = infoPtr->xOldTrack - infoPtr->items[infoPtr->iMoveItem].rect.left;
                 /* FIXME: should stop tracking if HDN_TRACK returns TRUE */
-                HEADER_SendNotifyWithIntFieldT(hwnd, HDN_TRACKW, infoPtr->iMoveItem, HDI_WIDTH, iTrackWidth);
+                HEADER_SendNotifyWithIntFieldT(infoPtr, HDN_TRACKW, infoPtr->iMoveItem, HDI_WIDTH, iTrackWidth);
 	    }
 
 	    TRACE("Tracking item %d!\n", infoPtr->iMoveItem);
@@ -1866,14 +1809,14 @@ HEADER_MouseMove (HWND hwnd, LPARAM lParam)
     if (hotTrackEnabled) {
         TRACKMOUSEEVENT tme;
         if (oldHotItem != infoPtr->iHotItem && !infoPtr->bDragging) {
-	    hdc = GetDC (hwnd);
-	    if (oldHotItem != -1) HEADER_RefreshItem (hwnd, oldHotItem);
-	    if (infoPtr->iHotItem != -1) HEADER_RefreshItem (hwnd, infoPtr->iHotItem);
-	    ReleaseDC (hwnd, hdc);
+	    hdc = GetDC (infoPtr->hwndSelf);
+	    if (oldHotItem != -1) HEADER_RefreshItem (infoPtr, oldHotItem);
+	    if (infoPtr->iHotItem != -1) HEADER_RefreshItem (infoPtr, infoPtr->iHotItem);
+	    ReleaseDC (infoPtr->hwndSelf, hdc);
         }
         tme.cbSize = sizeof( tme );
         tme.dwFlags = TME_LEAVE;
-        tme.hwndTrack = hwnd;
+        tme.hwndTrack = infoPtr->hwndSelf;
         TrackMouseEvent( &tme );
     }
 
@@ -1882,45 +1825,44 @@ HEADER_MouseMove (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_Paint (HWND hwnd, WPARAM wParam)
+HEADER_Paint (HEADER_INFO *infoPtr, HDC hdcParam)
 {
     HDC hdc;
     PAINTSTRUCT ps;
 
-    hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
-    HEADER_Refresh (hwnd, hdc);
-    if(!wParam)
-	EndPaint (hwnd, &ps);
+    hdc = hdcParam==0 ? BeginPaint (infoPtr->hwndSelf, &ps) : hdcParam;
+    HEADER_Refresh (infoPtr, hdc);
+    if(!hdcParam)
+	EndPaint (infoPtr->hwndSelf, &ps);
     return 0;
 }
 
 
 static LRESULT
-HEADER_RButtonUp (HWND hwnd, LPARAM lParam)
+HEADER_RButtonUp (HEADER_INFO *infoPtr, INT x, INT y)
 {
     BOOL bRet;
     POINT pt;
 
-    pt.x = (short)LOWORD(lParam);
-    pt.y = (short)HIWORD(lParam);
+    pt.x = x;
+    pt.y = y;
 
     /* Send a Notify message */
-    bRet = HEADER_SendSimpleNotify (hwnd, NM_RCLICK);
+    bRet = HEADER_SendSimpleNotify (infoPtr, NM_RCLICK);
 
     /* Change to screen coordinate for WM_CONTEXTMENU */
-    ClientToScreen(hwnd, &pt);
+    ClientToScreen(infoPtr->hwndSelf, &pt);
 
     /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
-    SendMessageW( hwnd, WM_CONTEXTMENU, (WPARAM) hwnd, MAKELPARAM(pt.x, pt.y));
+    SendMessageW( infoPtr->hwndSelf, WM_CONTEXTMENU, (WPARAM) infoPtr->hwndSelf, MAKELPARAM(pt.x, pt.y));
 
     return bRet;
 }
 
 
 static LRESULT
-HEADER_SetCursor (HWND hwnd, LPARAM lParam)
+HEADER_SetCursor (HEADER_INFO *infoPtr, LPARAM lParam)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     POINT pt;
     UINT  flags;
     INT   nItem;
@@ -1928,9 +1870,9 @@ HEADER_SetCursor (HWND hwnd, LPARAM lParam)
     TRACE("code=0x%X  id=0x%X\n", LOWORD(lParam), HIWORD(lParam));
 
     GetCursorPos (&pt);
-    ScreenToClient (hwnd, &pt);
+    ScreenToClient (infoPtr->hwndSelf, &pt);
 
-    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
+    HEADER_InternalHitTest (infoPtr, &pt, &flags, &nItem);
 
     if (flags == HHT_ONDIVIDER)
         SetCursor (infoPtr->hcurDivider);
@@ -1944,19 +1886,16 @@ HEADER_SetCursor (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-HEADER_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
+HEADER_SetFont (HEADER_INFO *infoPtr, HFONT hFont, WORD Redraw)
 {
-    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
     TEXTMETRICW tm;
-    HFONT hFont, hOldFont;
+    HFONT hOldFont;
     HDC hdc;
 
-    infoPtr->hFont = (HFONT)wParam;
-
-    hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
+    infoPtr->hFont = hFont;
 
     hdc = GetDC (0);
-    hOldFont = SelectObject (hdc, hFont);
+    hOldFont = SelectObject (hdc, infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT));
     GetTextMetricsW (hdc, &tm);
     infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
     SelectObject (hdc, hOldFont);
@@ -1964,32 +1903,45 @@ HEADER_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
     infoPtr->bRectsValid = FALSE;
 
-    if (lParam) {
-        InvalidateRect(hwnd, NULL, FALSE);
+    if (Redraw) {
+        InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
     }
 
     return 0;
 }
 
-static LRESULT HEADER_SetRedraw(HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT HEADER_SetRedraw(HEADER_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
     /* ignoring the InvalidateRect calls is handled by user32. But some apps expect
      * that we invalidate the header and this has to be done manually  */
     LRESULT ret;
 
-    ret = DefWindowProcW(hwnd, WM_SETREDRAW, wParam, lParam);
+    ret = DefWindowProcW(infoPtr->hwndSelf, WM_SETREDRAW, wParam, lParam);
     if (wParam)
-        InvalidateRect(hwnd, NULL, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     return ret;
 }
 
-/* Update the theme handle after a theme change */
-static LRESULT HEADER_ThemeChanged(HWND hwnd)
+static INT HEADER_StyleChanged(HEADER_INFO *infoPtr, WPARAM wStyleType,
+                               const LPSTYLESTRUCT lpss)
 {
-    HTHEME theme = GetWindowTheme(hwnd);
+    TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
+          wStyleType, lpss->styleOld, lpss->styleNew);
+
+    if (wStyleType != GWL_STYLE) return 0;
+
+    infoPtr->dwStyle = lpss->styleNew;
+
+    return 0;
+}
+
+/* Update the theme handle after a theme change */
+static LRESULT HEADER_ThemeChanged(const HEADER_INFO *infoPtr)
+{
+    HTHEME theme = GetWindowTheme(infoPtr->hwndSelf);
     CloseThemeData(theme);
-    OpenThemeData(hwnd, themeClass);
-    InvalidateRect(hwnd, NULL, FALSE);
+    OpenThemeData(infoPtr->hwndSelf, themeClass);
+    InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
     return 0;
 }
 
@@ -1997,84 +1949,86 @@ static LRESULT HEADER_ThemeChanged(HWND hwnd)
 static LRESULT WINAPI
 HEADER_WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
+    HEADER_INFO *infoPtr = (HEADER_INFO *)GetWindowLongPtrW(hwnd, 0);
+
     TRACE("hwnd=%p msg=%x wparam=%lx lParam=%lx\n", hwnd, msg, wParam, lParam);
-    if (!HEADER_GetInfoPtr (hwnd) && (msg != WM_CREATE))
+    if (!infoPtr && (msg != WM_CREATE))
 	return DefWindowProcW (hwnd, msg, wParam, lParam);
     switch (msg) {
 /*	case HDM_CLEARFILTER: */
 
 	case HDM_CREATEDRAGIMAGE:
-	    return HEADER_CreateDragImage (hwnd, wParam);
+	    return HEADER_CreateDragImage (infoPtr, (INT)wParam);
 
 	case HDM_DELETEITEM:
-	    return HEADER_DeleteItem (hwnd, wParam);
+	    return HEADER_DeleteItem (infoPtr, (INT)wParam);
 
 /*	case HDM_EDITFILTER: */
 
 	case HDM_GETBITMAPMARGIN:
-	    return HEADER_GetBitmapMargin(hwnd);
+	    return HEADER_GetBitmapMargin(infoPtr);
 
 	case HDM_GETIMAGELIST:
-	    return HEADER_GetImageList (hwnd);
+	    return HEADER_GetImageList (infoPtr);
 
 	case HDM_GETITEMA:
 	case HDM_GETITEMW:
-	    return HEADER_GetItemT (hwnd, (INT)wParam, (LPHDITEMW)lParam, msg == HDM_GETITEMW);
+	    return HEADER_GetItemT (infoPtr, (INT)wParam, (LPHDITEMW)lParam, msg == HDM_GETITEMW);
 
 	case HDM_GETITEMCOUNT:
-	    return HEADER_GetItemCount (hwnd);
+	    return HEADER_GetItemCount (infoPtr);
 
 	case HDM_GETITEMRECT:
-	    return HEADER_GetItemRect (hwnd, wParam, lParam);
+	    return HEADER_GetItemRect (infoPtr, (INT)wParam, (LPRECT)lParam);
 
 	case HDM_GETORDERARRAY:
-	    return HEADER_GetOrderArray(hwnd, wParam, lParam);
+	    return HEADER_GetOrderArray(infoPtr, (INT)wParam, (LPINT)lParam);
 
 	case HDM_GETUNICODEFORMAT:
-	    return HEADER_GetUnicodeFormat (hwnd);
+	    return HEADER_GetUnicodeFormat (infoPtr);
 
 	case HDM_HITTEST:
-	    return HEADER_HitTest (hwnd, lParam);
+	    return HEADER_HitTest (infoPtr, (LPHDHITTESTINFO)lParam);
 
 	case HDM_INSERTITEMA:
 	case HDM_INSERTITEMW:
-	    return HEADER_InsertItemT (hwnd, (INT)wParam, (LPHDITEMW)lParam, msg == HDM_INSERTITEMW);
+	    return HEADER_InsertItemT (infoPtr, (INT)wParam, (LPHDITEMW)lParam, msg == HDM_INSERTITEMW);
 
 	case HDM_LAYOUT:
-	    return HEADER_Layout (hwnd, lParam);
+	    return HEADER_Layout (infoPtr, (LPHDLAYOUT)lParam);
 
 	case HDM_ORDERTOINDEX:
-	    return HEADER_OrderToIndex(hwnd, wParam);
+	    return HEADER_OrderToIndex(infoPtr, (INT)wParam);
 
 	case HDM_SETBITMAPMARGIN:
-	    return HEADER_SetBitmapMargin(hwnd, wParam);
+	    return HEADER_SetBitmapMargin(infoPtr, (INT)wParam);
 
 /*	case HDM_SETFILTERCHANGETIMEOUT: */
 
         case HDM_SETHOTDIVIDER:
-            return HEADER_SetHotDivider(hwnd, wParam, lParam);
+            return HEADER_SetHotDivider(infoPtr, wParam, lParam);
 
 	case HDM_SETIMAGELIST:
-	    return HEADER_SetImageList (hwnd, (HIMAGELIST)lParam);
+	    return HEADER_SetImageList (infoPtr, (HIMAGELIST)lParam);
 
 	case HDM_SETITEMA:
 	case HDM_SETITEMW:
-	    return HEADER_SetItemT (hwnd, (INT)wParam, (LPHDITEMW)lParam, msg == HDM_SETITEMW);
+	    return HEADER_SetItemT (infoPtr, (INT)wParam, (LPHDITEMW)lParam, msg == HDM_SETITEMW);
 
 	case HDM_SETORDERARRAY:
-	    return HEADER_SetOrderArray(hwnd, wParam, lParam);
+	    return HEADER_SetOrderArray(infoPtr, (INT)wParam, (LPINT)lParam);
 
 	case HDM_SETUNICODEFORMAT:
-	    return HEADER_SetUnicodeFormat (hwnd, wParam);
+	    return HEADER_SetUnicodeFormat (infoPtr, wParam);
 
         case WM_CREATE:
-            return HEADER_Create (hwnd, lParam);
+            return HEADER_Create (hwnd, (LPCREATESTRUCTW)lParam);
 
         case WM_DESTROY:
-            return HEADER_Destroy (hwnd);
+            return HEADER_Destroy (infoPtr);
 
         case WM_NCDESTROY:
-            return HEADER_NCDestroy (hwnd);
+            return HEADER_NCDestroy (infoPtr);
 
         case WM_ERASEBKGND:
             return 1;
@@ -2083,47 +2037,54 @@ HEADER_WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             return DLGC_WANTTAB | DLGC_WANTARROWS;
 
         case WM_GETFONT:
-            return HEADER_GetFont (hwnd);
+            return HEADER_GetFont (infoPtr);
 
         case WM_LBUTTONDBLCLK:
-            return HEADER_LButtonDblClk (hwnd, lParam);
+            return HEADER_LButtonDblClk (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
 
         case WM_LBUTTONDOWN:
-            return HEADER_LButtonDown (hwnd, lParam);
+            return HEADER_LButtonDown (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
 
         case WM_LBUTTONUP:
-            return HEADER_LButtonUp (hwnd, lParam);
+            return HEADER_LButtonUp (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
 
         case WM_MOUSELEAVE:
-            return HEADER_MouseLeave (hwnd);
+            return HEADER_MouseLeave (infoPtr);
 
         case WM_MOUSEMOVE:
-            return HEADER_MouseMove (hwnd, lParam);
+            return HEADER_MouseMove (infoPtr, lParam);
 
 	case WM_NOTIFYFORMAT:
-            return HEADER_NotifyFormat (hwnd, wParam, lParam);
+            return HEADER_NotifyFormat (infoPtr, wParam, lParam);
 
 	case WM_SIZE:
-	    return HEADER_Size (hwnd);
+	    return HEADER_Size (infoPtr);
 
         case WM_THEMECHANGED:
-            return HEADER_ThemeChanged (hwnd);
+            return HEADER_ThemeChanged (infoPtr);
 
         case WM_PRINTCLIENT:
         case WM_PAINT:
-            return HEADER_Paint (hwnd, wParam);
+            return HEADER_Paint (infoPtr, (HDC)wParam);
 
         case WM_RBUTTONUP:
-            return HEADER_RButtonUp (hwnd, lParam);
+            return HEADER_RButtonUp (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
 
         case WM_SETCURSOR:
-            return HEADER_SetCursor (hwnd, lParam);
+            return HEADER_SetCursor (infoPtr, lParam);
 
         case WM_SETFONT:
-            return HEADER_SetFont (hwnd, wParam, lParam);
+            return HEADER_SetFont (infoPtr, (HFONT)wParam, (WORD)lParam);
 
         case WM_SETREDRAW:
-            return HEADER_SetRedraw(hwnd, wParam, lParam);
+            return HEADER_SetRedraw(infoPtr, wParam, lParam);
+
+        case WM_STYLECHANGED:
+            return HEADER_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
+
+        case WM_SYSCOLORCHANGE:
+            COMCTL32_RefreshSysColors();
+            return 0;
 
         default:
             if ((msg >= WM_USER) && (msg < WM_APP) && !COMCTL32_IsReflectedMessage(msg))
diff --git a/reactos/dll/win32/comctl32/ipaddress.c b/reactos/dll/win32/comctl32/ipaddress.c
index a90f6e99365..42ac703b287 100644
--- a/reactos/dll/win32/comctl32/ipaddress.c
+++ b/reactos/dll/win32/comctl32/ipaddress.c
@@ -158,18 +158,18 @@ static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
     GetClientRect (infoPtr->Self, &rect);
 
     if (infoPtr->Enabled) {
-        bgCol = COLOR_WINDOW;
-        fgCol = COLOR_WINDOWTEXT;
+        bgCol = comctl32_color.clrWindow;
+        fgCol = comctl32_color.clrWindowText;
     } else {
-        bgCol = COLOR_3DFACE;
-        fgCol = COLOR_GRAYTEXT;
+        bgCol = comctl32_color.clr3dFace;
+        fgCol = comctl32_color.clrGrayText;
     }
     
     FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
     DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
     
-    SetBkColor  (hdc, GetSysColor(bgCol));
-    SetTextColor(hdc, GetSysColor(fgCol));
+    SetBkColor  (hdc, bgCol);
+    SetTextColor(hdc, fgCol);
 
     for (i = 0; i < 3; i++) {
         GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
@@ -595,6 +595,10 @@ IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 	    }
 	    break;
 
+        case WM_SYSCOLORCHANGE:
+            COMCTL32_RefreshSysColors();
+            return 0;
+
         case IPM_CLEARADDRESS:
             IPADDRESS_ClearAddress (infoPtr);
 	    break;
diff --git a/reactos/dll/win32/comctl32/monthcal.c b/reactos/dll/win32/comctl32/monthcal.c
index 15acf1f70bc..be4145164c2 100644
--- a/reactos/dll/win32/comctl32/monthcal.c
+++ b/reactos/dll/win32/comctl32/monthcal.c
@@ -456,7 +456,7 @@ static void MONTHCAL_Refresh(MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT
   SYSTEMTIME localtime;
   int startofprescal;
 
-  oldTextColor = SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
+  oldTextColor = SetTextColor(hdc, comctl32_color.clrWindowText);
 
   /* fill background */
   hbr = CreateSolidBrush (infoPtr->bk);
@@ -1926,12 +1926,12 @@ MONTHCAL_Create(HWND hwnd, LPARAM lParam)
   infoPtr->monthRange = 3;
   infoPtr->monthdayState = Alloc
                          (infoPtr->monthRange * sizeof(MONTHDAYSTATE));
-  infoPtr->titlebk     = GetSysColor(COLOR_ACTIVECAPTION);
-  infoPtr->titletxt    = GetSysColor(COLOR_WINDOW);
-  infoPtr->monthbk     = GetSysColor(COLOR_WINDOW);
-  infoPtr->trailingtxt = GetSysColor(COLOR_GRAYTEXT);
-  infoPtr->bk          = GetSysColor(COLOR_WINDOW);
-  infoPtr->txt	       = GetSysColor(COLOR_WINDOWTEXT);
+  infoPtr->titlebk     = comctl32_color.clrActiveCaption;
+  infoPtr->titletxt    = comctl32_color.clrWindow;
+  infoPtr->monthbk     = comctl32_color.clrWindow;
+  infoPtr->trailingtxt = comctl32_color.clrGrayText;
+  infoPtr->bk          = comctl32_color.clrWindow;
+  infoPtr->txt	       = comctl32_color.clrWindowText;
 
   /* set the current day for highlighing */
   infoPtr->minSel.wDay = infoPtr->todaysDate.wDay;
@@ -2082,6 +2082,10 @@ MONTHCAL_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
   case WM_DESTROY:
     return MONTHCAL_Destroy(infoPtr);
 
+  case WM_SYSCOLORCHANGE:
+    COMCTL32_RefreshSysColors();
+    return 0;
+
   default:
     if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
       ERR( "unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
diff --git a/reactos/dll/win32/comctl32/rebar.c b/reactos/dll/win32/comctl32/rebar.c
index 089da399cf2..982c8445daf 100644
--- a/reactos/dll/win32/comctl32/rebar.c
+++ b/reactos/dll/win32/comctl32/rebar.c
@@ -3190,8 +3190,8 @@ REBAR_NCCreate (HWND hwnd, LPARAM lParam)
     /* initialize info structure - initial values are 0 */
     infoPtr->clrBk = CLR_NONE;
     infoPtr->clrText = CLR_NONE;
-    infoPtr->clrBtnText = GetSysColor (COLOR_BTNTEXT);
-    infoPtr->clrBtnFace = GetSysColor (COLOR_BTNFACE);
+    infoPtr->clrBtnText = comctl32_color.clrBtnText;
+    infoPtr->clrBtnFace = comctl32_color.clrBtnFace;
     infoPtr->iOldBand = -1;
     infoPtr->ichevronhotBand = -2;
     infoPtr->iGrabbedBand = -1;
@@ -3720,10 +3720,9 @@ REBAR_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
         case WM_THEMECHANGED:
             return theme_changed (infoPtr);
 
-/*      case WM_SYSCOLORCHANGE: supported according to ControlSpy */
-/*      "Applications that have brushes using the existing system colors
-         should delete those brushes and recreate them using the new
-         system colors."  per MSDN                                */
+        case WM_SYSCOLORCHANGE:
+            COMCTL32_RefreshSysColors();
+            return 0;
 
 /*      case WM_VKEYTOITEM:     supported according to ControlSpy */
 /*	case WM_WININICHANGE: */
diff --git a/reactos/dll/win32/comctl32/status.c b/reactos/dll/win32/comctl32/status.c
index 17ba1e9123e..f7d203b0065 100644
--- a/reactos/dll/win32/comctl32/status.c
+++ b/reactos/dll/win32/comctl32/status.c
@@ -167,7 +167,7 @@ STATUSBAR_DrawSizeGrip (HTHEME theme, HDC hdc, LPRECT lpRect)
     pt.x = lpRect->right - 1;
     pt.y = lpRect->bottom - 1;
 
-    hPenFace = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_3DFACE ));
+    hPenFace = CreatePen( PS_SOLID, 1, comctl32_color.clr3dFace);
     hOldPen = SelectObject( hdc, hPenFace );
     MoveToEx (hdc, pt.x - 12, pt.y, NULL);
     LineTo (hdc, pt.x, pt.y);
@@ -176,7 +176,7 @@ STATUSBAR_DrawSizeGrip (HTHEME theme, HDC hdc, LPRECT lpRect)
     pt.x--;
     pt.y--;
 
-    hPenShadow = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_3DSHADOW ));
+    hPenShadow = CreatePen( PS_SOLID, 1, comctl32_color.clr3dShadow);
     SelectObject( hdc, hPenShadow );
     for (i = 1; i < 11; i += 4) {
 	MoveToEx (hdc, pt.x - i, pt.y, NULL);
@@ -186,7 +186,7 @@ STATUSBAR_DrawSizeGrip (HTHEME theme, HDC hdc, LPRECT lpRect)
 	LineTo (hdc, pt.x + 1, pt.y - i - 2);
     }
 
-    hPenHighlight = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_3DHIGHLIGHT ));
+    hPenHighlight = CreatePen( PS_SOLID, 1, comctl32_color.clr3dHilight);
     SelectObject( hdc, hPenHighlight );
     for (i = 3; i < 13; i += 4) {
 	MoveToEx (hdc, pt.x - i, pt.y, NULL);
@@ -1313,6 +1313,10 @@ StatusWindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 	    if (STATUSBAR_WMSize (infoPtr, (WORD)wParam)) return 0;
             return DefWindowProcW (hwnd, msg, wParam, lParam);
 
+        case WM_SYSCOLORCHANGE:
+            COMCTL32_RefreshSysColors();
+            return 0;
+
         case WM_THEMECHANGED:
             return theme_changed (infoPtr);
 
diff --git a/reactos/dll/win32/comctl32/syslink.c b/reactos/dll/win32/comctl32/syslink.c
index 8f48b4c53fd..1b89bc714aa 100644
--- a/reactos/dll/win32/comctl32/syslink.c
+++ b/reactos/dll/win32/comctl32/syslink.c
@@ -831,7 +831,7 @@ static LRESULT SYSLINK_Draw (const SYSLINK_INFO *infoPtr, HDC hdc)
 
     hOldFont = SelectObject(hdc, infoPtr->Font);
     OldTextColor = SetTextColor(hdc, infoPtr->TextColor);
-    OldBkColor = SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
+    OldBkColor = SetBkColor(hdc, comctl32_color.clrBtnFace);
     
     GetClientRect(infoPtr->Self, &rc);
     rc.right -= SL_RIGHTMARGIN + SL_LEFTMARGIN;
@@ -1729,9 +1729,9 @@ static LRESULT WINAPI SysLinkWindowProc(HWND hwnd, UINT message,
         infoPtr->Items = NULL;
         infoPtr->HasFocus = FALSE;
         infoPtr->MouseDownID = -1;
-        infoPtr->TextColor = GetSysColor(COLOR_WINDOWTEXT);
-        infoPtr->LinkColor = GetSysColor(COLOR_HIGHLIGHT);
-        infoPtr->VisitedColor = GetSysColor(COLOR_HIGHLIGHT);
+        infoPtr->TextColor = comctl32_color.clrWindowText;
+        infoPtr->LinkColor = comctl32_color.clrHighlight;
+        infoPtr->VisitedColor = comctl32_color.clrHighlight;
         infoPtr->BreakChar = ' ';
         TRACE("SysLink Ctrl creation, hwnd=%p\n", hwnd);
         SYSLINK_SetText(infoPtr, ((LPCREATESTRUCTW)lParam)->lpszName);
@@ -1746,6 +1746,10 @@ static LRESULT WINAPI SysLinkWindowProc(HWND hwnd, UINT message,
         Free (infoPtr);
         return 0;
 
+    case WM_SYSCOLORCHANGE:
+        COMCTL32_RefreshSysColors();
+        return 0;
+
     default:
 HandleDefaultMessage:
         if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
diff --git a/reactos/dll/win32/comctl32/tab.c b/reactos/dll/win32/comctl32/tab.c
index c2ab01e240d..b8846979c71 100644
--- a/reactos/dll/win32/comctl32/tab.c
+++ b/reactos/dll/win32/comctl32/tab.c
@@ -1668,7 +1668,7 @@ TAB_DrawItemInterior(const TAB_INFO *infoPtr, HDC hdc, INT iItem, RECT *drawRect
   /*
    * Text pen
    */
-  htextPen = CreatePen( PS_SOLID, 1, GetSysColor(COLOR_BTNTEXT) );
+  htextPen = CreatePen( PS_SOLID, 1, comctl32_color.clrBtnText );
   holdPen  = SelectObject(hdc, htextPen);
   hOldFont = SelectObject(hdc, infoPtr->hFont);
 
diff --git a/reactos/dll/win32/comctl32/toolbar.c b/reactos/dll/win32/comctl32/toolbar.c
index 867bac8fe6d..06bf2399fc6 100644
--- a/reactos/dll/win32/comctl32/toolbar.c
+++ b/reactos/dll/win32/comctl32/toolbar.c
@@ -217,7 +217,6 @@ typedef enum
 
 #define TOOLBAR_NOWHERE (-1)
 
-#define TOOLBAR_GetInfoPtr(hwnd) ((TOOLBAR_INFO *)GetWindowLongPtrW(hwnd,0))
 #define TOOLBAR_HasText(x, y) (TOOLBAR_GetText(x, y) ? TRUE : FALSE)
 #define TOOLBAR_HasDropDownArrows(exStyle) ((exStyle & TBSTYLE_EX_DRAWDDARROWS) ? TRUE : FALSE)
 
@@ -246,16 +245,13 @@ static HIMAGELIST TOOLBAR_GetImageList(const PIMLENTRY *pies, INT cies, INT id);
 static PIMLENTRY TOOLBAR_GetImageListEntry(const PIMLENTRY *pies, INT cies, INT id);
 static VOID TOOLBAR_DeleteImageList(PIMLENTRY **pies, INT *cies);
 static HIMAGELIST TOOLBAR_InsertImageList(PIMLENTRY **pies, INT *cies, HIMAGELIST himl, INT id);
-static LRESULT TOOLBAR_LButtonDown(HWND hwnd, WPARAM wParam, LPARAM lParam);
-static void TOOLBAR_SetHotItemEx (TOOLBAR_INFO *infoPtr, INT nHit, DWORD dwReason);
-static void TOOLBAR_LayoutToolbar(HWND hwnd);
-static LRESULT TOOLBAR_AutoSize(HWND hwnd);
+static LRESULT TOOLBAR_LButtonDown(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam);
+static void TOOLBAR_LayoutToolbar(TOOLBAR_INFO *infoPtr);
+static LRESULT TOOLBAR_AutoSize(TOOLBAR_INFO *infoPtr);
 static void TOOLBAR_CheckImageListIconSize(TOOLBAR_INFO *infoPtr);
 static void TOOLBAR_TooltipAddTool(const TOOLBAR_INFO *infoPtr, const TBUTTON_INFO *button);
 static void TOOLBAR_TooltipSetRect(const TOOLBAR_INFO *infoPtr, const TBUTTON_INFO *button);
 
-static LRESULT
-TOOLBAR_NotifyFormat(const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam);
 
 static inline int default_top_margin(const TOOLBAR_INFO *infoPtr)
 {
@@ -328,10 +324,10 @@ TOOLBAR_DumpToolbar(const TOOLBAR_INFO *iP, INT line)
 * function should be null.
 */
 static void
-TOOLBAR_CheckStyle (HWND hwnd, DWORD dwStyle)
+TOOLBAR_CheckStyle (const TOOLBAR_INFO *infoPtr, DWORD dwStyle)
 {
     if (dwStyle & TBSTYLE_REGISTERDROP)
-	FIXME("[%p] TBSTYLE_REGISTERDROP not implemented\n", hwnd);
+	FIXME("[%p] TBSTYLE_REGISTERDROP not implemented\n", infoPtr->hwndSelf);
 }
 
 
@@ -818,9 +814,8 @@ TOOLBAR_DrawSepDDArrow(const TOOLBAR_INFO *infoPtr, const NMTBCUSTOMDRAW *tbcd,
 
 /* draws a complete toolbar button */
 static void
-TOOLBAR_DrawButton (HWND hwnd, TBUTTON_INFO *btnPtr, HDC hdc, DWORD dwBaseCustDraw)
+TOOLBAR_DrawButton (const TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr, HDC hdc, DWORD dwBaseCustDraw)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     DWORD dwStyle = infoPtr->dwStyle;
     BOOL hasDropDownArrow = (TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle) &&
                             (btnPtr->fsStyle & BTNS_DROPDOWN)) ||
@@ -835,7 +830,7 @@ TOOLBAR_DrawButton (HWND hwnd, TBUTTON_INFO *btnPtr, HDC hdc, DWORD dwBaseCustDr
     INT oldBkMode;
     DWORD dwItemCustDraw;
     DWORD dwItemCDFlag;
-    HTHEME theme = GetWindowTheme (hwnd);
+    HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
 
     rc = btnPtr->rect;
     CopyRect (&rcArrow, &rc);
@@ -1081,9 +1076,8 @@ TOOLBAR_DrawButton (HWND hwnd, TBUTTON_INFO *btnPtr, HDC hdc, DWORD dwBaseCustDr
 
 
 static void
-TOOLBAR_Refresh (HWND hwnd, HDC hdc, const PAINTSTRUCT *ps)
+TOOLBAR_Refresh (TOOLBAR_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT i;
     RECT rcTemp, rcClient;
@@ -1117,7 +1111,7 @@ TOOLBAR_Refresh (HWND hwnd, HDC hdc, const PAINTSTRUCT *ps)
     ntfret = TOOLBAR_SendNotify(&tbcd.nmcd.hdr, infoPtr, NM_CUSTOMDRAW);
     dwBaseCustDraw = ntfret & 0xffff;
 
-    GetClientRect(hwnd, &rcClient);
+    GetClientRect(infoPtr->hwndSelf, &rcClient);
 
     /* redraw necessary buttons */
     btnPtr = infoPtr->buttons;
@@ -1136,7 +1130,7 @@ TOOLBAR_Refresh (HWND hwnd, HDC hdc, const PAINTSTRUCT *ps)
         bDraw &= IntersectRect(&rcTemp, &(ps->rcPaint), &(btnPtr->rect));
         bDraw = (btnPtr->fsState & TBSTATE_HIDDEN) ? FALSE : bDraw;
         if (bDraw)
-            TOOLBAR_DrawButton(hwnd, btnPtr, hdc, dwBaseCustDraw);
+            TOOLBAR_DrawButton(infoPtr, btnPtr, hdc, dwBaseCustDraw);
     }
 
     /* draw insert mark if required */
@@ -1221,9 +1215,8 @@ TOOLBAR_MeasureString(const TOOLBAR_INFO *infoPtr, const TBUTTON_INFO *btnPtr,
 * the largest height and width to caller.
 */
 static void
-TOOLBAR_CalcStrings (HWND hwnd, LPSIZE lpSize)
+TOOLBAR_CalcStrings (const TOOLBAR_INFO *infoPtr, LPSIZE lpSize)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT i;
     SIZE sz;
@@ -1236,7 +1229,7 @@ TOOLBAR_CalcStrings (HWND hwnd, LPSIZE lpSize)
     if (infoPtr->nMaxTextRows == 0)
         return;
 
-    hdc = GetDC (hwnd);
+    hdc = GetDC (infoPtr->hwndSelf);
     hOldFont = SelectObject (hdc, infoPtr->hFont);
 
     if (infoPtr->nNumButtons == 0 && infoPtr->nNumStrings > 0)
@@ -1260,7 +1253,7 @@ TOOLBAR_CalcStrings (HWND hwnd, LPSIZE lpSize)
     }
 
     SelectObject (hdc, hOldFont);
-    ReleaseDC (hwnd, hdc);
+    ReleaseDC (infoPtr->hwndSelf, hdc);
 
     TRACE("max string size %d x %d!\n", lpSize->cx, lpSize->cy);
 }
@@ -1281,9 +1274,8 @@ TOOLBAR_CalcStrings (HWND hwnd, LPSIZE lpSize)
 */
 
 static void
-TOOLBAR_WrapToolbar( HWND hwnd, DWORD dwStyle )
+TOOLBAR_WrapToolbar(TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT x, cx, i, j;
     RECT rc;
@@ -1292,24 +1284,24 @@ TOOLBAR_WrapToolbar( HWND hwnd, DWORD dwStyle )
     /* 	When the toolbar window style is not TBSTYLE_WRAPABLE,	*/
     /*	no layout is necessary. Applications may use this style */
     /*	to perform their own layout on the toolbar. 		*/
-    if( !(dwStyle & TBSTYLE_WRAPABLE) &&
+    if( !(infoPtr->dwStyle & TBSTYLE_WRAPABLE) &&
 	!(infoPtr->dwExStyle & TBSTYLE_EX_UNDOC1) )  return;
 
     btnPtr = infoPtr->buttons;
     x  = infoPtr->nIndent;
 
-    if (GetParent(hwnd))
+    if (GetParent(infoPtr->hwndSelf))
     {
         /* this can get the parents width, to know how far we can extend
          * this toolbar.  We cannot use its height, as there may be multiple
          * toolbars in a rebar control
          */
-        GetClientRect( GetParent(hwnd), &rc );
+        GetClientRect( GetParent(infoPtr->hwndSelf), &rc );
         infoPtr->nWidth = rc.right - rc.left;
     }
     else
     {
-        GetWindowRect( hwnd, &rc );
+        GetWindowRect( infoPtr->hwndSelf, &rc );
         infoPtr->nWidth = rc.right - rc.left;
     }
 
@@ -1615,13 +1607,12 @@ static inline SIZE TOOLBAR_MeasureButton(const TOOLBAR_INFO *infoPtr, SIZE sizeS
 * rect and calculates the new required toolbar window height.
 */
 static void
-TOOLBAR_CalcToolbar (HWND hwnd)
+TOOLBAR_CalcToolbar (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     SIZE  sizeString, sizeButton;
     BOOL validImageList = FALSE;
 
-    TOOLBAR_CalcStrings (hwnd, &sizeString);
+    TOOLBAR_CalcStrings (infoPtr, &sizeString);
 
     TOOLBAR_DumpToolbar (infoPtr, __LINE__);
 
@@ -1637,13 +1628,12 @@ TOOLBAR_CalcToolbar (HWND hwnd)
     if ( infoPtr->cxMax > 0 && infoPtr->nButtonWidth > infoPtr->cxMax )
         infoPtr->nButtonWidth = infoPtr->cxMax;
 
-    TOOLBAR_LayoutToolbar(hwnd);
+    TOOLBAR_LayoutToolbar(infoPtr);
 }
 
 static void
-TOOLBAR_LayoutToolbar(HWND hwnd)
+TOOLBAR_LayoutToolbar(TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     TBUTTON_INFO *btnPtr;
     SIZE sizeButton;
     INT i, nRows, nSepRows;
@@ -1652,7 +1642,7 @@ TOOLBAR_LayoutToolbar(HWND hwnd)
     BOOL validImageList = TOOLBAR_IsValidImageList(infoPtr, 0);
     BOOL hasDropDownArrows = TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle);
 
-    TOOLBAR_WrapToolbar(hwnd, infoPtr->dwStyle);
+    TOOLBAR_WrapToolbar(infoPtr);
 
     x  = infoPtr->nIndent;
     y  = infoPtr->iTopMargin;
@@ -1701,13 +1691,13 @@ TOOLBAR_LayoutToolbar(HWND hwnd)
 	      HDC hdc;
 	      HFONT hOldFont;
 
-	      hdc = GetDC (hwnd);
+	      hdc = GetDC (infoPtr->hwndSelf);
 	      hOldFont = SelectObject (hdc, infoPtr->hFont);
 
               TOOLBAR_MeasureString(infoPtr, btnPtr, hdc, &sz);
 
 	      SelectObject (hdc, hOldFont);
-	      ReleaseDC (hwnd, hdc);
+	      ReleaseDC (infoPtr->hwndSelf, hdc);
 
               sizeButton = TOOLBAR_MeasureButton(infoPtr, sz,
                   TOOLBAR_IsValidBitmapIndex(infoPtr, infoPtr->buttons[i].iBitmap),
@@ -1780,9 +1770,8 @@ TOOLBAR_LayoutToolbar(HWND hwnd)
 
 
 static INT
-TOOLBAR_InternalHitTest (HWND hwnd, const POINT *lpPt)
+TOOLBAR_InternalHitTest (TOOLBAR_INFO *infoPtr, const POINT *lpPt)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT i;
 
@@ -1858,10 +1847,10 @@ TOOLBAR_InternalInsertButtonsT(TOOLBAR_INFO *infoPtr, INT iIndex, UINT nAddButto
     }
 
     if (infoPtr->nNumStrings > 0 || fHasString)
-        TOOLBAR_CalcToolbar(infoPtr->hwndSelf);
+        TOOLBAR_CalcToolbar(infoPtr);
     else
-        TOOLBAR_LayoutToolbar(infoPtr->hwndSelf);
-    TOOLBAR_AutoSize(infoPtr->hwndSelf);
+        TOOLBAR_LayoutToolbar(infoPtr);
+    TOOLBAR_AutoSize(infoPtr);
 
     TOOLBAR_DumpToolbar(infoPtr, __LINE__);
     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
@@ -2626,7 +2615,7 @@ TOOLBAR_CustomizeDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 		else
 		   oldText = SetTextColor (lpdis->hDC, (lpdis->itemState & ODS_FOCUS)?comctl32_color.clrHighlightText:comctl32_color.clrWindowText);
                 hPen = CreatePen( PS_SOLID, 1,
-                     GetSysColor( (lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
+                                 (lpdis->itemState & ODS_SELECTED)?comctl32_color.clrHighlight:comctl32_color.clrWindow);
 		hOldPen = SelectObject (lpdis->hDC, hPen );
 		hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
 
@@ -2778,15 +2767,14 @@ TOOLBAR_CheckImageListIconSize(TOOLBAR_INFO *infoPtr)
  *
  */
 static LRESULT
-TOOLBAR_AddBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_AddBitmap (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBADDBITMAP lpAddBmp = (LPTBADDBITMAP)lParam;
     TBITMAP_INFO info;
     INT iSumButtons, i;
     HIMAGELIST himlDef;
 
-    TRACE("hwnd=%p wParam=%lx lParam=%lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p wParam=%lx lParam=%lx\n", infoPtr->hwndSelf, wParam, lParam);
     if (!lpAddBmp)
 	return -1;
 
@@ -2829,15 +2817,15 @@ TOOLBAR_AddBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	if (lpAddBmp->nID & 1)
 	{
 	    /* large icons: 24x24. Will make the button 31x30 */
-	    SendMessageW (hwnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(24, 24));
+	    SendMessageW (infoPtr->hwndSelf, TB_SETBITMAPSIZE, 0, MAKELPARAM(24, 24));
 	}
 	else
 	{
 	    /* small icons: 16x16. Will make the buttons 23x22 */
-	    SendMessageW (hwnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(16, 16));
+	    SendMessageW (infoPtr->hwndSelf, TB_SETBITMAPSIZE, 0, MAKELPARAM(16, 16));
 	}
 
-	TOOLBAR_CalcToolbar (hwnd);
+	TOOLBAR_CalcToolbar (infoPtr);
     }
     else
     {
@@ -2884,15 +2872,14 @@ TOOLBAR_AddBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
     infoPtr->nNumBitmapInfos++;
     TRACE("Number of bitmap infos: %d\n", infoPtr->nNumBitmapInfos);
 
-    InvalidateRect(hwnd, NULL, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     return iSumButtons;
 }
 
 
 static LRESULT
-TOOLBAR_AddButtonsT(HWND hwnd, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
+TOOLBAR_AddButtonsT(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
     INT nAddButtons = (UINT)wParam;
 
@@ -2903,10 +2890,9 @@ TOOLBAR_AddButtonsT(HWND hwnd, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
 
 
 static LRESULT
-TOOLBAR_AddStringW (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_AddStringW (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
 #define MAX_RESOURCE_STRING_LENGTH 512
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     BOOL fFirstString = (infoPtr->nNumStrings == 0);
     INT nIndex = infoPtr->nNumStrings;
 
@@ -2965,22 +2951,21 @@ TOOLBAR_AddStringW (HWND hwnd, WPARAM wParam, LPARAM lParam)
     }
 
     if (fFirstString)
-        TOOLBAR_CalcToolbar(hwnd);
+        TOOLBAR_CalcToolbar(infoPtr);
     return nIndex;
 }
 
 
 static LRESULT
-TOOLBAR_AddStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_AddStringA (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     BOOL fFirstString = (infoPtr->nNumStrings == 0);
     LPSTR p;
     INT nIndex;
     INT len;
 
     if ((wParam) && (HIWORD(lParam) == 0))  /* load from resources */
-        return TOOLBAR_AddStringW(hwnd, wParam, lParam);
+        return TOOLBAR_AddStringW(infoPtr, wParam, lParam);
 
     p = (LPSTR)lParam;
     if (p == NULL)
@@ -3000,15 +2985,14 @@ TOOLBAR_AddStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
     }
 
     if (fFirstString)
-        TOOLBAR_CalcToolbar(hwnd);
+        TOOLBAR_CalcToolbar(infoPtr);
     return nIndex;
 }
 
 
 static LRESULT
-TOOLBAR_AutoSize (HWND hwnd)
+TOOLBAR_AutoSize (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     RECT parent_rect;
     HWND parent;
     INT  x, y;
@@ -3016,7 +3000,7 @@ TOOLBAR_AutoSize (HWND hwnd)
 
     TRACE("auto sizing, style=%x!\n", infoPtr->dwStyle);
 
-    parent = GetParent (hwnd);
+    parent = GetParent (infoPtr->hwndSelf);
 
     if (!parent || !infoPtr->bDoRedraw)
         return 0;
@@ -3033,8 +3017,8 @@ TOOLBAR_AutoSize (HWND hwnd)
 
     if ((infoPtr->dwStyle & TBSTYLE_WRAPABLE) || (infoPtr->dwExStyle & TBSTYLE_EX_UNDOC1))
     {
-        TOOLBAR_LayoutToolbar(hwnd);
-        InvalidateRect( hwnd, NULL, TRUE );
+        TOOLBAR_LayoutToolbar(infoPtr);
+        InvalidateRect( infoPtr->hwndSelf, NULL, TRUE );
     }
 
     if (!(infoPtr->dwStyle & CCS_NORESIZE))
@@ -3044,13 +3028,13 @@ TOOLBAR_AutoSize (HWND hwnd)
 
         if ((infoPtr->dwStyle & CCS_BOTTOM) == CCS_NOMOVEY)
         {
-            GetWindowRect(hwnd, &window_rect);
+            GetWindowRect(infoPtr->hwndSelf, &window_rect);
             ScreenToClient(parent, (LPPOINT)&window_rect.left);
             y = window_rect.top;
         }
         if ((infoPtr->dwStyle & CCS_BOTTOM) == CCS_BOTTOM)
         {
-            GetWindowRect(hwnd, &window_rect);
+            GetWindowRect(infoPtr->hwndSelf, &window_rect);
             y = parent_rect.bottom - ( window_rect.bottom - window_rect.top);
         }
 
@@ -3067,7 +3051,7 @@ TOOLBAR_AutoSize (HWND hwnd)
             cx += GetSystemMetrics(SM_CXEDGE);
         }
 
-        SetWindowPos(hwnd, NULL, x, y, cx, cy, uPosFlags);
+        SetWindowPos(infoPtr->hwndSelf, NULL, x, y, cx, cy, uPosFlags);
     }
 
     return 0;
@@ -3075,19 +3059,15 @@ TOOLBAR_AutoSize (HWND hwnd)
 
 
 static LRESULT
-TOOLBAR_ButtonCount (HWND hwnd)
+TOOLBAR_ButtonCount (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return infoPtr->nNumButtons;
 }
 
 
 static LRESULT
-TOOLBAR_ButtonStructSize (HWND hwnd, WPARAM wParam)
+TOOLBAR_ButtonStructSize (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     infoPtr->dwStructSize = (DWORD)wParam;
 
     return 0;
@@ -3095,9 +3075,8 @@ TOOLBAR_ButtonStructSize (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_ChangeBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_ChangeBitmap (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
 
@@ -3112,16 +3091,15 @@ TOOLBAR_ChangeBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
     /* we HAVE to erase the background, the new bitmap could be */
     /* transparent */
-    InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_CheckButton (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
     INT nOldIndex = -1;
@@ -3129,7 +3107,7 @@ TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
 
-    TRACE("hwnd=%p, btn index=%d, lParam=0x%08lx\n", hwnd, nIndex, lParam);
+    TRACE("hwnd=%p, btn index=%d, lParam=0x%08lx\n", infoPtr->hwndSelf, nIndex, lParam);
 
     if (nIndex == -1)
 	return FALSE;
@@ -3155,8 +3133,8 @@ TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
     if( bChecked != LOWORD(lParam) )
     {
         if (nOldIndex != -1)
-            InvalidateRect(hwnd, &infoPtr->buttons[nOldIndex].rect, TRUE);
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+            InvalidateRect(infoPtr->hwndSelf, &infoPtr->buttons[nOldIndex].rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
     }
 
     /* FIXME: Send a WM_NOTIFY?? */
@@ -3166,18 +3144,15 @@ TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_CommandToIndex (HWND hwnd, WPARAM wParam)
+TOOLBAR_CommandToIndex (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
 }
 
 
 static LRESULT
-TOOLBAR_Customize (HWND hwnd)
+TOOLBAR_Customize (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     CUSTDLG_INFO custInfo;
     LRESULT ret;
     LPCVOID template;
@@ -3185,7 +3160,7 @@ TOOLBAR_Customize (HWND hwnd)
     NMHDR nmhdr;
 
     custInfo.tbInfo = infoPtr;
-    custInfo.tbHwnd = hwnd;
+    custInfo.tbHwnd = infoPtr->hwndSelf;
 
     /* send TBN_BEGINADJUST notification */
     TOOLBAR_SendNotify (&nmhdr, infoPtr, TBN_BEGINADJUST);
@@ -3198,8 +3173,8 @@ TOOLBAR_Customize (HWND hwnd)
     if(!(template = LoadResource (COMCTL32_hModule, hRes)))
 	return FALSE;
 
-    ret = DialogBoxIndirectParamW ((HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE),
-                                   template, hwnd, TOOLBAR_CustomizeDialogProc,
+    ret = DialogBoxIndirectParamW ((HINSTANCE)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_HINSTANCE),
+                                   template, infoPtr->hwndSelf, TOOLBAR_CustomizeDialogProc,
                                    (LPARAM)&custInfo);
 
     /* send TBN_ENDADJUST notification */
@@ -3210,9 +3185,8 @@ TOOLBAR_Customize (HWND hwnd)
 
 
 static LRESULT
-TOOLBAR_DeleteButton (HWND hwnd, WPARAM wParam)
+TOOLBAR_DeleteButton (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex = (INT)wParam;
     NMTOOLBARW nmtb;
     TBUTTON_INFO *btnPtr = &infoPtr->buttons[nIndex];
@@ -3257,25 +3231,24 @@ TOOLBAR_DeleteButton (HWND hwnd, WPARAM wParam)
 	Free (oldButtons);
     }
 
-    TOOLBAR_LayoutToolbar(hwnd);
+    TOOLBAR_LayoutToolbar(infoPtr);
 
-    InvalidateRect (hwnd, NULL, TRUE);
+    InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_EnableButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_EnableButton (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
     DWORD bState;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
 
-    TRACE("hwnd=%p, btn index=%ld, lParam=0x%08lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p, btn index=%ld, lParam=0x%08lx\n", infoPtr->hwndSelf, wParam, lParam);
 
     if (nIndex == -1)
 	return FALSE;
@@ -3293,25 +3266,22 @@ TOOLBAR_EnableButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
     /* redraw the button only if the state of the button changed */
     if(bState != (btnPtr->fsState & TBSTATE_ENABLED))
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
 
 
 static inline LRESULT
-TOOLBAR_GetAnchorHighlight (HWND hwnd)
+TOOLBAR_GetAnchorHighlight (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return infoPtr->bAnchor;
 }
 
 
 static LRESULT
-TOOLBAR_GetBitmap (HWND hwnd, WPARAM wParam)
+TOOLBAR_GetBitmap (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3330,9 +3300,8 @@ TOOLBAR_GetBitmapFlags (void)
 
 
 static LRESULT
-TOOLBAR_GetButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetButton (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
     INT nIndex = (INT)wParam;
     TBUTTON_INFO *btnPtr;
@@ -3358,9 +3327,8 @@ TOOLBAR_GetButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetButtonInfoT(HWND hwnd, WPARAM wParam, LPARAM lParam, BOOL bUnicode)
+TOOLBAR_GetButtonInfoT(const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam, BOOL bUnicode)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     /* TBBUTTONINFOW and TBBUTTONINFOA have the same layout*/
     LPTBBUTTONINFOW lpTbInfo = (LPTBBUTTONINFOW)lParam;
     TBUTTON_INFO *btnPtr;
@@ -3419,19 +3387,16 @@ TOOLBAR_GetButtonInfoT(HWND hwnd, WPARAM wParam, LPARAM lParam, BOOL bUnicode)
 
 
 static LRESULT
-TOOLBAR_GetButtonSize (HWND hwnd)
+TOOLBAR_GetButtonSize (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return MAKELONG((WORD)infoPtr->nButtonWidth,
                     (WORD)infoPtr->nButtonHeight);
 }
 
 
 static LRESULT
-TOOLBAR_GetButtonTextA (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetButtonTextA (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
     LPWSTR lpText;
 
@@ -3447,9 +3412,8 @@ TOOLBAR_GetButtonTextA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetButtonTextW (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetButtonTextW (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
     LPWSTR lpText;
     LRESULT ret = 0;
@@ -3473,19 +3437,17 @@ TOOLBAR_GetButtonTextW (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetDisabledImageList (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%p, wParam=%ld, lParam=0x%lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p, wParam=%ld, lParam=0x%lx\n", infoPtr->hwndSelf, wParam, lParam);
     /* UNDOCUMENTED: wParam is actually the ID of the image list to return */
-    return (LRESULT)GETDISIMAGELIST(TOOLBAR_GetInfoPtr (hwnd), wParam);
+    return (LRESULT)GETDISIMAGELIST(infoPtr, wParam);
 }
 
 
 static inline LRESULT
-TOOLBAR_GetExtendedStyle (HWND hwnd)
+TOOLBAR_GetExtendedStyle (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     TRACE("\n");
 
     return infoPtr->dwExStyle;
@@ -3493,19 +3455,17 @@ TOOLBAR_GetExtendedStyle (HWND hwnd)
 
 
 static LRESULT
-TOOLBAR_GetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetHotImageList (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%p, wParam=%ld, lParam=0x%lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p, wParam=%ld, lParam=0x%lx\n", infoPtr->hwndSelf, wParam, lParam);
     /* UNDOCUMENTED: wParam is actually the ID of the image list to return */
-    return (LRESULT)GETHOTIMAGELIST(TOOLBAR_GetInfoPtr (hwnd), wParam);
+    return (LRESULT)GETHOTIMAGELIST(infoPtr, wParam);
 }
 
 
 static LRESULT
-TOOLBAR_GetHotItem (HWND hwnd)
+TOOLBAR_GetHotItem (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     if (!((infoPtr->dwStyle & TBSTYLE_FLAT) || GetWindowTheme (infoPtr->hwndSelf)))
 	return -1;
 
@@ -3517,21 +3477,20 @@ TOOLBAR_GetHotItem (HWND hwnd)
 
 
 static LRESULT
-TOOLBAR_GetDefImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetDefImageList (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%p, wParam=%ld, lParam=0x%lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p, wParam=%ld, lParam=0x%lx\n", infoPtr->hwndSelf, wParam, lParam);
     /* UNDOCUMENTED: wParam is actually the ID of the image list to return */
-    return (LRESULT) GETDEFIMAGELIST(TOOLBAR_GetInfoPtr(hwnd), wParam);
+    return (LRESULT) GETDEFIMAGELIST(infoPtr, wParam);
 }
 
 
 static LRESULT
-TOOLBAR_GetInsertMark (HWND hwnd, LPARAM lParam)
+TOOLBAR_GetInsertMark (const TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBINSERTMARK *lptbim = (TBINSERTMARK*)lParam;
 
-    TRACE("hwnd = %p, lptbim = %p\n", hwnd, lptbim);
+    TRACE("hwnd = %p, lptbim = %p\n", infoPtr->hwndSelf, lptbim);
 
     *lptbim = infoPtr->tbim;
 
@@ -3540,20 +3499,17 @@ TOOLBAR_GetInsertMark (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetInsertMarkColor (HWND hwnd)
+TOOLBAR_GetInsertMarkColor (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
-    TRACE("hwnd = %p\n", hwnd);
+    TRACE("hwnd = %p\n", infoPtr->hwndSelf);
 
     return (LRESULT)infoPtr->clrInsertMark;
 }
 
 
 static LRESULT
-TOOLBAR_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetItemRect (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     LPRECT     lpRect;
     INT        nIndex;
@@ -3578,9 +3534,8 @@ TOOLBAR_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetMaxSize (HWND hwnd, LPARAM lParam)
+TOOLBAR_GetMaxSize (const TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPSIZE lpSize = (LPSIZE)lParam;
 
     if (lpSize == NULL)
@@ -3601,9 +3556,8 @@ TOOLBAR_GetMaxSize (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetPadding (HWND hwnd)
+TOOLBAR_GetPadding (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     DWORD oldPad;
 
     oldPad = MAKELONG(infoPtr->szPadding.cx, infoPtr->szPadding.cy);
@@ -3612,9 +3566,8 @@ TOOLBAR_GetPadding (HWND hwnd)
 
 
 static LRESULT
-TOOLBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetRect (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     LPRECT     lpRect;
     INT        nIndex;
@@ -3637,18 +3590,15 @@ TOOLBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetRows (HWND hwnd)
+TOOLBAR_GetRows (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return infoPtr->nRows;
 }
 
 
 static LRESULT
-TOOLBAR_GetState (HWND hwnd, WPARAM wParam)
+TOOLBAR_GetState (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3660,26 +3610,22 @@ TOOLBAR_GetState (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_GetStyle (HWND hwnd)
+TOOLBAR_GetStyle (const TOOLBAR_INFO *infoPtr)
 {
-    return GetWindowLongW(hwnd, GWL_STYLE);
+    return infoPtr->dwStyle;
 }
 
 
 static LRESULT
-TOOLBAR_GetTextRows (HWND hwnd)
+TOOLBAR_GetTextRows (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return infoPtr->nMaxTextRows;
 }
 
 
 static LRESULT
-TOOLBAR_GetToolTips (HWND hwnd)
+TOOLBAR_GetToolTips (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     if ((infoPtr->dwStyle & TBSTYLE_TOOLTIPS) && (infoPtr->hwndToolTip == NULL))
         TOOLBAR_TooltipCreateControl(infoPtr);
     return (LRESULT)infoPtr->hwndToolTip;
@@ -3687,29 +3633,25 @@ TOOLBAR_GetToolTips (HWND hwnd)
 
 
 static LRESULT
-TOOLBAR_GetUnicodeFormat (HWND hwnd)
+TOOLBAR_GetUnicodeFormat (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     TRACE("%s hwnd=%p\n",
-	   infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
+	   infoPtr->bUnicode ? "TRUE" : "FALSE", infoPtr->hwndSelf);
 
     return infoPtr->bUnicode;
 }
 
 
 static inline LRESULT
-TOOLBAR_GetVersion (HWND hwnd)
+TOOLBAR_GetVersion (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     return infoPtr->iVersion;
 }
 
 
 static LRESULT
-TOOLBAR_HideButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_HideButton (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
 
@@ -3725,25 +3667,24 @@ TOOLBAR_HideButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
     else
 	btnPtr->fsState |= TBSTATE_HIDDEN;
 
-    TOOLBAR_LayoutToolbar (hwnd);
+    TOOLBAR_LayoutToolbar (infoPtr);
 
-    InvalidateRect (hwnd, NULL, TRUE);
+    InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
 
     return TRUE;
 }
 
 
 static inline LRESULT
-TOOLBAR_HitTest (HWND hwnd, LPARAM lParam)
+TOOLBAR_HitTest (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    return TOOLBAR_InternalHitTest (hwnd, (LPPOINT)lParam);
+    return TOOLBAR_InternalHitTest (infoPtr, (LPPOINT)lParam);
 }
 
 
 static LRESULT
-TOOLBAR_Indeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_Indeterminate (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
     DWORD oldState;
@@ -3760,16 +3701,15 @@ TOOLBAR_Indeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	btnPtr->fsState |= TBSTATE_INDETERMINATE;
 
     if(oldState != btnPtr->fsState)
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_InsertButtonT(HWND hwnd, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
+TOOLBAR_InsertButtonT(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
     INT nIndex = (INT)wParam;
 
@@ -3801,9 +3741,8 @@ TOOLBAR_InsertButtonT(HWND hwnd, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
 
 
 static LRESULT
-TOOLBAR_IsButtonChecked (HWND hwnd, WPARAM wParam)
+TOOLBAR_IsButtonChecked (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3815,9 +3754,8 @@ TOOLBAR_IsButtonChecked (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_IsButtonEnabled (HWND hwnd, WPARAM wParam)
+TOOLBAR_IsButtonEnabled (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3829,9 +3767,8 @@ TOOLBAR_IsButtonEnabled (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_IsButtonHidden (HWND hwnd, WPARAM wParam)
+TOOLBAR_IsButtonHidden (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3843,9 +3780,8 @@ TOOLBAR_IsButtonHidden (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_IsButtonHighlighted (HWND hwnd, WPARAM wParam)
+TOOLBAR_IsButtonHighlighted (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3857,9 +3793,8 @@ TOOLBAR_IsButtonHighlighted (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_IsButtonIndeterminate (HWND hwnd, WPARAM wParam)
+TOOLBAR_IsButtonIndeterminate (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3871,9 +3806,8 @@ TOOLBAR_IsButtonIndeterminate (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_IsButtonPressed (HWND hwnd, WPARAM wParam)
+TOOLBAR_IsButtonPressed (const TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
@@ -3885,29 +3819,28 @@ TOOLBAR_IsButtonPressed (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_LoadImages (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_LoadImages (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
     TBADDBITMAP tbab;
     tbab.hInst = (HINSTANCE)lParam;
     tbab.nID = wParam;
 
-    TRACE("hwnd = %p, hInst = %p, nID = %lu\n", hwnd, tbab.hInst, tbab.nID);
+    TRACE("hwnd = %p, hInst = %p, nID = %lu\n", infoPtr->hwndSelf, tbab.hInst, tbab.nID);
 
-    return TOOLBAR_AddBitmap(hwnd, 0, (LPARAM)&tbab);
+    return TOOLBAR_AddBitmap(infoPtr, 0, (LPARAM)&tbab);
 }
 
 
 static LRESULT
-TOOLBAR_MapAccelerator (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_MapAccelerator (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     WCHAR wAccel = (WCHAR)wParam;
     UINT* pIDButton = (UINT*)lParam;
     WCHAR wszAccel[] = {'&',wAccel,0};
     int i;
     
     TRACE("hwnd = %p, wAccel = %x(%s), pIDButton = %p\n",
-        hwnd, wAccel, debugstr_wn(&wAccel,1), pIDButton);
+        infoPtr->hwndSelf, wAccel, debugstr_wn(&wAccel,1), pIDButton);
     
     for (i = 0; i < infoPtr->nNumButtons; i++)
     {
@@ -3942,14 +3875,13 @@ TOOLBAR_MapAccelerator (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_MarkButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_MarkButton (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
     DWORD oldState;
     TBUTTON_INFO *btnPtr;
 
-    TRACE("hwnd = %p, wParam = %ld, lParam = 0x%08lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd = %p, wParam = %ld, lParam = 0x%08lx\n", infoPtr->hwndSelf, wParam, lParam);
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
     if (nIndex == -1)
@@ -3964,7 +3896,7 @@ TOOLBAR_MarkButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
         btnPtr->fsState &= ~TBSTATE_MARKED;
 
     if(oldState != btnPtr->fsState)
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
@@ -3991,15 +3923,14 @@ static inline void TOOLBAR_MoveFixupIndex(INT* pIndex, INT nIndex, INT nMoveInde
 
 
 static LRESULT
-TOOLBAR_MoveButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_MoveButton (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex;
     INT nCount;
     INT nMoveIndex = (INT)lParam;
     TBUTTON_INFO button;
 
-    TRACE("hwnd=%p, wParam=%ld, lParam=%ld\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p, wParam=%ld, lParam=%ld\n", infoPtr->hwndSelf, wParam, lParam);
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, TRUE);
     if ((nIndex == -1) || (nMoveIndex < 0))
@@ -4034,18 +3965,17 @@ TOOLBAR_MoveButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
         TOOLBAR_MoveFixupIndex(&infoPtr->nHotItem, nIndex, nMoveIndex, FALSE);
     }
 
-    TOOLBAR_LayoutToolbar(hwnd);
-    TOOLBAR_AutoSize(hwnd);
-    InvalidateRect(hwnd, NULL, TRUE);
+    TOOLBAR_LayoutToolbar(infoPtr);
+    TOOLBAR_AutoSize(infoPtr);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_PressButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_PressButton (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
     DWORD oldState;
@@ -4062,7 +3992,7 @@ TOOLBAR_PressButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	btnPtr->fsState |= TBSTATE_PRESSED;
 
     if(oldState != btnPtr->fsState)
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
@@ -4070,9 +4000,8 @@ TOOLBAR_PressButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
 /* FIXME: there might still be some confusion her between number of buttons
  * and number of bitmaps */
 static LRESULT
-TOOLBAR_ReplaceBitmap (HWND hwnd, LPARAM lParam)
+TOOLBAR_ReplaceBitmap (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBREPLACEBITMAP lpReplace = (LPTBREPLACEBITMAP) lParam;
     HBITMAP hBitmap;
     int i = 0, nOldButtons = 0, pos = 0;
@@ -4142,7 +4071,7 @@ TOOLBAR_ReplaceBitmap (HWND hwnd, LPARAM lParam)
     TRACE(" pos %d  %d old bitmaps replaced by %d new ones.\n",
             pos, nOldBitmaps, nNewBitmaps);
 
-    InvalidateRect(hwnd, NULL, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     return TRUE;
 }
 
@@ -4253,8 +4182,7 @@ TOOLBAR_Restore(TOOLBAR_INFO *infoPtr, const TBSAVEPARAMSW *lpSave)
                 if (HIWORD(nmtbr.tbButton.iString))
                     nmtbr.tbButton.iString = 0;
 
-                TOOLBAR_InsertButtonT(infoPtr->hwndSelf, -1,
-                    (LPARAM)&nmtbr.tbButton, TRUE);
+                TOOLBAR_InsertButtonT(infoPtr, -1, (LPARAM)&nmtbr.tbButton, TRUE);
             }
 
             /* do legacy notifications */
@@ -4270,7 +4198,7 @@ TOOLBAR_Restore(TOOLBAR_INFO *infoPtr, const TBSAVEPARAMSW *lpSave)
              * delete */
             for (i = infoPtr->nNumButtons - 1; i >= 0; i--)
                 if (infoPtr->buttons[i].iBitmap == -1)
-                    TOOLBAR_DeleteButton(infoPtr->hwndSelf, i);
+                    TOOLBAR_DeleteButton(infoPtr, i);
 
             /* only indicate success if at least one button survived */
             if (infoPtr->nNumButtons > 0) ret = TRUE;
@@ -4284,10 +4212,8 @@ TOOLBAR_Restore(TOOLBAR_INFO *infoPtr, const TBSAVEPARAMSW *lpSave)
 
 
 static LRESULT
-TOOLBAR_SaveRestoreW (HWND hwnd, WPARAM wParam, const TBSAVEPARAMSW *lpSave)
+TOOLBAR_SaveRestoreW (TOOLBAR_INFO *infoPtr, WPARAM wParam, const TBSAVEPARAMSW *lpSave)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     if (lpSave == NULL) return 0;
 
     if (wParam)
@@ -4298,7 +4224,7 @@ TOOLBAR_SaveRestoreW (HWND hwnd, WPARAM wParam, const TBSAVEPARAMSW *lpSave)
 
 
 static LRESULT
-TOOLBAR_SaveRestoreA (HWND hwnd, WPARAM wParam, const TBSAVEPARAMSA *lpSave)
+TOOLBAR_SaveRestoreA (TOOLBAR_INFO *infoPtr, WPARAM wParam, const TBSAVEPARAMSA *lpSave)
 {
     LPWSTR pszValueName = 0, pszSubKey = 0;
     TBSAVEPARAMSW SaveW;
@@ -4320,7 +4246,7 @@ TOOLBAR_SaveRestoreA (HWND hwnd, WPARAM wParam, const TBSAVEPARAMSA *lpSave)
     SaveW.pszValueName = pszValueName;
     SaveW.pszSubKey = pszSubKey;
     SaveW.hkr = lpSave->hkr;
-    result = TOOLBAR_SaveRestoreW(hwnd, wParam, &SaveW);
+    result = TOOLBAR_SaveRestoreW(infoPtr, wParam, &SaveW);
 
 exit:
     Free (pszValueName);
@@ -4331,12 +4257,11 @@ exit:
 
 
 static LRESULT
-TOOLBAR_SetAnchorHighlight (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetAnchorHighlight (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     BOOL bOldAnchor = infoPtr->bAnchor;
 
-    TRACE("hwnd=%p, bAnchor = %s\n", hwnd, wParam ? "TRUE" : "FALSE");
+    TRACE("hwnd=%p, bAnchor = %s\n", infoPtr->hwndSelf, wParam ? "TRUE" : "FALSE");
 
     infoPtr->bAnchor = (BOOL)wParam;
 
@@ -4347,14 +4272,13 @@ TOOLBAR_SetAnchorHighlight (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_SetBitmapSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetBitmapSize (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     HIMAGELIST himlDef = GETDEFIMAGELIST(infoPtr, 0);
     short width = (short)LOWORD(lParam);
     short height = (short)HIWORD(lParam);
 
-    TRACE("hwnd=%p, wParam=%ld, lParam=%ld\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p, wParam=%ld, lParam=%ld\n", infoPtr->hwndSelf, wParam, lParam);
 
     if (wParam != 0)
         FIXME("wParam is %ld. Perhaps image list index?\n", wParam);
@@ -4391,16 +4315,15 @@ TOOLBAR_SetBitmapSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
             infoPtr->nBitmapHeight);
     }
 
-    TOOLBAR_CalcToolbar(hwnd);
+    TOOLBAR_CalcToolbar(infoPtr);
     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_SetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetButtonInfoA (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBBUTTONINFOA lptbbi = (LPTBBUTTONINFOA)lParam;
     TBUTTON_INFO *btnPtr;
     INT nIndex;
@@ -4440,21 +4363,20 @@ TOOLBAR_SetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
     /* save the button rect to see if we need to redraw the whole toolbar */
     oldBtnRect = btnPtr->rect;
-    TOOLBAR_LayoutToolbar(hwnd);
+    TOOLBAR_LayoutToolbar(infoPtr);
 
     if (!EqualRect(&oldBtnRect, &btnPtr->rect))
-        InvalidateRect(hwnd, NULL, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     else
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_SetButtonInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetButtonInfoW (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPTBBUTTONINFOW lptbbi = (LPTBBUTTONINFOW)lParam;
     TBUTTON_INFO *btnPtr;
     INT nIndex;
@@ -4493,21 +4415,20 @@ TOOLBAR_SetButtonInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
     /* save the button rect to see if we need to redraw the whole toolbar */
     oldBtnRect = btnPtr->rect;
-    TOOLBAR_LayoutToolbar(hwnd);
+    TOOLBAR_LayoutToolbar(infoPtr);
 
     if (!EqualRect(&oldBtnRect, &btnPtr->rect))
-        InvalidateRect(hwnd, NULL, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     else
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_SetButtonSize (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetButtonSize (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT cx = (short)LOWORD(lParam), cy = (short)HIWORD(lParam);
 
     if ((cx < 0) || (cy < 0))
@@ -4516,7 +4437,7 @@ TOOLBAR_SetButtonSize (HWND hwnd, LPARAM lParam)
         return FALSE;
     }
 
-    TRACE("%p, cx = %d, cy = %d\n", hwnd, cx, cy);
+    TRACE("%p, cx = %d, cy = %d\n", infoPtr->hwndSelf, cx, cy);
 
     /* The documentation claims you can only change the button size before
      * any button has been added. But this is wrong.
@@ -4539,16 +4460,14 @@ TOOLBAR_SetButtonSize (HWND hwnd, LPARAM lParam)
     infoPtr->nButtonHeight = cy;
     
     infoPtr->iTopMargin = default_top_margin(infoPtr);
-    TOOLBAR_LayoutToolbar(hwnd);
+    TOOLBAR_LayoutToolbar(infoPtr);
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_SetButtonWidth (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetButtonWidth (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     /* if setting to current values, ignore */
     if ((infoPtr->cxMin == (short)LOWORD(lParam)) &&
 	(infoPtr->cxMax == (short)HIWORD(lParam))) {
@@ -4567,18 +4486,17 @@ TOOLBAR_SetButtonWidth (HWND hwnd, LPARAM lParam)
     TRACE("number of buttons %d, cx=%d, cy=%d, recalcing\n",
 	infoPtr->nNumButtons, infoPtr->cxMin, infoPtr->cxMax);
 
-    TOOLBAR_CalcToolbar (hwnd);
+    TOOLBAR_CalcToolbar (infoPtr);
 
-    InvalidateRect (hwnd, NULL, TRUE);
+    InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
 
     return TRUE;
 }
 
 
 static LRESULT
-TOOLBAR_SetCmdId (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetCmdId (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nIndex = (INT)wParam;
 
     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
@@ -4597,9 +4515,8 @@ TOOLBAR_SetCmdId (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetDisabledImageList (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     HIMAGELIST himl = (HIMAGELIST)lParam;
     HIMAGELIST himlTemp;
     INT id = 0;
@@ -4617,12 +4534,11 @@ TOOLBAR_SetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetDrawTextFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetDrawTextFlags (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     DWORD dwTemp;
 
-    TRACE("hwnd = %p, dwMask = 0x%08x, dwDTFlags = 0x%08x\n", hwnd, (DWORD)wParam, (DWORD)lParam);
+    TRACE("hwnd = %p, dwMask = 0x%08x, dwDTFlags = 0x%08x\n", infoPtr->hwndSelf, (DWORD)wParam, (DWORD)lParam);
 
     dwTemp = infoPtr->dwDTFlags;
     infoPtr->dwDTFlags =
@@ -4638,9 +4554,8 @@ TOOLBAR_SetDrawTextFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
  *  (MSDN says that this parameter is reserved)
  */
 static LRESULT
-TOOLBAR_SetExtendedStyle (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetExtendedStyle (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     DWORD dwOldStyle;
 
     dwOldStyle = infoPtr->dwExStyle;
@@ -4653,21 +4568,20 @@ TOOLBAR_SetExtendedStyle (HWND hwnd, LPARAM lParam)
 	      (infoPtr->dwExStyle & ~TBSTYLE_EX_ALL));
 
     if ((dwOldStyle ^ infoPtr->dwExStyle) & TBSTYLE_EX_MIXEDBUTTONS)
-        TOOLBAR_CalcToolbar(hwnd);
+        TOOLBAR_CalcToolbar(infoPtr);
     else
-        TOOLBAR_LayoutToolbar(hwnd);
+        TOOLBAR_LayoutToolbar(infoPtr);
 
-    TOOLBAR_AutoSize(hwnd);
-    InvalidateRect(hwnd, NULL, TRUE);
+    TOOLBAR_AutoSize(infoPtr);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
 
     return (LRESULT)dwOldStyle;
 }
 
 
 static LRESULT
-TOOLBAR_SetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetHotImageList (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     HIMAGELIST himlTemp;
     HIMAGELIST himl = (HIMAGELIST)lParam;
     INT id = 0;
@@ -4675,7 +4589,7 @@ TOOLBAR_SetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
     if (infoPtr->iVersion >= 5)
         id = wParam;
 
-    TRACE("hwnd = %p, himl = %p, id = %d\n", hwnd, himl, id);
+    TRACE("hwnd = %p, himl = %p, id = %d\n", infoPtr->hwndSelf, himl, id);
 
     himlTemp = TOOLBAR_InsertImageList(&infoPtr->himlHot, 
         &infoPtr->cimlHot, himl, id);
@@ -4744,12 +4658,11 @@ TOOLBAR_SetHotItemEx (TOOLBAR_INFO *infoPtr, INT nHit, DWORD dwReason)
 }
 
 static LRESULT
-TOOLBAR_SetHotItem (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetHotItem (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     INT nOldHotItem = infoPtr->nHotItem;
 
-    TRACE("hwnd = %p, nHit = %d\n", hwnd, (INT)wParam);
+    TRACE("hwnd = %p, nHit = %d\n", infoPtr->hwndSelf, (INT)wParam);
 
     if ((INT)wParam >= infoPtr->nNumButtons)
         return infoPtr->nHotItem;
@@ -4770,9 +4683,8 @@ TOOLBAR_SetHotItem (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetImageList (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     HIMAGELIST himlTemp;
     HIMAGELIST himl = (HIMAGELIST)lParam;
     INT oldButtonWidth = infoPtr->nButtonWidth;
@@ -4798,26 +4710,24 @@ TOOLBAR_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
     }
     if ((oldBitmapWidth != infoPtr->nBitmapWidth) || (oldBitmapHeight != infoPtr->nBitmapHeight))
     {
-        TOOLBAR_CalcToolbar(hwnd);
+        TOOLBAR_CalcToolbar(infoPtr);
         if (infoPtr->nButtonWidth < oldButtonWidth)
-            TOOLBAR_SetButtonSize(hwnd, MAKELONG(oldButtonWidth, infoPtr->nButtonHeight));
+            TOOLBAR_SetButtonSize(infoPtr, MAKELONG(oldButtonWidth, infoPtr->nButtonHeight));
     }
 
     TRACE("hwnd %p, new himl=%p, id = %d, count=%d, bitmap w=%d, h=%d\n",
-	  hwnd, infoPtr->himlDef, id, infoPtr->nNumBitmaps,
+	  infoPtr->hwndSelf, infoPtr->himlDef, id, infoPtr->nNumBitmaps,
 	  infoPtr->nBitmapWidth, infoPtr->nBitmapHeight);
 
-    InvalidateRect(hwnd, NULL, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
 
     return (LRESULT)himlTemp;
 }
 
 
 static LRESULT
-TOOLBAR_SetIndent (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetIndent (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     infoPtr->nIndent = (INT)wParam;
 
     TRACE("\n");
@@ -4826,8 +4736,8 @@ TOOLBAR_SetIndent (HWND hwnd, WPARAM wParam)
     if(infoPtr->nIndent != (INT)wParam)
     {
         infoPtr->nIndent = (INT)wParam;
-        TOOLBAR_CalcToolbar (hwnd);
-        InvalidateRect(hwnd, NULL, FALSE);
+        TOOLBAR_CalcToolbar (infoPtr);
+        InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
     }
 
     return TRUE;
@@ -4835,12 +4745,11 @@ TOOLBAR_SetIndent (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_SetInsertMark (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetInsertMark (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBINSERTMARK *lptbim = (TBINSERTMARK*)lParam;
 
-    TRACE("hwnd = %p, lptbim = { %d, 0x%08x}\n", hwnd, lptbim->iButton, lptbim->dwFlags);
+    TRACE("hwnd = %p, lptbim = { %d, 0x%08x}\n", infoPtr->hwndSelf, lptbim->iButton, lptbim->dwFlags);
 
     if ((lptbim->dwFlags & ~TBIMHT_AFTER) != 0)
     {
@@ -4854,7 +4763,7 @@ TOOLBAR_SetInsertMark (HWND hwnd, LPARAM lParam)
     {
         infoPtr->tbim = *lptbim;
         /* FIXME: don't need to update entire toolbar */
-        InvalidateRect(hwnd, NULL, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     }
     else
         ERR("Invalid button index %d\n", lptbim->iButton);
@@ -4864,27 +4773,23 @@ TOOLBAR_SetInsertMark (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetInsertMarkColor (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetInsertMarkColor (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     infoPtr->clrInsertMark = (COLORREF)lParam;
 
     /* FIXME: don't need to update entire toolbar */
-    InvalidateRect(hwnd, NULL, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
 
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_SetMaxTextRows (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetMaxTextRows (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     infoPtr->nMaxTextRows = (INT)wParam;
 
-    TOOLBAR_CalcToolbar(hwnd);
+    TOOLBAR_CalcToolbar(infoPtr);
     return TRUE;
 }
 
@@ -4901,9 +4806,8 @@ TOOLBAR_SetMaxTextRows (HWND hwnd, WPARAM wParam)
  * See blueprints in comments above TOOLBAR_MeasureButton for more info.
  */
 static LRESULT
-TOOLBAR_SetPadding (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetPadding (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     DWORD  oldPad;
 
     oldPad = MAKELONG(infoPtr->szPadding.cx, infoPtr->szPadding.cy);
@@ -4916,9 +4820,8 @@ TOOLBAR_SetPadding (HWND hwnd, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetParent (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetParent (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     HWND hwndOldNotify;
 
     TRACE("\n");
@@ -4931,9 +4834,8 @@ TOOLBAR_SetParent (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_SetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetRows (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPRECT lprc = (LPRECT)lParam;
     int rows = LOWORD(wParam);
     BOOL bLarger = HIWORD(wParam);
@@ -5024,20 +4926,20 @@ TOOLBAR_SetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
         TRACE("Result - %d rows\n", curRow + 1);
 
         /* recalculate toolbar */
-        TOOLBAR_CalcToolbar (hwnd);
+        TOOLBAR_CalcToolbar (infoPtr);
 
         /* Resize if necessary (Only if NORESIZE is set - odd, but basically
            if NORESIZE is NOT set, then the toolbar will always be resized to
            take up the whole window. With it set, sizing needs to be manual. */
         if (infoPtr->dwStyle & CCS_NORESIZE) {
-            SetWindowPos(hwnd, NULL, 0, 0,
+            SetWindowPos(infoPtr->hwndSelf, NULL, 0, 0,
                          infoPtr->rcBound.right - infoPtr->rcBound.left,
                          infoPtr->rcBound.bottom - infoPtr->rcBound.top,
                          SWP_NOMOVE);
         }
 
         /* repaint toolbar */
-        InvalidateRect(hwnd, NULL, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     }
 
     /* return bounding rectangle */
@@ -5053,9 +4955,8 @@ TOOLBAR_SetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetState (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     INT nIndex;
 
@@ -5068,8 +4969,8 @@ TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
     /* if hidden state has changed the invalidate entire window and recalc */
     if ((btnPtr->fsState & TBSTATE_HIDDEN) != (LOWORD(lParam) & TBSTATE_HIDDEN)) {
 	btnPtr->fsState = LOWORD(lParam);
-	TOOLBAR_CalcToolbar (hwnd);
-	InvalidateRect(hwnd, 0, TRUE);
+	TOOLBAR_CalcToolbar (infoPtr);
+	InvalidateRect(infoPtr->hwndSelf, 0, TRUE);
 	return TRUE;
     }
 
@@ -5077,7 +4978,7 @@ TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
     if(btnPtr->fsState != LOWORD(lParam))
     {
         btnPtr->fsState = LOWORD(lParam);
-        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
     }
 
     return TRUE;
@@ -5085,20 +4986,18 @@ TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetStyle (HWND hwnd, LPARAM lParam)
+TOOLBAR_SetStyle (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    SetWindowLongW(hwnd, GWL_STYLE, lParam);
+    SetWindowLongW(infoPtr->hwndSelf, GWL_STYLE, lParam);
 
     return TRUE;
 }
 
 
 static inline LRESULT
-TOOLBAR_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetToolTips (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
-    TRACE("hwnd=%p, hwndTooltip=%p, lParam=0x%lx\n", hwnd, (HWND)wParam, lParam);
+    TRACE("hwnd=%p, hwndTooltip=%p, lParam=0x%lx\n", infoPtr->hwndSelf, (HWND)wParam, lParam);
 
     infoPtr->hwndToolTip = (HWND)wParam;
     return 0;
@@ -5106,13 +5005,12 @@ TOOLBAR_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetUnicodeFormat (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     BOOL bTemp;
 
     TRACE("%s hwnd=%p\n",
-	   ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
+	   ((BOOL)wParam) ? "TRUE" : "FALSE", infoPtr->hwndSelf);
 
     bTemp = infoPtr->bUnicode;
     infoPtr->bUnicode = (BOOL)wParam;
@@ -5122,10 +5020,8 @@ TOOLBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_GetColorScheme (HWND hwnd, LPCOLORSCHEME lParam)
+TOOLBAR_GetColorScheme (const TOOLBAR_INFO *infoPtr, LPCOLORSCHEME lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     lParam->clrBtnHighlight = (infoPtr->clrBtnHighlight == CLR_DEFAULT) ?
 	                       comctl32_color.clrBtnHighlight :
                                infoPtr->clrBtnHighlight;
@@ -5136,46 +5032,42 @@ TOOLBAR_GetColorScheme (HWND hwnd, LPCOLORSCHEME lParam)
 
 
 static LRESULT
-TOOLBAR_SetColorScheme (HWND hwnd, const COLORSCHEME *lParam)
+TOOLBAR_SetColorScheme (TOOLBAR_INFO *infoPtr, const COLORSCHEME *lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     TRACE("new colors Hl=%x Shd=%x, old colors Hl=%x Shd=%x\n",
 	  lParam->clrBtnHighlight, lParam->clrBtnShadow,
 	  infoPtr->clrBtnHighlight, infoPtr->clrBtnShadow);
 
     infoPtr->clrBtnHighlight = lParam->clrBtnHighlight;
     infoPtr->clrBtnShadow = lParam->clrBtnShadow;
-    InvalidateRect(hwnd, NULL, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_SetVersion (HWND hwnd, INT iVersion)
+TOOLBAR_SetVersion (TOOLBAR_INFO *infoPtr, INT iVersion)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT iOldVersion = infoPtr->iVersion;
 
     infoPtr->iVersion = iVersion;
 
     if (infoPtr->iVersion >= 5)
-        TOOLBAR_SetUnicodeFormat(hwnd, TRUE);
+        TOOLBAR_SetUnicodeFormat(infoPtr, TRUE);
 
     return iOldVersion;
 }
 
 
 static LRESULT
-TOOLBAR_GetStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetStringA (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     WORD iString = HIWORD(wParam);
     WORD buffersize = LOWORD(wParam);
     LPSTR str = (LPSTR)lParam;
     LRESULT ret = -1;
 
-    TRACE("hwnd=%p, iString=%d, buffersize=%d, string=%p\n", hwnd, iString, buffersize, str);
+    TRACE("hwnd=%p, iString=%d, buffersize=%d, string=%p\n", infoPtr->hwndSelf, iString, buffersize, str);
 
     if (iString < infoPtr->nNumStrings)
     {
@@ -5192,15 +5084,14 @@ TOOLBAR_GetStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetStringW (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetStringW (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     WORD iString = HIWORD(wParam);
     WORD len = LOWORD(wParam)/sizeof(WCHAR) - 1;
     LPWSTR str = (LPWSTR)lParam;
     LRESULT ret = -1;
 
-    TRACE("hwnd=%p, iString=%d, buffersize=%d, string=%p\n", hwnd, iString, LOWORD(wParam), str);
+    TRACE("hwnd=%p, iString=%d, buffersize=%d, string=%p\n", infoPtr->hwndSelf, iString, LOWORD(wParam), str);
 
     if (iString < infoPtr->nNumStrings)
     {
@@ -5235,9 +5126,8 @@ static LRESULT TOOLBAR_Unkwn45D(HWND hwnd, WPARAM wParam, LPARAM lParam)
  * caller to specify a reason why the hot item changed (rather than just the
  * HICF_OTHER that TB_SETHOTITEM sends). */
 static LRESULT
-TOOLBAR_SetHotItem2 (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetHotItem2 (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     INT nOldHotItem = infoPtr->nHotItem;
 
     TRACE("old item=%d, new item=%d, flags=%08x\n",
@@ -5259,34 +5149,29 @@ TOOLBAR_SetHotItem2 (HWND hwnd, WPARAM wParam, LPARAM lParam)
 /* Sets the toolbar global iListGap parameter which controls the amount of
  * spacing between the image and the text of buttons for TBSTYLE_LIST
  * toolbars. */
-static LRESULT TOOLBAR_SetListGap(HWND hwnd, WPARAM wParam)
+static LRESULT TOOLBAR_SetListGap(TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
-
-    TRACE("hwnd=%p iListGap=%ld\n", hwnd, wParam);
+    TRACE("hwnd=%p iListGap=%ld\n", infoPtr->hwndSelf, wParam);
     
     infoPtr->iListGap = (INT)wParam;
 
-    InvalidateRect(hwnd, NULL, TRUE);
+    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
 
     return 0;
 }
 
 /* Returns the number of maximum number of image lists associated with the
  * various states. */
-static LRESULT TOOLBAR_GetImageListCount(HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT TOOLBAR_GetImageListCount(const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
-
-    TRACE("hwnd=%p wParam %08lx lParam %08lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p wParam %08lx lParam %08lx\n", infoPtr->hwndSelf, wParam, lParam);
 
     return max(infoPtr->cimlDef, max(infoPtr->cimlHot, infoPtr->cimlDis));
 }
 
 static LRESULT
-TOOLBAR_GetIdealSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_GetIdealSize (const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPSIZE lpsize = (LPSIZE)lParam;
 
     if (lpsize == NULL)
@@ -5310,9 +5195,9 @@ TOOLBAR_GetIdealSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	}
 	else if(HIWORD(lpsize->cx)) {
 	    RECT rc;
-	    HWND hwndParent = GetParent(hwnd);
+	    HWND hwndParent = GetParent(infoPtr->hwndSelf);
 
-	    GetWindowRect(hwnd, &rc);
+	    GetWindowRect(infoPtr->hwndSelf, &rc);
 	    MapWindowPoints(0, hwndParent, (LPPOINT)&rc, 2);
             TRACE("mapped to (%s)\n", wine_dbgstr_rect(&rc));
 	    lpsize->cx = max(rc.right-rc.left,
@@ -5346,7 +5231,7 @@ static LRESULT TOOLBAR_Unkwn464(HWND hwnd, WPARAM wParam, LPARAM lParam)
 static LRESULT
 TOOLBAR_Create (HWND hwnd, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
+    TOOLBAR_INFO *infoPtr = (TOOLBAR_INFO *)GetWindowLongPtrW(hwnd, 0);
     DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
     LOGFONTW logFont;
 
@@ -5394,17 +5279,15 @@ TOOLBAR_Create (HWND hwnd, LPARAM lParam)
     
     OpenThemeData (hwnd, themeClass);
 
-    TOOLBAR_CheckStyle (hwnd, dwStyle);
+    TOOLBAR_CheckStyle (infoPtr, dwStyle);
 
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_Destroy (HWND hwnd)
+TOOLBAR_Destroy (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     /* delete tooltip control */
     if (infoPtr->hwndToolTip)
 	DestroyWindow (infoPtr->hwndToolTip);
@@ -5436,24 +5319,23 @@ TOOLBAR_Destroy (HWND hwnd)
     /* delete default font */
     DeleteObject (infoPtr->hDefaultFont);
         
-    CloseThemeData (GetWindowTheme (hwnd));
+    CloseThemeData (GetWindowTheme (infoPtr->hwndSelf));
 
     /* free toolbar info data */
     Free (infoPtr);
-    SetWindowLongPtrW (hwnd, 0, 0);
+    SetWindowLongPtrW (infoPtr->hwndSelf, 0, 0);
 
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_EraseBackground (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     NMTBCUSTOMDRAW tbcd;
     INT ret = FALSE;
     DWORD ntfret;
-    HTHEME theme = GetWindowTheme (hwnd);
+    HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
     DWORD dwEraseCustDraw = 0;
 
     /* the app has told us not to redraw the toolbar */
@@ -5476,7 +5358,7 @@ TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
 		return TRUE;
 	    default:
 		FIXME("[%p] response %d not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
-		      hwnd, ntfret);
+		      infoPtr->hwndSelf, ntfret);
 	    }
     }
 
@@ -5490,14 +5372,14 @@ TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 	pt.x = 0;
 	pt.y = 0;
-	parent = GetParent(hwnd);
-	MapWindowPoints(hwnd, parent, &pt, 1);
+	parent = GetParent(infoPtr->hwndSelf);
+	MapWindowPoints(infoPtr->hwndSelf, parent, &pt, 1);
 	OffsetWindowOrgEx (hdc, pt.x, pt.y, &ptorig);
 	ret = SendMessageW (parent, WM_ERASEBKGND, wParam, lParam);
 	SetWindowOrgEx (hdc, ptorig.x, ptorig.y, 0);
     }
     if (!ret)
-	ret = DefWindowProcW (hwnd, WM_ERASEBKGND, wParam, lParam);
+	ret = DefWindowProcW (infoPtr->hwndSelf, WM_ERASEBKGND, wParam, lParam);
 
     if (dwEraseCustDraw & CDRF_NOTIFYPOSTERASE) {
 	ZeroMemory (&tbcd, sizeof(NMTBCUSTOMDRAW));
@@ -5513,7 +5395,7 @@ TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
 		return TRUE;
 	    default:
 		FIXME("[%p] response %d not handled to NM_CUSTOMDRAW (CDDS_POSTERASE)\n",
-		      hwnd, ntfret);
+		      infoPtr->hwndSelf, ntfret);
 	    }
     }
     return ret;
@@ -5521,10 +5403,8 @@ TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_GetFont (HWND hwnd)
+TOOLBAR_GetFont (const TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     return (LRESULT)infoPtr->hFont;
 }
 
@@ -5563,16 +5443,15 @@ TOOLBAR_SetRelativeHotItem(TOOLBAR_INFO *infoPtr, INT iDirection, DWORD dwReason
 }
 
 static LRESULT
-TOOLBAR_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_KeyDown (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     NMKEY nmkey;
 
     nmkey.nVKey = (UINT)wParam;
     nmkey.uFlags = HIWORD(lParam);
 
     if (TOOLBAR_SendNotify(&nmkey.hdr, infoPtr, NM_KEYDOWN))
-        return DefWindowProcW(hwnd, WM_KEYDOWN, wParam, lParam);
+        return DefWindowProcW(infoPtr->hwndSelf, WM_KEYDOWN, wParam, lParam);
 
     switch ((UINT)wParam)
     {
@@ -5591,7 +5470,7 @@ TOOLBAR_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
         {
             SendMessageW (infoPtr->hwndNotify, WM_COMMAND,
                 MAKEWPARAM(infoPtr->buttons[infoPtr->nHotItem].idCommand, BN_CLICKED),
-                (LPARAM)hwnd);
+                (LPARAM)infoPtr->hwndSelf);
         }
         break;
     }
@@ -5601,28 +5480,27 @@ TOOLBAR_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_LButtonDblClk (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_LButtonDblClk (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
     POINT pt;
     INT   nHit;
 
     pt.x = (short)LOWORD(lParam);
     pt.y = (short)HIWORD(lParam);
-    nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
+    nHit = TOOLBAR_InternalHitTest (infoPtr, &pt);
 
     if (nHit >= 0)
-        TOOLBAR_LButtonDown (hwnd, wParam, lParam);
-    else if (GetWindowLongW (hwnd, GWL_STYLE) & CCS_ADJUSTABLE)
-	TOOLBAR_Customize (hwnd);
+        TOOLBAR_LButtonDown (infoPtr, wParam, lParam);
+    else if (infoPtr->dwStyle & CCS_ADJUSTABLE)
+	TOOLBAR_Customize (infoPtr);
 
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_LButtonDown (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     POINT pt;
     INT   nHit;
@@ -5638,19 +5516,19 @@ TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
         bDragKeyPressed = (wParam & MK_SHIFT);
 
     if (infoPtr->hwndToolTip)
-	TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+	TOOLBAR_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwndSelf,
 			    WM_LBUTTONDOWN, wParam, lParam);
 
     pt.x = (short)LOWORD(lParam);
     pt.y = (short)HIWORD(lParam);
-    nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
+    nHit = TOOLBAR_InternalHitTest (infoPtr, &pt);
 
     btnPtr = &infoPtr->buttons[nHit];
 
     if ((nHit >= 0) && bDragKeyPressed && (infoPtr->dwStyle & CCS_ADJUSTABLE))
     {
         infoPtr->nButtonDrag = nHit;
-        SetCapture (hwnd);
+        SetCapture (infoPtr->hwndSelf);
         
         /* If drag cursor has not been loaded, load it.
          * Note: it doesn't need to be freed */
@@ -5680,7 +5558,7 @@ TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	        btnPtr->fsState |= TBSTATE_PRESSED;
 	    else
 	        btnPtr->bDropDownPressed = TRUE;
-	    RedrawWindow(hwnd,&btnPtr->rect,0,
+	    RedrawWindow(infoPtr->hwndSelf,&btnPtr->rect,0,
 			RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
 
 	    memset(&nmtb, 0, sizeof(nmtb));
@@ -5699,20 +5577,20 @@ TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
        	            btnPtr->fsState &= ~TBSTATE_PRESSED;
        	        else
        	            btnPtr->bDropDownPressed = FALSE;
-       	        InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+                InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
 
                 /* find and set hot item
                  * NOTE: native doesn't do this, but that is a bug */
                 GetCursorPos(&pt);
-                ScreenToClient(hwnd, &pt);
-                nHit = TOOLBAR_InternalHitTest(hwnd, &pt);
+                ScreenToClient(infoPtr->hwndSelf, &pt);
+                nHit = TOOLBAR_InternalHitTest(infoPtr, &pt);
                 if (!infoPtr->bAnchor || (nHit >= 0))
                     TOOLBAR_SetHotItemEx(infoPtr, nHit, HICF_MOUSE | HICF_LMOUSE);
                 
                 /* remove any left mouse button down or double-click messages
                  * so that we can get a toggle effect on the button */
-                while (PeekMessageW(&msg, hwnd, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE) ||
-                       PeekMessageW(&msg, hwnd, WM_LBUTTONDBLCLK, WM_LBUTTONDBLCLK, PM_REMOVE))
+                while (PeekMessageW(&msg, infoPtr->hwndSelf, WM_LBUTTONDOWN, WM_LBUTTONDOWN, PM_REMOVE) ||
+                       PeekMessageW(&msg, infoPtr->hwndSelf, WM_LBUTTONDBLCLK, WM_LBUTTONDBLCLK, PM_REMOVE))
                     ;
 
 		return 0;
@@ -5728,9 +5606,9 @@ TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
         TOOLBAR_SetHotItemEx(infoPtr, nHit, HICF_MOUSE | HICF_LMOUSE);
 
         if (btnPtr->fsState & TBSTATE_ENABLED)
-	    InvalidateRect(hwnd, &btnPtr->rect, TRUE);
-	UpdateWindow(hwnd);
-	SetCapture (hwnd);
+	    InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
+	UpdateWindow(infoPtr->hwndSelf);
+	SetCapture (infoPtr->hwndSelf);
     }
 
     if (nHit >=0)
@@ -5751,19 +5629,18 @@ TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
         nmmouse.dwItemData = infoPtr->buttons[nmmouse.dwHitInfo].dwData;
     }
 
-    ClientToScreen(hwnd, &pt); 
+    ClientToScreen(infoPtr->hwndSelf, &pt);
     nmmouse.pt = pt;
 
     if (!TOOLBAR_SendNotify(&nmmouse.hdr, infoPtr, NM_LDOWN))
-        return DefWindowProcW(hwnd, WM_LBUTTONDOWN, wParam, lParam);
+        return DefWindowProcW(infoPtr->hwndSelf, WM_LBUTTONDOWN, wParam, lParam);
 
     return 0;
 }
 
 static LRESULT
-TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_LButtonUp (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
     POINT pt;
     INT   nHit;
@@ -5773,12 +5650,12 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
     NMTOOLBARA nmtb;
 
     if (infoPtr->hwndToolTip)
-	TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+	TOOLBAR_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwndSelf,
 			    WM_LBUTTONUP, wParam, lParam);
 
     pt.x = (short)LOWORD(lParam);
     pt.y = (short)HIWORD(lParam);
-    nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
+    nHit = TOOLBAR_InternalHitTest (infoPtr, &pt);
 
     if (!infoPtr->bAnchor || (nHit >= 0))
         TOOLBAR_SetHotItemEx(infoPtr, nHit, HICF_MOUSE | HICF_LMOUSE);
@@ -5792,7 +5669,7 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
         /* reset cursor */
         SetCursor(LoadCursorW(NULL, (LPCWSTR)IDC_ARROW));
 
-        GetClientRect(hwnd, &rcClient);
+        GetClientRect(infoPtr->hwndSelf, &rcClient);
         if (PtInRect(&rcClient, pt))
         {
             INT nButton = -1;
@@ -5810,7 +5687,7 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
                 if (pt.x < (btnPtr->rect.left + (btnPtr->rect.right - btnPtr->rect.left)/2))
                 {
                     if ((nButton > 0) && (infoPtr->buttons[nButton-1].fsStyle & BTNS_SEP))
-                        TOOLBAR_DeleteButton(hwnd, nButton - 1);
+                        TOOLBAR_DeleteButton(infoPtr, nButton - 1);
                 }
                 else /* else insert a separator before the dragged button */
                 {
@@ -5818,7 +5695,7 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
                     memset(&tbb, 0, sizeof(tbb));
                     tbb.fsStyle = BTNS_SEP;
                     tbb.iString = -1;
-                    TOOLBAR_InsertButtonT(hwnd, nButton, (LPARAM)&tbb, TRUE);
+                    TOOLBAR_InsertButtonT(infoPtr, nButton, (LPARAM)&tbb, TRUE);
                 }
             }
             else
@@ -5826,18 +5703,18 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
                 if (nButton == -1)
                 {
                     if ((infoPtr->nNumButtons > 0) && (pt.x < infoPtr->buttons[0].rect.left))
-                        TOOLBAR_MoveButton(hwnd, infoPtr->nButtonDrag, 0);
+                        TOOLBAR_MoveButton(infoPtr, infoPtr->nButtonDrag, 0);
                     else
-                        TOOLBAR_MoveButton(hwnd, infoPtr->nButtonDrag, infoPtr->nNumButtons);
+                        TOOLBAR_MoveButton(infoPtr, infoPtr->nButtonDrag, infoPtr->nNumButtons);
                 }
                 else
-                    TOOLBAR_MoveButton(hwnd, infoPtr->nButtonDrag, nButton);
+                    TOOLBAR_MoveButton(infoPtr, infoPtr->nButtonDrag, nButton);
             }
         }
         else
         {
             TRACE("button %d dragged out of toolbar\n", infoPtr->nButtonDrag);
-            TOOLBAR_DeleteButton(hwnd, (WPARAM)infoPtr->nButtonDrag);
+            TOOLBAR_DeleteButton(infoPtr, (WPARAM)infoPtr->nButtonDrag);
         }
 
         /* button under cursor changed so need to re-set hot item */
@@ -5868,7 +5745,7 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	}
 
         if (nOldIndex != -1)
-            InvalidateRect(hwnd, &infoPtr->buttons[nOldIndex].rect, TRUE);
+            InvalidateRect(infoPtr->hwndSelf, &infoPtr->buttons[nOldIndex].rect, TRUE);
 
 	/*
 	 * now we can ReleaseCapture, which triggers CAPTURECHANGED msg,
@@ -5894,10 +5771,10 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
 	if (btnPtr->fsState & TBSTATE_ENABLED)
 	{
 	    SendMessageW (infoPtr->hwndNotify, WM_COMMAND,
-	      MAKEWPARAM(infoPtr->buttons[nHit].idCommand, BN_CLICKED), (LPARAM)hwnd);
+	      MAKEWPARAM(infoPtr->buttons[nHit].idCommand, BN_CLICKED), (LPARAM)infoPtr->hwndSelf);
 
             /* In case we have just been destroyed... */
-            if(!IsWindow(hwnd))
+            if(!IsWindow(infoPtr->hwndSelf))
                 return 0;
         }
     }
@@ -5914,19 +5791,18 @@ TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
         nmmouse.dwItemData = infoPtr->buttons[nmmouse.dwHitInfo].dwData;
     }
 
-    ClientToScreen(hwnd, &pt); 
+    ClientToScreen(infoPtr->hwndSelf, &pt);
     nmmouse.pt = pt;
 
     if (!TOOLBAR_SendNotify((LPNMHDR)&nmmouse, infoPtr, NM_CLICK))
-        return DefWindowProcW(hwnd, WM_LBUTTONUP, wParam, lParam);
+        return DefWindowProcW(infoPtr->hwndSelf, WM_LBUTTONUP, wParam, lParam);
 
     return 0;
 }
 
 static LRESULT
-TOOLBAR_RButtonUp( HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_RButtonUp(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     INT nHit;
     NMMOUSE nmmouse;
     POINT pt;
@@ -5934,7 +5810,7 @@ TOOLBAR_RButtonUp( HWND hwnd, WPARAM wParam, LPARAM lParam)
     pt.x = (short)LOWORD(lParam);
     pt.y = (short)HIWORD(lParam);
 
-    nHit = TOOLBAR_InternalHitTest(hwnd, &pt);
+    nHit = TOOLBAR_InternalHitTest(infoPtr, &pt);
     nmmouse.dwHitInfo = nHit;
 
     if (nHit < 0) {
@@ -5944,31 +5820,29 @@ TOOLBAR_RButtonUp( HWND hwnd, WPARAM wParam, LPARAM lParam)
 	nmmouse.dwItemData = infoPtr->buttons[nmmouse.dwHitInfo].dwData;
     }
 
-    ClientToScreen(hwnd, &pt); 
+    ClientToScreen(infoPtr->hwndSelf, &pt);
     nmmouse.pt = pt;
 
     if (!TOOLBAR_SendNotify((LPNMHDR)&nmmouse, infoPtr, NM_RCLICK))
-        return DefWindowProcW(hwnd, WM_RBUTTONUP, wParam, lParam);
+        return DefWindowProcW(infoPtr->hwndSelf, WM_RBUTTONUP, wParam, lParam);
 
     return 0;
 }
 
 static LRESULT
-TOOLBAR_RButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_RButtonDblClk( TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     NMHDR nmhdr;
 
     if (!TOOLBAR_SendNotify(&nmhdr, infoPtr, NM_RDBLCLK))
-        return DefWindowProcW(hwnd, WM_RBUTTONDBLCLK, wParam, lParam);
+        return DefWindowProcW(infoPtr->hwndSelf, WM_RBUTTONDBLCLK, wParam, lParam);
 
     return 0;
 }
 
 static LRESULT
-TOOLBAR_CaptureChanged(HWND hwnd)
+TOOLBAR_CaptureChanged(TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     TBUTTON_INFO *btnPtr;
 
     infoPtr->bCaptured = FALSE;
@@ -5981,16 +5855,14 @@ TOOLBAR_CaptureChanged(HWND hwnd)
         infoPtr->nOldHit = -1;
 
         if (btnPtr->fsState & TBSTATE_ENABLED)
-            InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+            InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
     }
     return 0;
 }
 
 static LRESULT
-TOOLBAR_MouseLeave (HWND hwnd)
+TOOLBAR_MouseLeave (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     /* don't remove hot effects when in anchor highlighting mode or when a
      * drop-down button is pressed */
     if (infoPtr->nHotItem >= 0 && !infoPtr->bAnchor)
@@ -6016,7 +5888,7 @@ TOOLBAR_MouseLeave (HWND hwnd)
 
       rc1 = btnPtr->rect;
       InflateRect (&rc1, 1, 1);
-      InvalidateRect (hwnd, &rc1, TRUE);
+      InvalidateRect (infoPtr->hwndSelf, &rc1, TRUE);
     }
 
     if (infoPtr->bCaptured && !infoPtr->bDragOutSent)
@@ -6034,9 +5906,8 @@ TOOLBAR_MouseLeave (HWND hwnd)
 }
 
 static LRESULT
-TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_MouseMove (TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     POINT pt;
     TRACKMOUSEEVENT trackinfo;
     INT   nHit;
@@ -6054,9 +5925,9 @@ TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
         _TrackMouseEvent(&trackinfo);
 
         /* Make sure tracking is enabled so we receive a WM_MOUSELEAVE message */
-        if(trackinfo.hwndTrack != hwnd || !(trackinfo.dwFlags & TME_LEAVE)) {
+        if(trackinfo.hwndTrack != infoPtr->hwndSelf || !(trackinfo.dwFlags & TME_LEAVE)) {
             trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
-            trackinfo.hwndTrack = hwnd;
+            trackinfo.hwndTrack = infoPtr->hwndSelf;
 
             /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
             /* and can properly deactivate the hot toolbar button */
@@ -6065,13 +5936,13 @@ TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
     }
 
     if (infoPtr->hwndToolTip)
-	TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+	TOOLBAR_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwndSelf,
 			    WM_MOUSEMOVE, wParam, lParam);
 
     pt.x = (short)LOWORD(lParam);
     pt.y = (short)HIWORD(lParam);
 
-    nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
+    nHit = TOOLBAR_InternalHitTest (infoPtr, &pt);
 
     if (((infoPtr->dwStyle & TBSTYLE_FLAT) || GetWindowTheme (infoPtr->hwndSelf)) 
         && (!infoPtr->bAnchor || (nHit >= 0)))
@@ -6093,11 +5964,11 @@ TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
             btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
             if (infoPtr->nOldHit == infoPtr->nButtonDown) {
                 btnPtr->fsState &= ~TBSTATE_PRESSED;
-                InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+                InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
             }
             else if (nHit == infoPtr->nButtonDown) {
                 btnPtr->fsState |= TBSTATE_PRESSED;
-                InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+                InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
             }
             infoPtr->nOldHit = nHit;
         }
@@ -6366,9 +6237,8 @@ static LRESULT TOOLBAR_TTGetDispInfo (TOOLBAR_INFO *infoPtr, NMTTDISPINFOW *lpnm
 
 
 static inline LRESULT
-TOOLBAR_Notify (HWND hwnd, LPARAM lParam)
+TOOLBAR_Notify (TOOLBAR_INFO *infoPtr, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     LPNMHDR lpnmh = (LPNMHDR)lParam;
 
     switch (lpnmh->code)
@@ -6439,31 +6309,28 @@ TOOLBAR_NotifyFormat(const TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 
 
 static LRESULT
-TOOLBAR_Paint (HWND hwnd, WPARAM wParam)
+TOOLBAR_Paint (TOOLBAR_INFO *infoPtr, WPARAM wParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
     HDC hdc;
     PAINTSTRUCT ps;
 
     /* fill ps.rcPaint with a default rect */
     ps.rcPaint = infoPtr->rcBound;
 
-    hdc = wParam==0 ? BeginPaint(hwnd, &ps) : (HDC)wParam;
+    hdc = wParam==0 ? BeginPaint(infoPtr->hwndSelf, &ps) : (HDC)wParam;
 
     TRACE("psrect=(%s)\n", wine_dbgstr_rect(&ps.rcPaint));
 
-    TOOLBAR_Refresh (hwnd, hdc, &ps);
-    if (!wParam) EndPaint (hwnd, &ps);
+    TOOLBAR_Refresh (infoPtr, hdc, &ps);
+    if (!wParam) EndPaint (infoPtr->hwndSelf, &ps);
 
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_SetFocus (HWND hwnd)
+TOOLBAR_SetFocus (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     TRACE("nHotItem = %d\n", infoPtr->nHotItem);
 
     /* make first item hot */
@@ -6474,10 +6341,8 @@ TOOLBAR_SetFocus (HWND hwnd)
 }
 
 static LRESULT
-TOOLBAR_SetFont(HWND hwnd, WPARAM wParam, LPARAM lParam)
+TOOLBAR_SetFont(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
-    
     TRACE("font=%p redraw=%ld\n", (HFONT)wParam, lParam);
     
     if (wParam == 0)
@@ -6485,15 +6350,15 @@ TOOLBAR_SetFont(HWND hwnd, WPARAM wParam, LPARAM lParam)
     else
         infoPtr->hFont = (HFONT)wParam;
 
-    TOOLBAR_CalcToolbar(hwnd);
+    TOOLBAR_CalcToolbar(infoPtr);
 
     if (lParam)
-        InvalidateRect(hwnd, NULL, TRUE);
+        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
     return 1;
 }
 
 static LRESULT
-TOOLBAR_SetRedraw (HWND hwnd, WPARAM wParam)
+TOOLBAR_SetRedraw (TOOLBAR_INFO *infoPtr, WPARAM wParam)
      /*****************************************************
       *
       * Function;
@@ -6508,7 +6373,6 @@ TOOLBAR_SetRedraw (HWND hwnd, WPARAM wParam)
       *
       *****************************************************/
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     BOOL oldredraw = infoPtr->bDoRedraw;
 
     TRACE("set to %s\n",
@@ -6522,10 +6386,8 @@ TOOLBAR_SetRedraw (HWND hwnd, WPARAM wParam)
 
 
 static LRESULT
-TOOLBAR_Size (HWND hwnd)
+TOOLBAR_Size (TOOLBAR_INFO *infoPtr)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     TRACE("sizing toolbar!\n");
 
     if (infoPtr->dwExStyle & TBSTYLE_EX_HIDECLIPPEDBUTTONS)
@@ -6535,7 +6397,7 @@ TOOLBAR_Size (HWND hwnd)
         TBUTTON_INFO *btnPtr;
         INT i;
 
-        GetClientRect(hwnd, &client);
+        GetClientRect(infoPtr->hwndSelf, &client);
         if(client.right > infoPtr->client_rect.right)
         {
             min_x = infoPtr->client_rect.right;
@@ -6565,19 +6427,17 @@ TOOLBAR_Size (HWND hwnd)
         for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
             if(IntersectRect(&dummy, &delta_width, &btnPtr->rect) ||
                 IntersectRect(&dummy, &delta_height, &btnPtr->rect))
-                InvalidateRect(hwnd, &btnPtr->rect, TRUE);
+                InvalidateRect(infoPtr->hwndSelf, &btnPtr->rect, TRUE);
     }
-    GetClientRect(hwnd, &infoPtr->client_rect);
-    TOOLBAR_AutoSize(hwnd);
+    GetClientRect(infoPtr->hwndSelf, &infoPtr->client_rect);
+    TOOLBAR_AutoSize(infoPtr);
     return 0;
 }
 
 
 static LRESULT
-TOOLBAR_StyleChanged (HWND hwnd, INT nType, const STYLESTRUCT *lpStyle)
+TOOLBAR_StyleChanged (TOOLBAR_INFO *infoPtr, INT nType, const STYLESTRUCT *lpStyle)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
-
     if (nType == GWL_STYLE)
     {
         DWORD dwOldStyle = infoPtr->dwStyle;
@@ -6587,21 +6447,21 @@ TOOLBAR_StyleChanged (HWND hwnd, INT nType, const STYLESTRUCT *lpStyle)
         else
             infoPtr->dwDTFlags = DT_CENTER | DT_END_ELLIPSIS;
 
-        TOOLBAR_CheckStyle (hwnd, lpStyle->styleNew);
+        TOOLBAR_CheckStyle (infoPtr, lpStyle->styleNew);
 
         TRACE("new style 0x%08x\n", lpStyle->styleNew);
 
         infoPtr->dwStyle = lpStyle->styleNew;
 
         if ((dwOldStyle ^ lpStyle->styleNew) & (TBSTYLE_WRAPABLE | CCS_VERT))
-            TOOLBAR_LayoutToolbar(hwnd);
+            TOOLBAR_LayoutToolbar(infoPtr);
 
         /* only resize if one of the CCS_* styles was changed */
         if ((dwOldStyle ^ lpStyle->styleNew) & COMMON_STYLES)
         {
-            TOOLBAR_AutoSize (hwnd);
+            TOOLBAR_AutoSize (infoPtr);
     
-            InvalidateRect(hwnd, NULL, TRUE);
+            InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
         }
     }
 
@@ -6631,7 +6491,7 @@ static LRESULT theme_changed (HWND hwnd)
 static LRESULT WINAPI
 ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-    TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
+    TOOLBAR_INFO *infoPtr = (TOOLBAR_INFO *)GetWindowLongPtrW(hwnd, 0);
 
     TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n",
 	  hwnd, uMsg, /* SPY_GetMsgName(uMsg), */ wParam, lParam);
@@ -6642,279 +6502,279 @@ ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     switch (uMsg)
     {
 	case TB_ADDBITMAP:
-	    return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
+	    return TOOLBAR_AddBitmap (infoPtr, wParam, lParam);
 
 	case TB_ADDBUTTONSA:
-	    return TOOLBAR_AddButtonsT(hwnd, wParam, lParam, FALSE);
+	    return TOOLBAR_AddButtonsT(infoPtr, wParam, lParam, FALSE);
 
 	case TB_ADDBUTTONSW:
-	    return TOOLBAR_AddButtonsT(hwnd, wParam, lParam, TRUE);
+	    return TOOLBAR_AddButtonsT(infoPtr, wParam, lParam, TRUE);
 
 	case TB_ADDSTRINGA:
-	    return TOOLBAR_AddStringA (hwnd, wParam, lParam);
+	    return TOOLBAR_AddStringA (infoPtr, wParam, lParam);
 
 	case TB_ADDSTRINGW:
-	    return TOOLBAR_AddStringW (hwnd, wParam, lParam);
+	    return TOOLBAR_AddStringW (infoPtr, wParam, lParam);
 
 	case TB_AUTOSIZE:
-	    return TOOLBAR_AutoSize (hwnd);
+	    return TOOLBAR_AutoSize (infoPtr);
 
 	case TB_BUTTONCOUNT:
-	    return TOOLBAR_ButtonCount (hwnd);
+	    return TOOLBAR_ButtonCount (infoPtr);
 
 	case TB_BUTTONSTRUCTSIZE:
-	    return TOOLBAR_ButtonStructSize (hwnd, wParam);
+	    return TOOLBAR_ButtonStructSize (infoPtr, wParam);
 
 	case TB_CHANGEBITMAP:
-	    return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
+	    return TOOLBAR_ChangeBitmap (infoPtr, wParam, lParam);
 
 	case TB_CHECKBUTTON:
-	    return TOOLBAR_CheckButton (hwnd, wParam, lParam);
+	    return TOOLBAR_CheckButton (infoPtr, wParam, lParam);
 
 	case TB_COMMANDTOINDEX:
-	    return TOOLBAR_CommandToIndex (hwnd, wParam);
+	    return TOOLBAR_CommandToIndex (infoPtr, wParam);
 
 	case TB_CUSTOMIZE:
-	    return TOOLBAR_Customize (hwnd);
+	    return TOOLBAR_Customize (infoPtr);
 
 	case TB_DELETEBUTTON:
-	    return TOOLBAR_DeleteButton (hwnd, wParam);
+	    return TOOLBAR_DeleteButton (infoPtr, wParam);
 
 	case TB_ENABLEBUTTON:
-	    return TOOLBAR_EnableButton (hwnd, wParam, lParam);
+	    return TOOLBAR_EnableButton (infoPtr, wParam, lParam);
 
 	case TB_GETANCHORHIGHLIGHT:
-	    return TOOLBAR_GetAnchorHighlight (hwnd);
+	    return TOOLBAR_GetAnchorHighlight (infoPtr);
 
 	case TB_GETBITMAP:
-	    return TOOLBAR_GetBitmap (hwnd, wParam);
+	    return TOOLBAR_GetBitmap (infoPtr, wParam);
 
 	case TB_GETBITMAPFLAGS:
 	    return TOOLBAR_GetBitmapFlags ();
 
 	case TB_GETBUTTON:
-	    return TOOLBAR_GetButton (hwnd, wParam, lParam);
+	    return TOOLBAR_GetButton (infoPtr, wParam, lParam);
 
 	case TB_GETBUTTONINFOA:
-	    return TOOLBAR_GetButtonInfoT(hwnd, wParam, lParam, FALSE);
+	    return TOOLBAR_GetButtonInfoT(infoPtr, wParam, lParam, FALSE);
 
 	case TB_GETBUTTONINFOW:
-	    return TOOLBAR_GetButtonInfoT(hwnd, wParam, lParam, TRUE);
+	    return TOOLBAR_GetButtonInfoT(infoPtr, wParam, lParam, TRUE);
 
 	case TB_GETBUTTONSIZE:
-	    return TOOLBAR_GetButtonSize (hwnd);
+	    return TOOLBAR_GetButtonSize (infoPtr);
 
 	case TB_GETBUTTONTEXTA:
-	    return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
+	    return TOOLBAR_GetButtonTextA (infoPtr, wParam, lParam);
 
 	case TB_GETBUTTONTEXTW:
-	    return TOOLBAR_GetButtonTextW (hwnd, wParam, lParam);
+	    return TOOLBAR_GetButtonTextW (infoPtr, wParam, lParam);
 
 	case TB_GETDISABLEDIMAGELIST:
-	    return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
+	    return TOOLBAR_GetDisabledImageList (infoPtr, wParam, lParam);
 
 	case TB_GETEXTENDEDSTYLE:
-	    return TOOLBAR_GetExtendedStyle (hwnd);
+	    return TOOLBAR_GetExtendedStyle (infoPtr);
 
 	case TB_GETHOTIMAGELIST:
-	    return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
+	    return TOOLBAR_GetHotImageList (infoPtr, wParam, lParam);
 
 	case TB_GETHOTITEM:
-	    return TOOLBAR_GetHotItem (hwnd);
+	    return TOOLBAR_GetHotItem (infoPtr);
 
 	case TB_GETIMAGELIST:
-	    return TOOLBAR_GetDefImageList (hwnd, wParam, lParam);
+	    return TOOLBAR_GetDefImageList (infoPtr, wParam, lParam);
 
 	case TB_GETINSERTMARK:
-	    return TOOLBAR_GetInsertMark (hwnd, lParam);
+	    return TOOLBAR_GetInsertMark (infoPtr, lParam);
 
 	case TB_GETINSERTMARKCOLOR:
-	    return TOOLBAR_GetInsertMarkColor (hwnd);
+	    return TOOLBAR_GetInsertMarkColor (infoPtr);
 
 	case TB_GETITEMRECT:
-	    return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
+	    return TOOLBAR_GetItemRect (infoPtr, wParam, lParam);
 
 	case TB_GETMAXSIZE:
-	    return TOOLBAR_GetMaxSize (hwnd, lParam);
+	    return TOOLBAR_GetMaxSize (infoPtr, lParam);
 
 /*	case TB_GETOBJECT:			*/ /* 4.71 */
 
 	case TB_GETPADDING:
-	    return TOOLBAR_GetPadding (hwnd);
+	    return TOOLBAR_GetPadding (infoPtr);
 
 	case TB_GETRECT:
-	    return TOOLBAR_GetRect (hwnd, wParam, lParam);
+	    return TOOLBAR_GetRect (infoPtr, wParam, lParam);
 
 	case TB_GETROWS:
-	    return TOOLBAR_GetRows (hwnd);
+	    return TOOLBAR_GetRows (infoPtr);
 
 	case TB_GETSTATE:
-	    return TOOLBAR_GetState (hwnd, wParam);
+	    return TOOLBAR_GetState (infoPtr, wParam);
 
 	case TB_GETSTRINGA:
-        return TOOLBAR_GetStringA (hwnd, wParam, lParam);
+            return TOOLBAR_GetStringA (infoPtr, wParam, lParam);
 
 	case TB_GETSTRINGW:
-	    return TOOLBAR_GetStringW (hwnd, wParam, lParam);
+	    return TOOLBAR_GetStringW (infoPtr, wParam, lParam);
 
 	case TB_GETSTYLE:
-	    return TOOLBAR_GetStyle (hwnd);
+	    return TOOLBAR_GetStyle (infoPtr);
 
 	case TB_GETTEXTROWS:
-	    return TOOLBAR_GetTextRows (hwnd);
+	    return TOOLBAR_GetTextRows (infoPtr);
 
 	case TB_GETTOOLTIPS:
-	    return TOOLBAR_GetToolTips (hwnd);
+	    return TOOLBAR_GetToolTips (infoPtr);
 
 	case TB_GETUNICODEFORMAT:
-	    return TOOLBAR_GetUnicodeFormat (hwnd);
+	    return TOOLBAR_GetUnicodeFormat (infoPtr);
 
 	case TB_HIDEBUTTON:
-	    return TOOLBAR_HideButton (hwnd, wParam, lParam);
+	    return TOOLBAR_HideButton (infoPtr, wParam, lParam);
 
 	case TB_HITTEST:
-	    return TOOLBAR_HitTest (hwnd, lParam);
+	    return TOOLBAR_HitTest (infoPtr, lParam);
 
 	case TB_INDETERMINATE:
-	    return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
+	    return TOOLBAR_Indeterminate (infoPtr, wParam, lParam);
 
 	case TB_INSERTBUTTONA:
-	    return TOOLBAR_InsertButtonT(hwnd, wParam, lParam, FALSE);
+	    return TOOLBAR_InsertButtonT(infoPtr, wParam, lParam, FALSE);
 
 	case TB_INSERTBUTTONW:
-	    return TOOLBAR_InsertButtonT(hwnd, wParam, lParam, TRUE);
+	    return TOOLBAR_InsertButtonT(infoPtr, wParam, lParam, TRUE);
 
 /*	case TB_INSERTMARKHITTEST:		*/ /* 4.71 */
 
 	case TB_ISBUTTONCHECKED:
-	    return TOOLBAR_IsButtonChecked (hwnd, wParam);
+	    return TOOLBAR_IsButtonChecked (infoPtr, wParam);
 
 	case TB_ISBUTTONENABLED:
-	    return TOOLBAR_IsButtonEnabled (hwnd, wParam);
+	    return TOOLBAR_IsButtonEnabled (infoPtr, wParam);
 
 	case TB_ISBUTTONHIDDEN:
-	    return TOOLBAR_IsButtonHidden (hwnd, wParam);
+	    return TOOLBAR_IsButtonHidden (infoPtr, wParam);
 
 	case TB_ISBUTTONHIGHLIGHTED:
-	    return TOOLBAR_IsButtonHighlighted (hwnd, wParam);
+	    return TOOLBAR_IsButtonHighlighted (infoPtr, wParam);
 
 	case TB_ISBUTTONINDETERMINATE:
-	    return TOOLBAR_IsButtonIndeterminate (hwnd, wParam);
+	    return TOOLBAR_IsButtonIndeterminate (infoPtr, wParam);
 
 	case TB_ISBUTTONPRESSED:
-	    return TOOLBAR_IsButtonPressed (hwnd, wParam);
+	    return TOOLBAR_IsButtonPressed (infoPtr, wParam);
 
 	case TB_LOADIMAGES:
-	    return TOOLBAR_LoadImages (hwnd, wParam, lParam);
+	    return TOOLBAR_LoadImages (infoPtr, wParam, lParam);
 
 	case TB_MAPACCELERATORA:
 	case TB_MAPACCELERATORW:
-	    return TOOLBAR_MapAccelerator (hwnd, wParam, lParam);
+	    return TOOLBAR_MapAccelerator (infoPtr, wParam, lParam);
 
 	case TB_MARKBUTTON:
-	    return TOOLBAR_MarkButton (hwnd, wParam, lParam);
+	    return TOOLBAR_MarkButton (infoPtr, wParam, lParam);
 
 	case TB_MOVEBUTTON:
-	    return TOOLBAR_MoveButton (hwnd, wParam, lParam);
+	    return TOOLBAR_MoveButton (infoPtr, wParam, lParam);
 
 	case TB_PRESSBUTTON:
-	    return TOOLBAR_PressButton (hwnd, wParam, lParam);
+	    return TOOLBAR_PressButton (infoPtr, wParam, lParam);
 
 	case TB_REPLACEBITMAP:
-            return TOOLBAR_ReplaceBitmap (hwnd, lParam);
+            return TOOLBAR_ReplaceBitmap (infoPtr, lParam);
 
 	case TB_SAVERESTOREA:
-	    return TOOLBAR_SaveRestoreA (hwnd, wParam, (LPTBSAVEPARAMSA)lParam);
+	    return TOOLBAR_SaveRestoreA (infoPtr, wParam, (LPTBSAVEPARAMSA)lParam);
 
 	case TB_SAVERESTOREW:
-	    return TOOLBAR_SaveRestoreW (hwnd, wParam, (LPTBSAVEPARAMSW)lParam);
+	    return TOOLBAR_SaveRestoreW (infoPtr, wParam, (LPTBSAVEPARAMSW)lParam);
 
 	case TB_SETANCHORHIGHLIGHT:
-	    return TOOLBAR_SetAnchorHighlight (hwnd, wParam);
+	    return TOOLBAR_SetAnchorHighlight (infoPtr, wParam);
 
 	case TB_SETBITMAPSIZE:
-	    return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
+	    return TOOLBAR_SetBitmapSize (infoPtr, wParam, lParam);
 
 	case TB_SETBUTTONINFOA:
-	    return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
+	    return TOOLBAR_SetButtonInfoA (infoPtr, wParam, lParam);
 
 	case TB_SETBUTTONINFOW:
-	    return TOOLBAR_SetButtonInfoW (hwnd, wParam, lParam);
+	    return TOOLBAR_SetButtonInfoW (infoPtr, wParam, lParam);
 
 	case TB_SETBUTTONSIZE:
-	    return TOOLBAR_SetButtonSize (hwnd, lParam);
+	    return TOOLBAR_SetButtonSize (infoPtr, lParam);
 
 	case TB_SETBUTTONWIDTH:
-	    return TOOLBAR_SetButtonWidth (hwnd, lParam);
+	    return TOOLBAR_SetButtonWidth (infoPtr, lParam);
 
 	case TB_SETCMDID:
-	    return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
+	    return TOOLBAR_SetCmdId (infoPtr, wParam, lParam);
 
 	case TB_SETDISABLEDIMAGELIST:
-	    return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
+	    return TOOLBAR_SetDisabledImageList (infoPtr, wParam, lParam);
 
 	case TB_SETDRAWTEXTFLAGS:
-	    return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
+	    return TOOLBAR_SetDrawTextFlags (infoPtr, wParam, lParam);
 
 	case TB_SETEXTENDEDSTYLE:
-	    return TOOLBAR_SetExtendedStyle (hwnd, lParam);
+	    return TOOLBAR_SetExtendedStyle (infoPtr, lParam);
 
 	case TB_SETHOTIMAGELIST:
-	    return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
+	    return TOOLBAR_SetHotImageList (infoPtr, wParam, lParam);
 
 	case TB_SETHOTITEM:
-	    return TOOLBAR_SetHotItem (hwnd, wParam);
+	    return TOOLBAR_SetHotItem (infoPtr, wParam);
 
 	case TB_SETIMAGELIST:
-	    return TOOLBAR_SetImageList (hwnd, wParam, lParam);
+	    return TOOLBAR_SetImageList (infoPtr, wParam, lParam);
 
 	case TB_SETINDENT:
-	    return TOOLBAR_SetIndent (hwnd, wParam);
+	    return TOOLBAR_SetIndent (infoPtr, wParam);
 
 	case TB_SETINSERTMARK:
-	    return TOOLBAR_SetInsertMark (hwnd, lParam);
+	    return TOOLBAR_SetInsertMark (infoPtr, lParam);
 
 	case TB_SETINSERTMARKCOLOR:
-	    return TOOLBAR_SetInsertMarkColor (hwnd, lParam);
+	    return TOOLBAR_SetInsertMarkColor (infoPtr, lParam);
 
 	case TB_SETMAXTEXTROWS:
-	    return TOOLBAR_SetMaxTextRows (hwnd, wParam);
+	    return TOOLBAR_SetMaxTextRows (infoPtr, wParam);
 
 	case TB_SETPADDING:
-	    return TOOLBAR_SetPadding (hwnd, lParam);
+	    return TOOLBAR_SetPadding (infoPtr, lParam);
 
 	case TB_SETPARENT:
-	    return TOOLBAR_SetParent (hwnd, wParam);
+	    return TOOLBAR_SetParent (infoPtr, wParam);
 
 	case TB_SETROWS:
-	    return TOOLBAR_SetRows (hwnd, wParam, lParam);
+	    return TOOLBAR_SetRows (infoPtr, wParam, lParam);
 
 	case TB_SETSTATE:
-	    return TOOLBAR_SetState (hwnd, wParam, lParam);
+	    return TOOLBAR_SetState (infoPtr, wParam, lParam);
 
 	case TB_SETSTYLE:
-	    return TOOLBAR_SetStyle (hwnd, lParam);
+	    return TOOLBAR_SetStyle (infoPtr, lParam);
 
 	case TB_SETTOOLTIPS:
-	    return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
+	    return TOOLBAR_SetToolTips (infoPtr, wParam, lParam);
 
 	case TB_SETUNICODEFORMAT:
-	    return TOOLBAR_SetUnicodeFormat (hwnd, wParam);
+	    return TOOLBAR_SetUnicodeFormat (infoPtr, wParam);
 
 	case TB_UNKWN45D:
 	    return TOOLBAR_Unkwn45D(hwnd, wParam, lParam);
 
 	case TB_SETHOTITEM2:
-	    return TOOLBAR_SetHotItem2 (hwnd, wParam, lParam);
+	    return TOOLBAR_SetHotItem2 (infoPtr, wParam, lParam);
 
 	case TB_SETLISTGAP:
-	    return TOOLBAR_SetListGap(hwnd, wParam);
+	    return TOOLBAR_SetListGap(infoPtr, wParam);
 
 	case TB_GETIMAGELISTCOUNT:
-	    return TOOLBAR_GetImageListCount(hwnd, wParam, lParam);
+	    return TOOLBAR_GetImageListCount(infoPtr, wParam, lParam);
 
 	case TB_GETIDEALSIZE:
-	    return TOOLBAR_GetIdealSize (hwnd, wParam, lParam);
+	    return TOOLBAR_GetIdealSize (infoPtr, wParam, lParam);
 
 	case TB_UNKWN464:
 	    return TOOLBAR_Unkwn464(hwnd, wParam, lParam);
@@ -6923,17 +6783,17 @@ ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 
 /*	case TB_GETCOLORSCHEME:			*/ /* identical to CCM_ */
 	case CCM_GETCOLORSCHEME:
-	    return TOOLBAR_GetColorScheme (hwnd, (LPCOLORSCHEME)lParam);
+	    return TOOLBAR_GetColorScheme (infoPtr, (LPCOLORSCHEME)lParam);
 
 /*	case TB_SETCOLORSCHEME:			*/ /* identical to CCM_ */
 	case CCM_SETCOLORSCHEME:
-	    return TOOLBAR_SetColorScheme (hwnd, (LPCOLORSCHEME)lParam);
+	    return TOOLBAR_SetColorScheme (infoPtr, (LPCOLORSCHEME)lParam);
 
 	case CCM_GETVERSION:
-	    return TOOLBAR_GetVersion (hwnd);
+	    return TOOLBAR_GetVersion (infoPtr);
 
 	case CCM_SETVERSION:
-	    return TOOLBAR_SetVersion (hwnd, (INT)wParam);
+	    return TOOLBAR_SetVersion (infoPtr, (INT)wParam);
 
 
 /*	case WM_CHAR: */
@@ -6942,42 +6802,42 @@ ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 	    return TOOLBAR_Create (hwnd, lParam);
 
 	case WM_DESTROY:
-	  return TOOLBAR_Destroy (hwnd);
+	  return TOOLBAR_Destroy (infoPtr);
 
 	case WM_ERASEBKGND:
-	    return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
+	    return TOOLBAR_EraseBackground (infoPtr, wParam, lParam);
 
 	case WM_GETFONT:
-		return TOOLBAR_GetFont (hwnd);
+		return TOOLBAR_GetFont (infoPtr);
 
 	case WM_KEYDOWN:
-	    return TOOLBAR_KeyDown (hwnd, wParam, lParam);
+	    return TOOLBAR_KeyDown (infoPtr, wParam, lParam);
 
 /*	case WM_KILLFOCUS: */
 
 	case WM_LBUTTONDBLCLK:
-	    return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
+	    return TOOLBAR_LButtonDblClk (infoPtr, wParam, lParam);
 
 	case WM_LBUTTONDOWN:
-	    return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
+	    return TOOLBAR_LButtonDown (infoPtr, wParam, lParam);
 
 	case WM_LBUTTONUP:
-	    return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
+	    return TOOLBAR_LButtonUp (infoPtr, wParam, lParam);
 
 	case WM_RBUTTONUP:
-	    return TOOLBAR_RButtonUp (hwnd, wParam, lParam);
+	    return TOOLBAR_RButtonUp (infoPtr, wParam, lParam);
 
 	case WM_RBUTTONDBLCLK:
-	    return TOOLBAR_RButtonDblClk (hwnd, wParam, lParam);
+	    return TOOLBAR_RButtonDblClk (infoPtr, wParam, lParam);
 
 	case WM_MOUSEMOVE:
-	    return TOOLBAR_MouseMove (hwnd, wParam, lParam);
+	    return TOOLBAR_MouseMove (infoPtr, wParam, lParam);
 
 	case WM_MOUSELEAVE:
-	    return TOOLBAR_MouseLeave (hwnd);
+	    return TOOLBAR_MouseLeave (infoPtr);
 
 	case WM_CAPTURECHANGED:
-	    return TOOLBAR_CaptureChanged(hwnd);
+	    return TOOLBAR_CaptureChanged(infoPtr);
 
 	case WM_NCACTIVATE:
 	    return TOOLBAR_NCActivate (hwnd, wParam, lParam);
@@ -6992,29 +6852,29 @@ ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 	    return TOOLBAR_NCPaint (hwnd, wParam, lParam);
 
 	case WM_NOTIFY:
-	    return TOOLBAR_Notify (hwnd, lParam);
+	    return TOOLBAR_Notify (infoPtr, lParam);
 
 	case WM_NOTIFYFORMAT:
 	    return TOOLBAR_NotifyFormat (infoPtr, wParam, lParam);
 
 	case WM_PRINTCLIENT:
 	case WM_PAINT:
-	    return TOOLBAR_Paint (hwnd, wParam);
+	    return TOOLBAR_Paint (infoPtr, wParam);
 
 	case WM_SETFOCUS:
-	    return TOOLBAR_SetFocus (hwnd);
+	    return TOOLBAR_SetFocus (infoPtr);
 
 	case WM_SETFONT:
-            return TOOLBAR_SetFont(hwnd, wParam, lParam);
+            return TOOLBAR_SetFont(infoPtr, wParam, lParam);
 
 	case WM_SETREDRAW:
-	    return TOOLBAR_SetRedraw (hwnd, wParam);
+	    return TOOLBAR_SetRedraw (infoPtr, wParam);
 
 	case WM_SIZE:
-	    return TOOLBAR_Size (hwnd);
+	    return TOOLBAR_Size (infoPtr);
 
 	case WM_STYLECHANGED:
-	    return TOOLBAR_StyleChanged (hwnd, (INT)wParam, (LPSTYLESTRUCT)lParam);
+	    return TOOLBAR_StyleChanged (infoPtr, (INT)wParam, (LPSTYLESTRUCT)lParam);
 
 	case WM_SYSCOLORCHANGE:
 	    return TOOLBAR_SysColorChange ();
diff --git a/reactos/dll/win32/comctl32/tooltips.c b/reactos/dll/win32/comctl32/tooltips.c
index ec5e5ead133..fe640848ed0 100644
--- a/reactos/dll/win32/comctl32/tooltips.c
+++ b/reactos/dll/win32/comctl32/tooltips.c
@@ -189,8 +189,8 @@ TOOLTIPS_InitSystemSettings (TOOLTIPS_INFO *infoPtr)
 {
     NONCLIENTMETRICSW nclm;
 
-    infoPtr->clrBk   = GetSysColor (COLOR_INFOBK);
-    infoPtr->clrText = GetSysColor (COLOR_INFOTEXT);
+    infoPtr->clrBk   = comctl32_color.clrInfoBk;
+    infoPtr->clrText = comctl32_color.clrInfoText;
 
     DeleteObject (infoPtr->hFont);
     nclm.cbSize = sizeof(nclm);
@@ -2864,6 +2864,10 @@ TOOLTIPS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 	case WM_SETFONT:
 	    return TOOLTIPS_SetFont (hwnd, wParam, lParam);
 
+	case WM_SYSCOLORCHANGE:
+	    COMCTL32_RefreshSysColors();
+	    return 0;
+
 	case WM_TIMER:
 	    return TOOLTIPS_Timer (hwnd, wParam, lParam);
 
diff --git a/reactos/dll/win32/comctl32/treeview.c b/reactos/dll/win32/comctl32/treeview.c
index 093b416e0d8..cfd25242a1d 100644
--- a/reactos/dll/win32/comctl32/treeview.c
+++ b/reactos/dll/win32/comctl32/treeview.c
@@ -2306,7 +2306,7 @@ TREEVIEW_DrawItemLines(const TREEVIEW_INFO *infoPtr, HDC hdc, const TREEVIEW_ITE
 		 & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
 		> TVS_LINESATROOT);
     HBRUSH hbr, hbrOld;
-    COLORREF clrBk = infoPtr->clrBk == -1 ? GetSysColor(COLOR_WINDOW):
+    COLORREF clrBk = infoPtr->clrBk == -1 ? comctl32_color.clrWindow:
                                             infoPtr->clrBk;
 
     if (!lar && item->iLevel == 0)
@@ -2460,26 +2460,26 @@ TREEVIEW_DrawItem(const TREEVIEW_INFO *infoPtr, HDC hdc, TREEVIEW_ITEM *wineItem
     {
 	if ((wineItem->state & TVIS_DROPHILITED) || inFocus)
 	{
-	    nmcdhdr.clrTextBk = GetSysColor(COLOR_HIGHLIGHT);
-	    nmcdhdr.clrText   = GetSysColor(COLOR_HIGHLIGHTTEXT);
+	    nmcdhdr.clrTextBk = comctl32_color.clrHighlight;
+	    nmcdhdr.clrText   = comctl32_color.clrHighlightText;
 	}
 	else
 	{
-	    nmcdhdr.clrTextBk = GetSysColor(COLOR_BTNFACE);
+	    nmcdhdr.clrTextBk = comctl32_color.clrBtnFace;
 	    if (infoPtr->clrText == -1)
-		nmcdhdr.clrText = GetSysColor(COLOR_WINDOWTEXT);
+		nmcdhdr.clrText = comctl32_color.clrWindowText;
 	    else
 		nmcdhdr.clrText = infoPtr->clrText;
 	}
     }
     else
     {
-	nmcdhdr.clrTextBk = infoPtr->clrBk == -1 ? GetSysColor(COLOR_WINDOW):
+	nmcdhdr.clrTextBk = infoPtr->clrBk == -1 ? comctl32_color.clrWindow:
                                                    infoPtr->clrBk;
 	if ((infoPtr->dwStyle & TVS_TRACKSELECT) && (wineItem == infoPtr->hotItem))
 	    nmcdhdr.clrText = comctl32_color.clrHighlight;
 	else if (infoPtr->clrText == -1)
-	    nmcdhdr.clrText = GetSysColor(COLOR_WINDOWTEXT);
+	    nmcdhdr.clrText = comctl32_color.clrWindowText;
 	else
 	    nmcdhdr.clrText = infoPtr->clrText;
     }
@@ -2786,7 +2786,7 @@ static LRESULT
 TREEVIEW_EraseBackground(const TREEVIEW_INFO *infoPtr, HDC hDC)
 {
     HBRUSH hBrush;
-    COLORREF clrBk = infoPtr->clrBk == -1 ? GetSysColor(COLOR_WINDOW):
+    COLORREF clrBk = infoPtr->clrBk == -1 ? comctl32_color.clrWindow:
                                             infoPtr->clrBk;
     RECT rect;
 
@@ -4890,7 +4890,7 @@ initialize_checkboxes(TREEVIEW_INFO *infoPtr)
 
     SelectObject(hdc, hbmOld);
     nIndex = ImageList_AddMasked(infoPtr->himlState, hbm,
-                                 GetSysColor(COLOR_WINDOW));
+                                 comctl32_color.clrWindow);
     TRACE("checkbox index %d\n", nIndex);
 
     DeleteObject(hbm);
@@ -4954,7 +4954,7 @@ TREEVIEW_Create(HWND hwnd, const CREATESTRUCTW *lpcs)
     infoPtr->clrBk   = -1; /* use system color */
     infoPtr->clrText = -1;	/* use system color */
     infoPtr->clrLine = RGB(128, 128, 128);
-    infoPtr->clrInsertMark = GetSysColor(COLOR_BTNTEXT);
+    infoPtr->clrInsertMark = comctl32_color.clrBtnText;
 
     /* hwndToolTip */
 
@@ -5710,7 +5710,9 @@ TREEVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     case WM_STYLECHANGED:
 	return TREEVIEW_StyleChanged(infoPtr, wParam, lParam);
 
-	/* WM_SYSCOLORCHANGE */
+    case WM_SYSCOLORCHANGE:
+        COMCTL32_RefreshSysColors();
+        return 0;
 
 	/* WM_SYSKEYDOWN */