diff --git a/dlls/comctl32/Makefile.in b/dlls/comctl32/Makefile.in
index 26de9d6..679c0c9 100644
--- a/dlls/comctl32/Makefile.in
+++ b/dlls/comctl32/Makefile.in
@@ -1,4 +1,4 @@
-EXTRADEFS = -D_COMCTL32_ -DWINE_NO_STRICT
+EXTRADEFS = -D_COMCTL32_
 TOPSRCDIR = @top_srcdir@
 TOPOBJDIR = ../..
 SRCDIR    = @srcdir@
diff --git a/dlls/comctl32/animate.c b/dlls/comctl32/animate.c
index a403703..cef888a 100644
--- a/dlls/comctl32/animate.c
+++ b/dlls/comctl32/animate.c
@@ -836,7 +836,7 @@
 
 static LRESULT WINAPI ANIMATE_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hWnd, uMsg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n", hWnd, uMsg, wParam, lParam);
     if (!ANIMATE_GetInfoPtr(hWnd) && (uMsg != WM_NCCREATE))
 	return DefWindowProcA(hWnd, uMsg, wParam, lParam);
     switch (uMsg)
diff --git a/dlls/comctl32/comboex.c b/dlls/comctl32/comboex.c
index edd89fc..1eace05 100644
--- a/dlls/comctl32/comboex.c
+++ b/dlls/comctl32/comboex.c
@@ -324,7 +324,7 @@
     GetTextExtentPointA (mydc, "A", 1, size);
     SelectObject (mydc, ofont);
     ReleaseDC (0, mydc);
-    TRACE("selected font hwnd=%08x, height=%ld\n", nfont, size->cy);
+    TRACE("selected font hwnd=%p, height=%ld\n", nfont, size->cy);
 }
 
 
@@ -1233,7 +1233,7 @@
     NMCOMBOBOXEXW nmcit;
     INT i;
 
-    TRACE("CtlType=%08x, CtlID=%08x, itemID=%08x, hwnd=%x, data=%08lx\n",
+    TRACE("CtlType=%08x, CtlID=%08x, itemID=%08x, hwnd=%p, data=%08lx\n",
 	  dis->CtlType, dis->CtlID, dis->itemID, dis->hwndItem, dis->itemData);
 
     if (dis->itemID >= infoPtr->nb_items) return FALSE;
@@ -1291,7 +1291,7 @@
 	  dis->CtlType, dis->CtlID);
     TRACE("itemID=0x%08x itemAction=0x%08x itemState=0x%08x\n",
 	  dis->itemID, dis->itemAction, dis->itemState);
-    TRACE("hWnd=0x%04x hDC=0x%04x (%d,%d)-(%d,%d) itemData=0x%08lx\n",
+    TRACE("hWnd=%p hDC=%p (%d,%d)-(%d,%d) itemData=0x%08lx\n",
 	  dis->hwndItem, dis->hDC, dis->rcItem.left,
 	  dis->rcItem.top, dis->rcItem.right, dis->rcItem.bottom,
 	  dis->itemData);
@@ -1358,7 +1358,7 @@
 		if (item->pszText)
 		    GetWindowTextW(infoPtr->hwndEdit, item->pszText, len+1);
 
-	       TRACE("edit control hwndEdit=%0x, text len=%d str=%s\n",
+	       TRACE("edit control hwndEdit=%p, text len=%d str=%s\n",
 		     infoPtr->hwndEdit, len, debugstr_txt(item->pszText));
 	    }
 	}
@@ -1552,7 +1552,7 @@
     ReleaseDC (0, hdc);
     mis->itemHeight = mysize.cy + CBE_EXTRA;
 
-    TRACE("adjusted height hwnd=%08x, height=%d\n",
+    TRACE("adjusted height hwnd=%p, height=%d\n",
 	  infoPtr->hwndSelf, mis->itemHeight);
 
     return 0;
@@ -1677,7 +1677,7 @@
     RECT rect;
     LRESULT lret;
 
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx, info_ptr=%p\n",
+    TRACE("hwnd=%p msg=%x wparam=%x lParam=%lx, info_ptr=%p\n",
 	  hwnd, uMsg, wParam, lParam, infoPtr);
 
     if (!infoPtr) return 0;
@@ -1879,7 +1879,7 @@
     POINT pt;
     WCHAR edit_text[260];
 
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx, info_ptr=%p\n",
+    TRACE("hwnd=%p msg=%x wparam=%x lParam=%lx, info_ptr=%p\n",
 	  hwnd, uMsg, wParam, lParam, infoPtr);
 
     if (!infoPtr) return 0;
@@ -2116,7 +2116,7 @@
 {
     COMBOEX_INFO *infoPtr = COMBOEX_GetInfoPtr (hwnd);
 
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
 
     if (!infoPtr) {
 	if (uMsg == WM_CREATE)
diff --git a/dlls/comctl32/comctl32undoc.c b/dlls/comctl32/comctl32undoc.c
index 6bca592..ba77f0f 100644
--- a/dlls/comctl32/comctl32undoc.c
+++ b/dlls/comctl32/comctl32undoc.c
@@ -669,7 +669,7 @@
     if (lpRegNum && (ret != -1))
 	*lpRegNum = 'a' + i;
 
-    TRACE("(%08x, %p, %ld, %p) returning %d\n",
+    TRACE("(%p, %p, %ld, %p) returning %d\n",
 	   hList, lpData, cbData, lpRegNum, ret);
 
     return ret;
@@ -730,7 +730,7 @@
 	mp->realMRU[i] = mp->realMRU[i-1];
     }
     mp->realMRU[0] = replace + 'a';
-    TRACE("(%08x, %p, %ld) adding data, /%c/ now most current\n",
+    TRACE("(%p, %p, %ld) adding data, /%c/ now most current\n",
 	  hList, lpData, cbData, replace+'a');
     ret = replace;
 
@@ -760,7 +760,7 @@
 INT WINAPI
 AddMRUStringW(HANDLE hList, LPCWSTR lpszString)
 {
-    FIXME("(%08x, %s) empty stub!\n", hList, debugstr_w(lpszString));
+    FIXME("(%p, %s) empty stub!\n", hList, debugstr_w(lpszString));
 
     return 0;
 }
@@ -771,7 +771,7 @@
 INT WINAPI
 AddMRUStringA(HANDLE hList, LPCSTR lpszString)
 {
-    FIXME("(%08x, %s) empty stub!\n", hList, debugstr_a(lpszString));
+    FIXME("(%p, %s) empty stub!\n", hList, debugstr_a(lpszString));
 
     return 0;
 }
@@ -791,7 +791,7 @@
 BOOL WINAPI
 DelMRUString(HANDLE hList, INT nItemPos)
 {
-    FIXME("(%08x, %d): stub\n", hList, nItemPos);
+    FIXME("(%p, %d): stub\n", hList, nItemPos);
     return TRUE;
 }
 
@@ -1025,7 +1025,7 @@
     witem = mp->array[desired];
     datasize = min( witem->size, nBufferSize );
     memcpy( lpBuffer, &witem->datastart, datasize);
-    TRACE("(%08x, %d, %p, %ld): returning len=%d\n",
+    TRACE("(%p, %d, %p, %ld): returning len=%d\n",
 	  hList, nItemPos, lpBuffer, nBufferSize, datasize);
     return datasize;
 }
@@ -1058,7 +1058,7 @@
 	WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
 			    lpBuffer, datasize, NULL, NULL);
     }
-    TRACE("(%08x, %d, %p, %ld): returning len=%d\n",
+    TRACE("(%p, %d, %p, %ld): returning len=%d\n",
 	  hList, nItemPos, lpBuffer, nBufferSize, datasize);
     return datasize;
 }
@@ -2225,7 +2225,7 @@
 {
     HDPA hdpa;
 
-    TRACE("(%d 0x%x)\n", nGrow, hHeap);
+    TRACE("(%d %p)\n", nGrow, hHeap);
 
     if (hHeap)
 	hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
@@ -2273,7 +2273,7 @@
     LPNMHDR lpNmh = NULL;
     UINT idFrom = 0;
 
-    TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
+    TRACE("(%p %p %d %p 0x%08lx)\n",
 	   lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
 	   lpNotify->dwParam5);
 
@@ -2326,7 +2326,7 @@
 {
     NOTIFYDATA notify;
 
-    TRACE("(0x%04x 0x%04x %d %p)\n",
+    TRACE("(%p %p %d %p)\n",
 	   hwndTo, hwndFrom, uCode, lpHdr);
 
     notify.hwndFrom = hwndFrom;
@@ -2360,7 +2360,7 @@
     NOTIFYDATA notify;
     HWND hwndNotify;
 
-    TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
+    TRACE("(%p %p %d %p 0x%08lx)\n",
 	   hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
 
     hwndNotify = hwndTo;
@@ -2703,7 +2703,7 @@
 
 BOOL WINAPI COMCTL32_410( HWND hw, DWORD b, DWORD c, DWORD d) {
 
-   FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
+   FIXME("(%p, %lx, %lx, %lx): stub!\n", hw, b, c, d);
 
    return TRUE;
 }
@@ -2717,7 +2717,7 @@
 
 BOOL WINAPI COMCTL32_411( HWND hw, DWORD b, DWORD c) {
 
-   FIXME("(%x, %lx, %lx): stub!\n", hw, b, c);
+   FIXME("(%p, %lx, %lx): stub!\n", hw, b, c);
 
    return TRUE;
 }
@@ -2731,7 +2731,7 @@
 
 BOOL WINAPI COMCTL32_412( HWND hwnd, DWORD b, DWORD c)
 {
-    FIXME("(%x, %lx, %lx): stub!\n", hwnd, b, c);
+    FIXME("(%p, %lx, %lx): stub!\n", hwnd, b, c);
 
     if (IsWindow (hwnd) == FALSE)
 	return FALSE;
@@ -2752,7 +2752,7 @@
 
 BOOL WINAPI COMCTL32_413( HWND hw, DWORD b, DWORD c, DWORD d) {
 
-   FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
+   FIXME("(%p, %lx, %lx, %lx): stub!\n", hw, b, c, d);
 
    return TRUE;
 }
@@ -2768,7 +2768,7 @@
 BOOL WINAPI COMCTL32_415( HWND hwnd, DWORD b, DWORD c, DWORD d, DWORD e)
 {
 
-   FIXME("(%x, %lx, %lx, %lx, %lx): stub!\n", hwnd, b, c, d, e);
+   FIXME("(%p, %lx, %lx, %lx, %lx): stub!\n", hwnd, b, c, d, e);
 
    return TRUE;
 }
diff --git a/dlls/comctl32/commctrl.c b/dlls/comctl32/commctrl.c
index a36d156..c29c40b 100644
--- a/dlls/comctl32/commctrl.c
+++ b/dlls/comctl32/commctrl.c
@@ -142,7 +142,7 @@
 BOOL WINAPI
 COMCTL32_LibMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
-    TRACE("%x,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
+    TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
 
     switch (fdwReason) {
 	case DLL_PROCESS_ATTACH:
@@ -150,7 +150,7 @@
 
             /* create private heap */
             COMCTL32_hHeap = HeapCreate (0, 0x10000, 0);
-            TRACE("Heap created: 0x%x\n", COMCTL32_hHeap);
+            TRACE("Heap created: %p\n", COMCTL32_hHeap);
 
             /* add global subclassing atom (used by 'tooltip' and 'updown') */
             COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtomA ("CC32SubclassInfo");
@@ -215,7 +215,7 @@
 
             /* destroy private heap */
             HeapDestroy (COMCTL32_hHeap);
-            TRACE("Heap destroyed: 0x%x\n", COMCTL32_hHeap);
+            TRACE("Heap destroyed: %p\n", COMCTL32_hHeap);
             COMCTL32_hHeap = (HANDLE)NULL;
             break;
     }
@@ -343,7 +343,7 @@
 {
     LPINT lpMenuId;
 
-    TRACE("%x, %x, %p\n", hwnd, uFlags, lpInfo);
+    TRACE("%p, %x, %p\n", hwnd, uFlags, lpInfo);
 
     if (lpInfo == NULL)
 	return FALSE;
@@ -1066,7 +1066,7 @@
    LPSUBCLASS_INFO stack;
    int newnum, n;
 
-   TRACE ("(%x, %p, %x, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
+   TRACE ("(%p, %p, %x, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
 
    /* Since the window procedure that we set here has two additional arguments,
     * we can't simply set it as the new window procedure of the window. So we
@@ -1160,7 +1160,7 @@
    LPSUBCLASS_INFO stack;
    int n;
 
-   TRACE ("(%x, %p, %x, %p)\n", hWnd, pfnSubclass, uID, pdwRef);
+   TRACE ("(%p, %p, %x, %p)\n", hWnd, pfnSubclass, uID, pdwRef);
 
    /* See if we have been called for this window */
    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
@@ -1198,7 +1198,7 @@
    LPSUBCLASS_INFO stack;
    int n;
 
-   TRACE ("(%x, %p, %x)\n", hWnd, pfnSubclass, uID);
+   TRACE ("(%p, %p, %x)\n", hWnd, pfnSubclass, uID);
 
    /* Find the Subclass to remove */
    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
@@ -1267,7 +1267,7 @@
    /* retrieve our little stack from the Properties */
    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
    if (!stack) {
-      ERR ("Our sub classing stack got erased for %x!! Nothing we can do\n", hWnd);
+      ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
       return 0;
    }
 
diff --git a/dlls/comctl32/datetime.c b/dlls/comctl32/datetime.c
index cc78be6..5464b9c 100644
--- a/dlls/comctl32/datetime.c
+++ b/dlls/comctl32/datetime.c
@@ -880,7 +880,7 @@
     else
         ShowWindow(infoPtr->hMonthCal, SW_SHOW);
 
-    TRACE ("dt:%x mc:%x mc parent:%x, desktop:%x, mcpp:%x\n",
+    TRACE ("dt:%p mc:%p mc parent:%p, desktop:%p, mcpp:%p\n",
               hwnd,infoPtr->hMonthCal,
               GetParent (infoPtr->hMonthCal),
               GetDesktopWindow (),
@@ -931,8 +931,8 @@
  LPNMHDR lpnmh = (LPNMHDR) lParam;
 
  TRACE ("%x,%lx\n",wParam, lParam);
- TRACE ("Got notification %x from %x\n", lpnmh->code, lpnmh->hwndFrom);
- TRACE ("info: %x %x %x\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
+ TRACE ("Got notification %x from %p\n", lpnmh->code, lpnmh->hwndFrom);
+ TRACE ("info: %p %p %p\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
  return 0;
 }
 
@@ -945,8 +945,8 @@
  LPNMHDR lpnmh = (LPNMHDR) lParam;
 
  TRACE ("%x,%lx\n",wParam, lParam);
- TRACE ("Got notification %x from %x\n", lpnmh->code, lpnmh->hwndFrom);
- TRACE ("info: %x %x %x\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
+ TRACE ("Got notification %x from %p\n", lpnmh->code, lpnmh->hwndFrom);
+ TRACE ("info: %p %p %p\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
  return 0;
 }
 
diff --git a/dlls/comctl32/draglist.c b/dlls/comctl32/draglist.c
index 46364c8..90005d3 100644
--- a/dlls/comctl32/draglist.c
+++ b/dlls/comctl32/draglist.c
@@ -39,7 +39,7 @@
  */
 BOOL WINAPI MakeDragList (HWND hwndLB)
 {
-    FIXME("(0x%x)\n", hwndLB);
+    FIXME("(%p)\n", hwndLB);
 
 
     return FALSE;
@@ -50,7 +50,7 @@
  */
 VOID WINAPI DrawInsert (HWND hwndParent, HWND hwndLB, INT nItem)
 {
-    FIXME("(0x%x 0x%x %d)\n", hwndParent, hwndLB, nItem);
+    FIXME("(%p %p %d)\n", hwndParent, hwndLB, nItem);
 
 
 }
@@ -64,7 +64,7 @@
     INT nIndex;
     DWORD dwScrollTime;
 
-    FIXME("(0x%x %ld x %ld %s)\n",
+    FIXME("(%p %ld x %ld %s)\n",
 	   hwndLB, pt.x, pt.y, bAutoScroll ? "TRUE" : "FALSE");
 
     ScreenToClient (hwndLB, &pt);
diff --git a/dlls/comctl32/flatsb.c b/dlls/comctl32/flatsb.c
index a128b3c..ea275e3 100644
--- a/dlls/comctl32/flatsb.c
+++ b/dlls/comctl32/flatsb.c
@@ -53,7 +53,7 @@
  */
 BOOL WINAPI InitializeFlatSB(HWND hwnd)
 {
-    TRACE("[%04x]\n", hwnd);
+    TRACE("[%p]\n", hwnd);
     FIXME("stub\n");
     return FALSE;
 }
@@ -69,7 +69,7 @@
  */
 HRESULT WINAPI UninitializeFlatSB(HWND hwnd)
 {
-    TRACE("[%04x]\n", hwnd);
+    TRACE("[%p]\n", hwnd);
     FIXME("stub\n");
     return S_FALSE;
 }
@@ -85,7 +85,7 @@
 BOOL WINAPI
 FlatSB_GetScrollProp(HWND hwnd, INT propIndex, LPINT prop)
 {
-    TRACE("[%04x] propIndex=%d\n", hwnd, propIndex);
+    TRACE("[%p] propIndex=%d\n", hwnd, propIndex);
     FIXME("stub\n");
     return FALSE;
 }
@@ -96,7 +96,7 @@
 BOOL WINAPI
 FlatSB_SetScrollProp(HWND hwnd, UINT index, INT newValue, BOOL flag)
 {
-    TRACE("[%04x] index=%u newValue=%d flag=%d\n", hwnd, index, newValue, flag);
+    TRACE("[%p] index=%u newValue=%d flag=%d\n", hwnd, index, newValue, flag);
     FIXME("stub\n");
     return FALSE;
 }
@@ -193,7 +193,7 @@
 static LRESULT
 FlatSB_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("[%04x] wParam=%04x lParam=%08lx\n", hwnd, wParam, lParam);
+    TRACE("[%p] wParam=%04x lParam=%08lx\n", hwnd, wParam, lParam);
     return 0;
 }
 
@@ -201,7 +201,7 @@
 static LRESULT
 FlatSB_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("[%04x] wParam=%04x lParam=%08lx\n", hwnd, wParam, lParam);
+    TRACE("[%p] wParam=%04x lParam=%08lx\n", hwnd, wParam, lParam);
     return 0;
 }
 
diff --git a/dlls/comctl32/header.c b/dlls/comctl32/header.c
index 9cb6ee1..c44a528 100644
--- a/dlls/comctl32/header.c
+++ b/dlls/comctl32/header.c
@@ -1651,7 +1651,7 @@
 static LRESULT WINAPI
 HEADER_WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx\n", hwnd, msg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lParam=%lx\n", hwnd, msg, wParam, lParam);
     if (!HEADER_GetInfoPtr (hwnd) && (msg != WM_CREATE))
 	return DefWindowProcA (hwnd, msg, wParam, lParam);
     switch (msg) {
diff --git a/dlls/comctl32/hotkey.c b/dlls/comctl32/hotkey.c
index 3c19e0c..1067579 100644
--- a/dlls/comctl32/hotkey.c
+++ b/dlls/comctl32/hotkey.c
@@ -113,7 +113,7 @@
 
     GetClientRect(infoPtr->hwndSelf, &rc);
 
-    TRACE("(infoPtr=%p hdc=%x)\n", infoPtr, hdc);
+    TRACE("(infoPtr=%p hdc=%p)\n", infoPtr, hdc);
 
     if(!infoPtr->CurrMod && !infoPtr->HotKey) {
 	HOTKEY_DrawHotKey (infoPtr, infoPtr->strNone, 4, &rc, hdc);
@@ -406,7 +406,7 @@
 HOTKEY_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
     HOTKEY_INFO *infoPtr = HOTKEY_GetInfoPtr (hwnd);
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
     if (!infoPtr && (uMsg != WM_CREATE))
         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
     switch (uMsg)
diff --git a/dlls/comctl32/imagelist.c b/dlls/comctl32/imagelist.c
index ddffc8e..4afb9ea 100644
--- a/dlls/comctl32/imagelist.c
+++ b/dlls/comctl32/imagelist.c
@@ -171,7 +171,7 @@
     BITMAP  bmp;
     HBITMAP hOldBitmapImage, hOldBitmap;
 
-    TRACE("himl=%p hbmimage=%x hbmmask=%x\n", himl, hbmImage, hbmMask);
+    TRACE("himl=%p hbmimage=%p hbmmask=%p\n", himl, hbmImage, hbmMask);
     if (!himl || !hbmImage)
         return -1;
 
@@ -283,7 +283,7 @@
     HBITMAP hMaskBitmap=0;
     COLORREF bkColor;
 
-    TRACE("himl=%p hbitmap=%x clrmask=%lx\n", himl, hBitmap, clrMask);
+    TRACE("himl=%p hbitmap=%p clrmask=%lx\n", himl, hBitmap, clrMask);
     if (himl == NULL)
         return -1;
 
@@ -722,7 +722,7 @@
 BOOL WINAPI
 ImageList_DragEnter (HWND hwndLock, INT x, INT y)
 {
-    TRACE("(hwnd=%#x x=%d y=%d)\n", hwndLock, x, y);
+    TRACE("(hwnd=%p x=%d y=%d)\n", hwndLock, x, y);
 
     if (InternalDrag.himl == NULL)
 	return FALSE;
@@ -1096,7 +1096,7 @@
     bIsTransparent = (fStyle & ILD_TRANSPARENT) || clrBk == CLR_NONE;
     bBlend = fStyle & (ILD_BLEND25 | ILD_BLEND50);
 
-    TRACE("hbmMask(0x%08x) iImage(%d) x(%d) y(%d) cx(%d) cy(%d)\n",
+    TRACE("hbmMask(%p) iImage(%d) x(%d) y(%d) cx(%d) cy(%d)\n",
           himl->hbmMask, pimldp->i, pimldp->x, pimldp->y, cx, cy);
 
     /* we will use these DCs to access the images and masks in the ImageList */
@@ -2205,7 +2205,7 @@
     HDC hdcImageList, hdcImage;
     BITMAP bmp;
 
-    TRACE("%p %d %04x %04x\n", himl, i, hbmImage, hbmMask);
+    TRACE("%p %d %p %p\n", himl, i, hbmImage, hbmMask);
 
     if (himl == NULL) {
         ERR("Invalid image list handle!\n");
@@ -2280,7 +2280,7 @@
     ICONINFO  ii;
     BITMAP  bmp;
 
-    TRACE("(0x%lx 0x%x 0x%x)\n", (DWORD)himl, i, hIcon);
+    TRACE("(0x%lx 0x%x %p)\n", (DWORD)himl, i, hIcon);
 
     if (himl == NULL)
 	return -1;
@@ -2310,12 +2310,12 @@
         nIndex = i;
 
     hdcImageList = CreateCompatibleDC (0);
-    TRACE("hdcImageList=0x%x!\n", hdcImageList);
+    TRACE("hdcImageList=%p!\n", hdcImageList);
     if (hdcImageList == 0)
 	ERR("invalid hdcImageList!\n");
 
     hdcImage = CreateCompatibleDC (0);
-    TRACE("hdcImage=0x%x!\n", hdcImage);
+    TRACE("hdcImage=%p!\n", hdcImage);
     if (hdcImage == 0)
 	ERR("invalid hdcImage!\n");
 
diff --git a/dlls/comctl32/ipaddress.c b/dlls/comctl32/ipaddress.c
index b0c2931..752ea67 100644
--- a/dlls/comctl32/ipaddress.c
+++ b/dlls/comctl32/ipaddress.c
@@ -106,12 +106,12 @@
 {
     int i;
 
-    TRACE("(hwnd=%x)\n", hwnd);
+    TRACE("(hwnd=%p)\n", hwnd);
 
     for (i = 0; i < 4; i++)
         if (infoPtr->Part[i].EditHwnd == hwnd) return i;
 
-    ERR("We subclassed the wrong window! (hwnd=%x)\n", hwnd);
+    ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
     return -1;
 }
 
@@ -415,7 +415,7 @@
     INT index, len = 0, startsel, endsel;
     IPPART_INFO *part;
 
-    TRACE("(hwnd=0x%x msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
+    TRACE("(hwnd=%p msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 
     if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
     part = &infoPtr->Part[index];
@@ -494,7 +494,7 @@
 {
     IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
 
-    TRACE("(hwnd=0x%x msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
+    TRACE("(hwnd=%p msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 
     if (!infoPtr && (uMsg != WM_CREATE))
         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
diff --git a/dlls/comctl32/listview.c b/dlls/comctl32/listview.c
index 7b641c4..72974a4 100644
--- a/dlls/comctl32/listview.c
+++ b/dlls/comctl32/listview.c
@@ -339,16 +339,16 @@
 
 /* Dump the LISTVIEW_INFO structure to the debug channel */
 #define LISTVIEW_DUMP(iP) do { \
-  TRACE("hwndSelf=%08x, clrBk=0x%06lx, clrText=0x%06lx, clrTextBk=0x%06lx, ItemHeight=%d, ItemWidth=%d, Style=0x%08lx\n", \
+  TRACE("hwndSelf=%p, clrBk=0x%06lx, clrText=0x%06lx, clrTextBk=0x%06lx, ItemHeight=%d, ItemWidth=%d, Style=0x%08lx\n", \
         iP->hwndSelf, iP->clrBk, iP->clrText, iP->clrTextBk, \
         iP->nItemHeight, iP->nItemWidth, infoPtr->dwStyle); \
-  TRACE("hwndSelf=%08x, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08lx, Focus=%d\n", \
+  TRACE("hwndSelf=%p, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08lx, Focus=%d\n", \
         iP->hwndSelf, iP->himlNormal, iP->himlSmall, iP->himlState, \
         iP->nFocusedItem, iP->nHotItem, iP->dwLvExStyle, iP->bFocus ); \
-  TRACE("hwndSelf=%08x, ntmH=%d, icSz.cx=%ld, icSz.cy=%ld, icSp.cx=%ld, icSp.cy=%ld, notifyFmt=%d\n", \
+  TRACE("hwndSelf=%p, ntmH=%d, icSz.cx=%ld, icSz.cy=%ld, icSp.cx=%ld, icSp.cy=%ld, notifyFmt=%d\n", \
         iP->hwndSelf, iP->ntmHeight, iP->iconSize.cx, iP->iconSize.cy, \
         iP->iconSpacing.cx, iP->iconSpacing.cy, iP->notifyFormat); \
-  TRACE("hwndSelf=%08x, rcList=%s\n", iP->hwndSelf, debugrect(&iP->rcList)); \
+  TRACE("hwndSelf=%p, rcList=%s\n", iP->hwndSelf, debugrect(&iP->rcList)); \
 } while(0)
 
 
@@ -3363,7 +3363,7 @@
 {
     if (!infoPtr->hBkBrush) return FALSE;
 
-    TRACE("(hdc=%x, lprcBox=%s, hBkBrush=%x)\n", hdc, debugrect(lprcBox), infoPtr->hBkBrush);
+    TRACE("(hdc=%p, lprcBox=%s, hBkBrush=%p)\n", hdc, debugrect(lprcBox), infoPtr->hBkBrush);
 
     return FillRect(hdc, lprcBox, infoPtr->hBkBrush);
 }
@@ -3395,7 +3395,7 @@
     HIMAGELIST himl;
     LVITEMW lvItem;
 
-    TRACE("(hdc=%x, nItem=%d, nSubItem=%d, pos=%s)\n", hdc, nItem, nSubItem, debugpoint(&pos));
+    TRACE("(hdc=%p, nItem=%d, nSubItem=%d, pos=%s)\n", hdc, nItem, nSubItem, debugpoint(&pos));
 
     /* get information needed for drawing the item */
     lvItem.mask = LVIF_TEXT | LVIF_IMAGE;
@@ -5060,7 +5060,7 @@
     LVITEMW lvItem;
     RECT label_rect;
 
-    TRACE("(hwnd=%x, nItem=%d, lprc=%p)\n", infoPtr->hwndSelf, nItem, lprc);
+    TRACE("(hwnd=%p, nItem=%d, lprc=%p)\n", infoPtr->hwndSelf, nItem, lprc);
 
     if (!lprc || nItem < 0 || nItem >= infoPtr->nItemCount) return FALSE;
 
@@ -6986,7 +6986,7 @@
 {
     RECT rc;
 
-    TRACE("(hdc=%x)\n", hdc);
+    TRACE("(hdc=%p)\n", hdc);
 
     if (!GetClipBox(hdc, &rc)) return FALSE;
 
@@ -7687,7 +7687,7 @@
  */
 static LRESULT LISTVIEW_NotifyFormat(LISTVIEW_INFO *infoPtr, HWND hwndFrom, INT nCommand)
 {
-  TRACE("(hwndFrom=%x, nCommand=%d)\n", hwndFrom, nCommand);
+  TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom, nCommand);
 
   if (nCommand == NF_REQUERY)
     infoPtr->notifyFormat = SendMessageW(hwndFrom, WM_NOTIFYFORMAT,
@@ -7708,7 +7708,7 @@
  */
 static LRESULT LISTVIEW_Paint(LISTVIEW_INFO *infoPtr, HDC hdc)
 {
-    TRACE("(hdc=%x)\n", hdc);
+    TRACE("(hdc=%p)\n", hdc);
 
     if (hdc) 
 	LISTVIEW_Refresh(infoPtr, hdc);
@@ -7889,7 +7889,7 @@
  */
 static LRESULT LISTVIEW_SetFocus(LISTVIEW_INFO *infoPtr, HWND hwndLoseFocus)
 {
-    TRACE("(hwndLoseFocus=%x)\n", hwndLoseFocus);
+    TRACE("(hwndLoseFocus=%p)\n", hwndLoseFocus);
 
     /* if we have the focus already, there's nothing to do */
     if (infoPtr->bFocus) return 0;
@@ -7925,7 +7925,7 @@
 {
     HFONT oldFont = infoPtr->hFont;
 
-    TRACE("(hfont=%x,redraw=%hu)\n", hFont, fRedraw);
+    TRACE("(hfont=%p,redraw=%hu)\n", hFont, fRedraw);
 
     infoPtr->hFont = hFont ? hFont : infoPtr->hDefaultFont;
     if (infoPtr->hFont == oldFont) return 0;
@@ -8767,7 +8767,7 @@
     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongW(GetParent(hwnd), 0);
     BOOL cancel = FALSE;
 
-    TRACE("(hwnd=%x, uMsg=%x, wParam=%x, lParam=%lx, isW=%d)\n",
+    TRACE("(hwnd=%p, uMsg=%x, wParam=%x, lParam=%lx, isW=%d)\n",
 	  hwnd, uMsg, wParam, lParam, isW);
 
     switch (uMsg)
diff --git a/dlls/comctl32/monthcal.c b/dlls/comctl32/monthcal.c
index 81ecdff..579f6d7 100644
--- a/dlls/comctl32/monthcal.c
+++ b/dlls/comctl32/monthcal.c
@@ -1554,7 +1554,7 @@
   nmhdr.hwndFrom = hwnd;
   nmhdr.idFrom   = GetWindowLongA( hwnd, GWL_ID);
   nmhdr.code     = NM_RELEASEDCAPTURE;
-  TRACE("Sent notification from %x to %x\n", hwnd, GetParent(hwnd));
+  TRACE("Sent notification from %p to %p\n", hwnd, GetParent(hwnd));
 
   SendMessageA(GetParent(hwnd), WM_NOTIFY,
                                 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
@@ -1850,7 +1850,7 @@
 
 static LRESULT MONTHCAL_Size(HWND hwnd, int Width, int Height)
 {
-  TRACE("(hwnd=%x, width=%d, height=%d)\n", hwnd, Width, Height);
+  TRACE("(hwnd=%p, width=%d, height=%d)\n", hwnd, Width, Height);
 
   MONTHCAL_UpdateSize(hwnd);
 
@@ -1928,7 +1928,7 @@
 static LRESULT WINAPI
 MONTHCAL_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-  TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
+  TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
   if (!MONTHCAL_GetInfoPtr(hwnd) && (uMsg != WM_CREATE))
     return DefWindowProcA(hwnd, uMsg, wParam, lParam);
   switch(uMsg)
diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c
index cdf5e7f..d29ffd3 100644
--- a/dlls/comctl32/pager.c
+++ b/dlls/comctl32/pager.c
@@ -231,7 +231,7 @@
 {
     TRACKMOUSEEVENT trackinfo;
 
-    TRACE("[%08x] SetCapture\n", hwnd);
+    TRACE("[%p] SetCapture\n", hwnd);
     SetCapture(hwnd);
     infoPtr->bCapture = TRUE;
 
@@ -260,7 +260,7 @@
 PAGER_ForwardMouse (HWND hwnd, WPARAM wParam)
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x]\n", hwnd);
+    TRACE("[%p]\n", hwnd);
 
     infoPtr->bForward = (BOOL)wParam;
 
@@ -273,7 +273,7 @@
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
     LRESULT btnState = PGF_INVISIBLE;
     INT btn = (INT)lParam;
-    TRACE("[%08x]\n", hwnd);
+    TRACE("[%p]\n", hwnd);
 
     if (btn == PGB_TOPORLEFT)
         btnState = infoPtr->TLbtnState;
@@ -288,7 +288,7 @@
 PAGER_GetPos(HWND hwnd)
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x] returns %d\n", hwnd, infoPtr->nPos);
+    TRACE("[%p] returns %d\n", hwnd, infoPtr->nPos);
     return (LRESULT)infoPtr->nPos;
 }
 
@@ -296,7 +296,7 @@
 PAGER_GetButtonSize(HWND hwnd)
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x] returns %d\n", hwnd, infoPtr->nButtonSize);
+    TRACE("[%p] returns %d\n", hwnd, infoPtr->nButtonSize);
     return (LRESULT)infoPtr->nButtonSize;
 }
 
@@ -304,7 +304,7 @@
 PAGER_GetBorder(HWND hwnd)
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x] returns %d\n", hwnd, infoPtr->nBorder);
+    TRACE("[%p] returns %d\n", hwnd, infoPtr->nBorder);
     return (LRESULT)infoPtr->nBorder;
 }
 
@@ -312,7 +312,7 @@
 PAGER_GetBkColor(HWND hwnd)
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x] returns %06lx\n", hwnd, infoPtr->clrBk);
+    TRACE("[%p] returns %06lx\n", hwnd, infoPtr->clrBk);
     return (LRESULT)infoPtr->clrBk;
 }
 
@@ -332,7 +332,7 @@
 
     *size = getWidth ? nmpgcs.iWidth : nmpgcs.iHeight;
 
-    TRACE("[%08x] PGN_CALCSIZE returns %s=%d\n", hwnd,
+    TRACE("[%p] PGN_CALCSIZE returns %s=%d\n", hwnd,
                   getWidth ? "width" : "height", *size);
 }
 
@@ -356,7 +356,7 @@
             if (infoPtr->nWidth < wndSize)
                 infoPtr->nWidth = wndSize;
 
-            TRACE("[%08x] SWP %dx%d at (%d,%d)\n", hwnd,
+            TRACE("[%p] SWP %dx%d at (%d,%d)\n", hwnd,
                          infoPtr->nWidth, infoPtr->nHeight,
                          -nPos, 0);
             SetWindowPos(infoPtr->hwndChild, 0,
@@ -370,7 +370,7 @@
             if (infoPtr->nHeight < wndSize)
                 infoPtr->nHeight = wndSize;
 
-            TRACE("[%08x] SWP %dx%d at (%d,%d)\n", hwnd,
+            TRACE("[%p] SWP %dx%d at (%d,%d)\n", hwnd,
                          infoPtr->nWidth, infoPtr->nHeight,
                          0, -nPos);
             SetWindowPos(infoPtr->hwndChild, 0,
@@ -412,7 +412,7 @@
             scrollRange = childSize - wndSize + infoPtr->nButtonSize;
     }
 
-    TRACE("[%08x] returns %d\n", hwnd, scrollRange);
+    TRACE("[%p] returns %d\n", hwnd, scrollRange);
     return scrollRange;
 }
 
@@ -524,7 +524,7 @@
     else
         infoPtr->nPos = newPos;
 
-    TRACE("[%08x] pos=%d, oldpos=%d\n", hwnd, infoPtr->nPos, oldPos);
+    TRACE("[%p] pos=%d, oldpos=%d\n", hwnd, infoPtr->nPos, oldPos);
 
     if (infoPtr->nPos != oldPos)
     {
@@ -593,7 +593,7 @@
 
     h = wndRect.bottom - wndRect.top + infoPtr->nButtonSize;
 
-    TRACE("[%08x] infoPtr->nWidth set to %d\n",
+    TRACE("[%p] infoPtr->nWidth set to %d\n",
 	       hwnd, infoPtr->nWidth);
 
     return h;
@@ -624,7 +624,7 @@
 
     w = wndRect.right - wndRect.left + infoPtr->nButtonSize;
 
-    TRACE("[%08x] infoPtr->nHeight set to %d\n",
+    TRACE("[%p] infoPtr->nHeight set to %d\n",
 	       hwnd, infoPtr->nHeight);
 
     return w;
@@ -647,7 +647,7 @@
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
 
-    TRACE("[%08x]\n", hwnd);
+    TRACE("[%p]\n", hwnd);
 
     if (infoPtr->hwndChild)
     {
@@ -676,7 +676,7 @@
     COLORREF clrTemp = infoPtr->clrBk;
 
     infoPtr->clrBk = (COLORREF)lParam;
-    TRACE("[%08x] %06lx\n", hwnd, infoPtr->clrBk);
+    TRACE("[%p] %06lx\n", hwnd, infoPtr->clrBk);
 
     /* the native control seems to do things this way */
     SetWindowPos(hwnd, 0,0,0,0,0,
@@ -696,7 +696,7 @@
     INT nTemp = infoPtr->nBorder;
 
     infoPtr->nBorder = (INT)lParam;
-    TRACE("[%08x] %d\n", hwnd, infoPtr->nBorder);
+    TRACE("[%p] %d\n", hwnd, infoPtr->nBorder);
 
     PAGER_RecalcSize(hwnd);
 
@@ -711,7 +711,7 @@
     INT nTemp = infoPtr->nButtonSize;
 
     infoPtr->nButtonSize = (INT)lParam;
-    TRACE("[%08x] %d\n", hwnd, infoPtr->nButtonSize);
+    TRACE("[%p] %d\n", hwnd, infoPtr->nButtonSize);
 
     PAGER_RecalcSize(hwnd);
 
@@ -729,7 +729,7 @@
 
     if (infoPtr->hwndChild)
     {
-        TRACE("[%08x] hwndChild=%08x\n", hwnd, infoPtr->hwndChild);
+        TRACE("[%p] hwndChild=%p\n", hwnd, infoPtr->hwndChild);
 
         if (PAGER_IsHorizontal(hwnd)) {
             hw = PAGER_SetFixedHeight(hwnd, infoPtr);
@@ -792,7 +792,7 @@
         SendMessageA (GetParent(hwnd), WM_NOTIFY,
                     (WPARAM)nmpgScroll.hdr.idFrom, (LPARAM)&nmpgScroll);
 
-        TRACE("[%08x] PGN_SCROLL returns iScroll=%d\n", hwnd, nmpgScroll.iScroll);
+        TRACE("[%p] PGN_SCROLL returns iScroll=%d\n", hwnd, nmpgScroll.iScroll);
 
         if (nmpgScroll.iScroll > 0)
         {
@@ -851,7 +851,7 @@
     infoPtr->direction = -1;
 
     if (dwStyle & PGS_DRAGNDROP)
-        FIXME("[%08x] Drag and Drop style is not implemented yet.\n", hwnd);
+        FIXME("[%p] Drag and Drop style is not implemented yet.\n", hwnd);
     /*
 	 * If neither horizontal nor vertical style specified, default to vertical.
 	 * This is probably not necessary, since the style may be set later on as
@@ -1003,7 +1003,7 @@
 	    lpRect->bottom = infoPtr->nHeight;
     }
 
-    TRACE("[%08x] client rect set to %dx%d at (%d,%d) BtnState[%d,%d]\n",
+    TRACE("[%p] client rect set to %dx%d at (%d,%d) BtnState[%d,%d]\n",
 	  hwnd, lpRect->right-lpRect->left, lpRect->bottom-lpRect->top,
 	  lpRect->left, lpRect->top,
 	  infoPtr->TLbtnState, infoPtr->BRbtnState);
@@ -1163,7 +1163,7 @@
     KillTimer (hwnd, TIMERID1);
     KillTimer (hwnd, TIMERID2);
 
-    TRACE("[%08x] ReleaseCapture\n", hwnd);
+    TRACE("[%p] ReleaseCapture\n", hwnd);
     ReleaseCapture();
     infoPtr->bCapture = FALSE;
 
@@ -1199,7 +1199,7 @@
     pt.x = SLOWORD(lParam);
     pt.y = SHIWORD(lParam);
 
-    TRACE("[%08x] to (%ld,%ld)\n", hwnd, pt.x, pt.y);
+    TRACE("[%p] to (%ld,%ld)\n", hwnd, pt.x, pt.y);
     ClientToScreen(hwnd, &pt);
     GetWindowRect(hwnd, &wnrect);
     if (PtInRect(&wnrect, pt)) {
@@ -1232,7 +1232,7 @@
 
 	/* If in one of the buttons the capture and draw buttons */
 	if (btnrect) {
-	    TRACE("[%08x] draw btn (%d,%d)-(%d,%d), Capture %s, style %08lx\n",
+	    TRACE("[%p] draw btn (%d,%d)-(%d,%d), Capture %s, style %08lx\n",
 		  hwnd, btnrect->left, btnrect->top,
 		  btnrect->right, btnrect->bottom,
 		  (infoPtr->bCapture) ? "TRUE" : "FALSE",
@@ -1285,7 +1285,7 @@
     pt.x = SLOWORD(lParam);
     pt.y = SHIWORD(lParam);
 
-    TRACE("[%08x] at (%d,%d)\n", hwnd, SLOWORD(lParam), SHIWORD(lParam));
+    TRACE("[%p] at (%d,%d)\n", hwnd, SLOWORD(lParam), SHIWORD(lParam));
 
     hit = PAGER_HitTest(hwnd, &pt);
 
@@ -1309,19 +1309,19 @@
     switch(hit)
     {
     case HTLEFT:
-        TRACE("[%08x] PGF_SCROLLLEFT\n", hwnd);
+        TRACE("[%p] PGF_SCROLLLEFT\n", hwnd);
         PAGER_Scroll(hwnd, PGF_SCROLLLEFT);
         break;
     case HTTOP:
-        TRACE("[%08x] PGF_SCROLLUP\n", hwnd);
+        TRACE("[%p] PGF_SCROLLUP\n", hwnd);
         PAGER_Scroll(hwnd, PGF_SCROLLUP);
         break;
     case HTRIGHT:
-        TRACE("[%08x] PGF_SCROLLRIGHT\n", hwnd);
+        TRACE("[%p] PGF_SCROLLRIGHT\n", hwnd);
         PAGER_Scroll(hwnd, PGF_SCROLLRIGHT);
         break;
     case HTBOTTOM:
-        TRACE("[%08x] PGF_SCROLLDOWN\n", hwnd);
+        TRACE("[%p] PGF_SCROLLDOWN\n", hwnd);
         PAGER_Scroll(hwnd, PGF_SCROLLDOWN);
         break;
     default:
@@ -1335,7 +1335,7 @@
 PAGER_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x]\n", hwnd);
+    TRACE("[%p]\n", hwnd);
 
     KillTimer (hwnd, TIMERID1);
     KillTimer (hwnd, TIMERID2);
@@ -1354,7 +1354,7 @@
     pt.x = SLOWORD(lParam);
     pt.y = SHIWORD(lParam);
 
-    TRACE("[%08x] at (%d,%d)\n", hwnd, SLOWORD(lParam), SHIWORD(lParam));
+    TRACE("[%p] at (%d,%d)\n", hwnd, SLOWORD(lParam), SHIWORD(lParam));
     MapWindowPoints(0, hwnd, &pt, 1);
     lParam = MAKELONG(pt.x, pt.y);
     return PAGER_LButtonDown (hwnd, wParam, lParam);
@@ -1377,7 +1377,7 @@
 	    dir = (infoPtr->TLbtnState & PGF_DEPRESSED) ?
 		PGF_SCROLLUP : PGF_SCROLLDOWN;
 	}
-	TRACE("[%08x] TIMERID1: style=%08lx, dir=%d\n", hwnd, dwStyle, dir);
+	TRACE("[%p] TIMERID1: style=%08lx, dir=%d\n", hwnd, dwStyle, dir);
 	KillTimer(hwnd, TIMERID1);
 	SetTimer(hwnd, TIMERID1, REPEAT_DELAY, 0);
 	if (dwStyle & PGS_AUTOSCROLL) {
@@ -1390,7 +1390,7 @@
 
     }
 
-    TRACE("[%08x] TIMERID2: dir=%d\n", hwnd, infoPtr->direction);
+    TRACE("[%p] TIMERID2: dir=%d\n", hwnd, infoPtr->direction);
     KillTimer(hwnd, TIMERID2);
     if (infoPtr->direction > 0) {
 	PAGER_Scroll(hwnd, infoPtr->direction);
@@ -1452,7 +1452,7 @@
     /* note that WM_SIZE is sent whenever NCCalcSize resizes the client wnd */
 
     PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
-    TRACE("[%08x] %dx%d\n", hwnd, SLOWORD(lParam), SHIWORD(lParam));
+    TRACE("[%p] %dx%d\n", hwnd, SLOWORD(lParam), SHIWORD(lParam));
 
     if (PAGER_IsHorizontal(hwnd))
         infoPtr->nHeight = SHIWORD(lParam);
diff --git a/dlls/comctl32/progress.c b/dlls/comctl32/progress.c
index b3961ff..2c50dda 100644
--- a/dlls/comctl32/progress.c
+++ b/dlls/comctl32/progress.c
@@ -107,7 +107,7 @@
     RECT rect;
     DWORD dwStyle;
 
-    TRACE("(infoPtr=%p, hdc=%x)\n", infoPtr, hdc);
+    TRACE("(infoPtr=%p, hdc=%p)\n", infoPtr, hdc);
 
     /* get the required bar brush */
     if (infoPtr->ColorBar == CLR_DEFAULT)
@@ -268,7 +268,7 @@
 {
     PROGRESS_INFO *infoPtr;
 
-    TRACE("hwnd=%x msg=%04x wparam=%x lParam=%lx\n", hwnd, message, wParam, lParam);
+    TRACE("hwnd=%p msg=%04x wparam=%x lParam=%lx\n", hwnd, message, wParam, lParam);
 
     infoPtr = (PROGRESS_INFO *)GetWindowLongW(hwnd, 0);
 
@@ -300,12 +300,12 @@
         infoPtr->ColorBar = CLR_DEFAULT;
         infoPtr->ColorBk = CLR_DEFAULT;
         infoPtr->Font = 0;
-        TRACE("Progress Ctrl creation, hwnd=%04x\n", hwnd);
+        TRACE("Progress Ctrl creation, hwnd=%p\n", hwnd);
         return 0;
     }
 
     case WM_DESTROY:
-        TRACE("Progress Ctrl destruction, hwnd=%04x\n", hwnd);
+        TRACE("Progress Ctrl destruction, hwnd=%p\n", hwnd);
         COMCTL32_Free (infoPtr);
         SetWindowLongW(hwnd, 0, 0);
         return 0;
diff --git a/dlls/comctl32/propsheet.c b/dlls/comctl32/propsheet.c
index e2b9c52..628e139 100644
--- a/dlls/comctl32/propsheet.c
+++ b/dlls/comctl32/propsheet.c
@@ -292,7 +292,7 @@
   psInfo->isModeless = dwFlags & PSH_MODELESS;
 
   memcpy(&psInfo->ppshheader,lppsh,dwSize);
-  TRACE("\n** PROPSHEETHEADER **\ndwSize\t\t%ld\ndwFlags\t\t%08lx\nhwndParent\t%04x\nhInstance\t%08x\npszCaption\t'%s'\nnPages\t\t%d\npfnCallback\t%p\n",
+  TRACE("\n** PROPSHEETHEADER **\ndwSize\t\t%ld\ndwFlags\t\t%08lx\nhwndParent\t%p\nhInstance\t%p\npszCaption\t'%s'\nnPages\t\t%d\npfnCallback\t%p\n",
 	lppsh->dwSize, lppsh->dwFlags, lppsh->hwndParent, lppsh->hInstance,
 	debugstr_a(lppsh->pszCaption), lppsh->nPages, lppsh->pfnCallback);
 
@@ -343,7 +343,7 @@
   psInfo->isModeless = dwFlags & PSH_MODELESS;
 
   memcpy(&psInfo->ppshheader,lppsh,dwSize);
-  TRACE("\n** PROPSHEETHEADER **\ndwSize\t\t%ld\ndwFlags\t\t%08lx\nhwndParent\t%04x\nhInstance\t%08x\npszCaption\t'%s'\nnPages\t\t%d\npfnCallback\t%p\n",
+  TRACE("\n** PROPSHEETHEADER **\ndwSize\t\t%ld\ndwFlags\t\t%08lx\nhwndParent\t%p\nhInstance\t%p\npszCaption\t'%s'\nnPages\t\t%d\npfnCallback\t%p\n",
       lppsh->dwSize, lppsh->dwFlags, lppsh->hwndParent, lppsh->hInstance, debugstr_w(lppsh->pszCaption), lppsh->nPages, lppsh->pfnCallback);
 
   PROPSHEET_UnImplementedFlags(lppsh->dwFlags);
@@ -2665,7 +2665,7 @@
 BOOL WINAPI
 PROPSHEET_DialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-  TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n",
+  TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n",
 	hwnd, uMsg, wParam, lParam);
 
   switch (uMsg)
diff --git a/dlls/comctl32/rebar.c b/dlls/comctl32/rebar.c
index f7674b2..3cb98f0 100644
--- a/dlls/comctl32/rebar.c
+++ b/dlls/comctl32/rebar.c
@@ -399,7 +399,7 @@
 REBAR_DumpBandInfo( LPREBARBANDINFOA pB)
 {
     if( !TRACE_ON(rebar) ) return;
-    TRACE("band info: ID=%u, size=%u, child=%04x, clrF=0x%06lx, clrB=0x%06lx\n",
+    TRACE("band info: ID=%u, size=%u, child=%p, clrF=0x%06lx, clrB=0x%06lx\n",
 	  pB->wID, pB->cbSize, pB->hwndChild, pB->clrFore, pB->clrBack);
     TRACE("band info: mask=0x%08x (%s)\n", pB->fMask, REBAR_FmtMask(pB->fMask));
     if (pB->fMask & RBBIM_STYLE)
@@ -430,19 +430,19 @@
 
     if(! TRACE_ON(rebar) ) return;
 
-    TRACE("hwnd=%04x: color=%08lx/%08lx, bands=%u, rows=%u, cSize=%ld,%ld\n",
+    TRACE("hwnd=%p: color=%08lx/%08lx, bands=%u, rows=%u, cSize=%ld,%ld\n",
 	  iP->hwndSelf, iP->clrText, iP->clrBk, iP->uNumBands, iP->uNumRows,
 	  iP->calcSize.cx, iP->calcSize.cy);
-    TRACE("hwnd=%04x: flags=%08x, dragStart=%d,%d, dragNow=%d,%d, ihitBand=%d\n",
+    TRACE("hwnd=%p: flags=%08x, dragStart=%d,%d, dragNow=%d,%d, ihitBand=%d\n",
 	  iP->hwndSelf, iP->fStatus, iP->dragStart.x, iP->dragStart.y,
 	  iP->dragNow.x, iP->dragNow.y,
 	  iP->ihitBand);
-    TRACE("hwnd=%04x: style=%08lx, I'm Unicode=%s, notify in Unicode=%s, redraw=%s\n",
+    TRACE("hwnd=%p: style=%08lx, I'm Unicode=%s, notify in Unicode=%s, redraw=%s\n",
 	  iP->hwndSelf, iP->dwStyle, (iP->bUnicode)?"TRUE":"FALSE",
 	  (iP->NtfUnicode)?"TRUE":"FALSE", (iP->DoRedraw)?"TRUE":"FALSE");
     for (i = 0; i < iP->uNumBands; i++) {
 	pB = &iP->bands[i];
-	TRACE("band # %u: ID=%u, child=%04x, row=%u, clrF=0x%06lx, clrB=0x%06lx\n",
+	TRACE("band # %u: ID=%u, child=%p, row=%u, clrF=0x%06lx, clrB=0x%06lx\n",
 	      i, pB->wID, pB->hwndChild, pB->iRow, pB->clrFore, pB->clrBack);
 	TRACE("band # %u: mask=0x%08x (%s)\n", i, pB->fMask, REBAR_FmtMask(pB->fMask));
 	if (pB->fMask & RBBIM_STYLE)
@@ -506,7 +506,7 @@
     nmhdr->hwndFrom = infoPtr->hwndSelf;
     nmhdr->code = code;
 
-    TRACE("window %04x, code=%08x, %s\n", parent, code,
+    TRACE("window %p, code=%08x, %s\n", parent, code,
 	  (infoPtr->NtfUnicode) ? "via Unicode" : "via ANSI");
 
     if (infoPtr->NtfUnicode)
@@ -638,7 +638,7 @@
 	if (HIDDENBAND(lpBand)) continue;
 
 	/* now draw the band */
-	TRACE("[%04x] drawing band %i, flags=%08x\n",
+	TRACE("[%p] drawing band %i, flags=%08x\n",
 	      infoPtr->hwndSelf, i, lpBand->fDraw);
 	REBAR_DrawBand (hdc, infoPtr, lpBand);
 
@@ -1224,7 +1224,7 @@
 	y = infoPtr->origin.y;
     }
 
-    TRACE("hwnd %08x, style=%08lx, setting at (%d,%d) for (%d,%d)\n",
+    TRACE("hwnd %p, style=%08lx, setting at (%d,%d) for (%d,%d)\n",
 	infoPtr->hwndSelf, infoPtr->dwStyle,
 	x, y, width, height);
     SetWindowPos (infoPtr->hwndSelf, 0, x, y, width, height,
@@ -1250,7 +1250,7 @@
 
 	if (HIDDENBAND(lpBand)) continue;
 	if (lpBand->hwndChild) {
-	    TRACE("hwndChild = %x\n", lpBand->hwndChild);
+	    TRACE("hwndChild = %p\n", lpBand->hwndChild);
 
 	    /* Always geterate the RBN_CHILDSIZE even it child
 		   did not change */
@@ -1296,7 +1296,7 @@
 		yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
 
 		/* center combo box inside child area */
-		TRACE("moving child (Combo(Ex)) %04x to (%d,%d) for (%d,%d)\n",
+		TRACE("moving child (Combo(Ex)) %p to (%d,%d) for (%d,%d)\n",
 		      lpBand->hwndChild,
 		      lpBand->rcChild.left, yPos,
 		      lpBand->rcChild.right - lpBand->rcChild.left,
@@ -1311,7 +1311,7 @@
 		    ERR("DeferWindowPos returned NULL\n");
 	    }
 	    else {
-		TRACE("moving child (Other) %04x to (%d,%d) for (%d,%d)\n",
+		TRACE("moving child (Other) %p to (%d,%d) for (%d,%d)\n",
 		      lpBand->hwndChild,
 		      lpBand->rcChild.left, lpBand->rcChild.top,
 		      lpBand->rcChild.right - lpBand->rcChild.left,
@@ -2060,7 +2060,7 @@
 	    /* above in trace fro WinRAR */
 	}
 	else {
-	    TRACE("child: 0x%x  prev parent: 0x%x\n",
+	    TRACE("child: %p  prev parent: %p\n",
 		   lpBand->hwndChild, lpBand->hwndPrevParent);
 	    lpBand->hwndChild = 0;
 	    lpBand->hwndPrevParent = 0;
@@ -2922,7 +2922,7 @@
 inline static LRESULT
 REBAR_GetUnicodeFormat (REBAR_INFO *infoPtr)
 {
-    TRACE("%s hwnd=0x%x\n",
+    TRACE("%s hwnd=%p\n",
 	  infoPtr->bUnicode ? "TRUE" : "FALSE", infoPtr->hwndSelf);
 
     return infoPtr->bUnicode;
@@ -3553,7 +3553,7 @@
 {
     BOOL bTemp = infoPtr->bUnicode;
 
-    TRACE("to %s hwnd=0x%04x, was %s\n",
+    TRACE("to %s hwnd=%p, was %s\n",
 	  ((BOOL)wParam) ? "TRUE" : "FALSE", infoPtr->hwndSelf,
 	  (bTemp) ? "TRUE" : "FALSE");
 
@@ -4249,7 +4249,7 @@
     ret = DefWindowProcA(infoPtr->hwndSelf, WM_WINDOWPOSCHANGED,
 			 wParam, lParam);
     GetWindowRect(infoPtr->hwndSelf, &rc);
-    TRACE("hwnd %08x new pos (%d,%d)-(%d,%d)\n",
+    TRACE("hwnd %p new pos (%d,%d)-(%d,%d)\n",
 	  infoPtr->hwndSelf, rc.left, rc.top, rc.right, rc.bottom);
     return ret;
 }
@@ -4260,7 +4260,7 @@
 {
     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n",
+    TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n",
 	  hwnd, uMsg, /* SPY_GetMsgName(uMsg), */ wParam, lParam);
     if (!infoPtr && (uMsg != WM_NCCREATE))
 	    return DefWindowProcA (hwnd, uMsg, wParam, lParam);
diff --git a/dlls/comctl32/smoothscroll.c b/dlls/comctl32/smoothscroll.c
index dd1683d..0a0c481 100644
--- a/dlls/comctl32/smoothscroll.c
+++ b/dlls/comctl32/smoothscroll.c
@@ -106,7 +106,7 @@
 	   );
    }
 
-   FIXME("(hwnd=%x,flags=%lx,x2=%lx): should smooth scroll here.\n",
+   FIXME("(hwnd=%p,flags=%lx,x2=%lx): should smooth scroll here.\n",
 	   smooth->hwnd,flags,smooth->x2
    );
    /* FIXME: do timer based smooth scrolling */
diff --git a/dlls/comctl32/status.c b/dlls/comctl32/status.c
index af06015..182fccd 100644
--- a/dlls/comctl32/status.c
+++ b/dlls/comctl32/status.c
@@ -1005,7 +1005,7 @@
 STATUSBAR_WMSetFont (STATUSWINDOWINFO *infoPtr, HFONT font, BOOL redraw)
 {
     infoPtr->hFont = font;
-    TRACE("%04x\n", infoPtr->hFont);
+    TRACE("%p\n", infoPtr->hFont);
     if (redraw)
         InvalidateRect(infoPtr->Self, NULL, FALSE);
 
@@ -1111,7 +1111,7 @@
     INT nPart = ((INT) wParam) & 0x00ff;
     LRESULT res;
 
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hwnd, msg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n", hwnd, msg, wParam, lParam);
     if (!infoPtr && msg != WM_CREATE)
         return DefWindowProcW (hwnd, msg, wParam, lParam);
 
diff --git a/dlls/comctl32/tab.c b/dlls/comctl32/tab.c
index 5e829cb..045cb2a 100644
--- a/dlls/comctl32/tab.c
+++ b/dlls/comctl32/tab.c
@@ -2386,7 +2386,7 @@
   RECT rect;
 
   GetClientRect (hwnd, &rect);
-  TRACE("Rect: %x T %i, L %i, B %i, R %i\n", hwnd,
+  TRACE("Rect: %p T %i, L %i, B %i, R %i\n", hwnd,
         rect.top, rect.left, rect.bottom, rect.right);
 
   pti = (TCITEMA *)lParam;
@@ -2445,7 +2445,7 @@
   else
     InvalidateRect(hwnd, NULL, TRUE);
 
-  TRACE("[%04x]: added item %d %s\n",
+  TRACE("[%p]: added item %d %s\n",
 	hwnd, iItem, debugstr_w(infoPtr->items[iItem].pszText));
 
   return iItem;
@@ -2461,7 +2461,7 @@
   RECT rect;
 
   GetClientRect (hwnd, &rect);
-  TRACE("Rect: %x T %i, L %i, B %i, R %i\n", hwnd,
+  TRACE("Rect: %p T %i, L %i, B %i, R %i\n", hwnd,
         rect.top, rect.left, rect.bottom, rect.right);
 
   pti = (TCITEMW *)lParam;
@@ -2519,7 +2519,7 @@
   else
     InvalidateRect(hwnd, NULL, TRUE);
 
-  TRACE("[%04x]: added item %d %s\n",
+  TRACE("[%p]: added item %d %s\n",
 	hwnd, iItem, debugstr_w(infoPtr->items[iItem].pszText));
 
   return iItem;
@@ -2907,7 +2907,7 @@
   infoPtr->fSizeSet	   = FALSE;
   infoPtr->bUnicode	   = IsWindowUnicode (hwnd);
 
-  TRACE("Created tab control, hwnd [%04x]\n", hwnd);
+  TRACE("Created tab control, hwnd [%p]\n", hwnd);
 
   /* The tab control always has the WS_CLIPSIBLINGS style. Even
      if you don't specify it in CreateWindow. This is necessary in
@@ -3001,7 +3001,7 @@
 TAB_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
 
-    TRACE("hwnd=%x msg=%x wParam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wParam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
     if (!TAB_GetInfoPtr(hwnd) && (uMsg != WM_CREATE))
       return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 
diff --git a/dlls/comctl32/toolbar.c b/dlls/comctl32/toolbar.c
index ac7eca2..8f1f0f9 100644
--- a/dlls/comctl32/toolbar.c
+++ b/dlls/comctl32/toolbar.c
@@ -226,11 +226,11 @@
 	DWORD dwStyle;
 
 	dwStyle = GetWindowLongA (iP->hwndSelf, GWL_STYLE);
-	TRACE("toolbar %08x at line %d, exStyle=%08lx, buttons=%d, bitmaps=%d, strings=%d, style=%08lx\n",
+	TRACE("toolbar %p at line %d, exStyle=%08lx, buttons=%d, bitmaps=%d, strings=%d, style=%08lx\n",
 	      iP->hwndSelf, line,
 	      iP->dwExStyle, iP->nNumButtons, iP->nNumBitmaps,
 	      iP->nNumStrings, dwStyle);
-	TRACE("toolbar %08x at line %d, himlInt=%p, himlDef=%p, himlHot=%p, himlDis=%p, redrawable=%s\n",
+	TRACE("toolbar %p at line %d, himlInt=%p, himlDef=%p, himlHot=%p, himlDis=%p, redrawable=%s\n",
 	      iP->hwndSelf, line,
 	      iP->himlInt, iP->himlDef, iP->himlHot, iP->himlDis,
 	      (iP->bDoRedraw) ? "TRUE" : "FALSE");
@@ -252,9 +252,9 @@
 TOOLBAR_CheckStyle (HWND hwnd, DWORD dwStyle)
 {
     if (dwStyle & TBSTYLE_ALTDRAG)
-	FIXME("[%04x] TBSTYLE_ALTDRAG not implemented\n", hwnd);
+	FIXME("[%p] TBSTYLE_ALTDRAG not implemented\n", hwnd);
     if (dwStyle & TBSTYLE_REGISTERDROP)
-	FIXME("[%04x] TBSTYLE_REGISTERDROP not implemented\n", hwnd);
+	FIXME("[%p] TBSTYLE_REGISTERDROP not implemented\n", hwnd);
 }
 
 
@@ -268,7 +268,7 @@
     nmhdr->hwndFrom = infoPtr->hwndSelf;
     nmhdr->code = code;
 
-    TRACE("to window %04x, code=%08x, %s\n", infoPtr->hwndNotify, code,
+    TRACE("to window %p, code=%08x, %s\n", infoPtr->hwndNotify, code,
 	  (infoPtr->bNtfUnicode) ? "via Unicode" : "via ANSI");
 
     if (infoPtr->bNtfUnicode)
@@ -2082,7 +2082,7 @@
     INT nIndex = 0, nButtons, nCount;
     HBITMAP hbmLoad;
 
-    TRACE("hwnd=%x wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
+    TRACE("hwnd=%p wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
     if (!lpAddBmp)
 	return -1;
 
@@ -2648,7 +2648,7 @@
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 
     if (infoPtr == NULL) {
-	ERR("(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
+	ERR("(%p, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
 	ERR("infoPtr == NULL!\n");
 	return 0;
     }
@@ -3283,7 +3283,7 @@
 {
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 
-    TRACE("%s hwnd=0x%x stub!\n",
+    TRACE("%s hwnd=%p stub!\n",
 	   infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
 
     return infoPtr->bUnicode;
@@ -3679,7 +3679,7 @@
     HBITMAP hBitmap;
     int i = 0, nOldButtons = 0, pos = 0;
 
-    TRACE("hInstOld %x nIDOld %x hInstNew %x nIDNew %x nButtons %x\n",
+    TRACE("hInstOld %p nIDOld %x hInstNew %p nIDNew %x nButtons %x\n",
           lpReplace->hInstOld, lpReplace->nIDOld, lpReplace->hInstNew, lpReplace->nIDNew,
           lpReplace->nButtons);
 
@@ -3698,18 +3698,18 @@
         hBitmap = (HBITMAP) lpReplace->nIDNew;
     }
 
-    TRACE("To be replaced hInstOld %x nIDOld %x\n", lpReplace->hInstOld, lpReplace->nIDOld);
+    TRACE("To be replaced hInstOld %p nIDOld %x\n", lpReplace->hInstOld, lpReplace->nIDOld);
     for (i = 0; i < infoPtr->nNumBitmapInfos; i++) {
         TBITMAP_INFO *tbi = &infoPtr->bitmaps[i];
-        TRACE("tbimapinfo %d hInstOld %x nIDOld %x\n", i, tbi->hInst, tbi->nID);
+        TRACE("tbimapinfo %d hInstOld %p nIDOld %x\n", i, tbi->hInst, tbi->nID);
         if (tbi->hInst == lpReplace->hInstOld && tbi->nID == lpReplace->nIDOld)
         {
-            TRACE("Found: nButtons %d hInst %x nID %x\n", tbi->nButtons, tbi->hInst, tbi->nID);
+            TRACE("Found: nButtons %d hInst %p nID %x\n", tbi->nButtons, tbi->hInst, tbi->nID);
             nOldButtons = tbi->nButtons;
             tbi->nButtons = lpReplace->nButtons;
             tbi->hInst = lpReplace->hInstNew;
             tbi->nID = lpReplace->nIDNew;
-            TRACE("tbimapinfo changed %d hInstOld %x nIDOld %x\n", i, tbi->hInst, tbi->nID);
+            TRACE("tbimapinfo changed %d hInstOld %p nIDOld %x\n", i, tbi->hInst, tbi->nID);
             break;
         }
         pos += tbi->nButtons;
@@ -3717,7 +3717,7 @@
 
     if (nOldButtons == 0)
     {
-        WARN("No hinst/bitmap found! hInst %x nID %x\n", lpReplace->hInstOld, lpReplace->nIDOld);
+        WARN("No hinst/bitmap found! hInst %p nID %x\n", lpReplace->hInstOld, lpReplace->nIDOld);
         return FALSE;
     }
 
@@ -4149,7 +4149,7 @@
 
     ImageList_GetIconSize(infoPtr->himlDef, &infoPtr->nBitmapWidth,
 			  &infoPtr->nBitmapHeight);
-    TRACE("hwnd %08x, new himl=%08x, count=%d, bitmap w=%d, h=%d\n",
+    TRACE("hwnd %p, new himl=%08x, count=%d, bitmap w=%d, h=%d\n",
 	  hwnd, (INT)infoPtr->himlDef, infoPtr->nNumBitmaps,
 	  infoPtr->nBitmapWidth, infoPtr->nBitmapHeight);
 
@@ -4358,7 +4358,7 @@
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
     BOOL bTemp;
 
-    TRACE("%s hwnd=0x%04x stub!\n",
+    TRACE("%s hwnd=%p stub!\n",
 	   ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
 
     bTemp = infoPtr->bUnicode;
@@ -4652,7 +4652,7 @@
 	    case CDRF_SKIPDEFAULT:
 		return TRUE;
 	    default:
-		FIXME("[%04x] response %ld not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
+		FIXME("[%p] response %ld not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
 		      hwnd, ntfret);
 	    }
     }
@@ -4690,7 +4690,7 @@
 	    case CDRF_SKIPDEFAULT:
 		return TRUE;
 	    default:
-		FIXME("[%04x] response %ld not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
+		FIXME("[%p] response %ld not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
 		      hwnd, ntfret);
 	    }
     }
@@ -5476,7 +5476,7 @@
 static LRESULT WINAPI
 ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n",
+    TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n",
 	  hwnd, uMsg, /* SPY_GetMsgName(uMsg), */ wParam, lParam);
 
     if (!TOOLBAR_GetInfoPtr(hwnd) && (uMsg != WM_NCCREATE))
diff --git a/dlls/comctl32/tooltips.c b/dlls/comctl32/tooltips.c
index 6b8989a..538c7ce 100644
--- a/dlls/comctl32/tooltips.c
+++ b/dlls/comctl32/tooltips.c
@@ -173,7 +173,7 @@
 
     if (HIWORD((UINT)toolPtr->lpszText) == 0) {
 	/* load a resource */
-	TRACE("load res string %x %x\n",
+	TRACE("load res string %p %x\n",
 	       toolPtr->hinst, (int)toolPtr->lpszText);
 	LoadStringW (toolPtr->hinst, (UINT)toolPtr->lpszText,
 		       infoPtr->szTipText, INFOTIPSIZE);
@@ -294,7 +294,7 @@
 
     infoPtr->nCurrentTool = infoPtr->nTool;
 
-    TRACE("Show tooltip pre %d! (%04x)\n", infoPtr->nTool, hwnd);
+    TRACE("Show tooltip pre %d! (%p)\n", infoPtr->nTool, hwnd);
 
     TOOLTIPS_GetTipText (hwnd, infoPtr, infoPtr->nCurrentTool);
 
@@ -383,7 +383,7 @@
     TTTOOL_INFO *toolPtr;
     NMHDR hdr;
 
-    TRACE("Hide tooltip %d! (%04x)\n", infoPtr->nCurrentTool, hwnd);
+    TRACE("Hide tooltip %d! (%p)\n", infoPtr->nCurrentTool, hwnd);
 
     if (infoPtr->nCurrentTool == -1)
 	return;
@@ -668,7 +668,7 @@
     if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
 	return FALSE;
 
-    TRACE("add tool (%x) %x %d%s!\n",
+    TRACE("add tool (%p) %p %d%s!\n",
 	   hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
 	   (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
 
@@ -746,7 +746,7 @@
     if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
 	return FALSE;
 
-    TRACE("add tool (%x) %x %d%s!\n",
+    TRACE("add tool (%p) %p %d%s!\n",
 	   hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
 	   (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
 
@@ -1475,9 +1475,9 @@
 	    nOldTool = infoPtr->nTool;
 	    infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr, lpMsg->hwnd,
 						       &pt);
-	    TRACE("tool (%x) %d %d %d\n", hwnd, nOldTool,
+	    TRACE("tool (%p) %d %d %d\n", hwnd, nOldTool,
 		  infoPtr->nTool, infoPtr->nCurrentTool);
-	    TRACE("WM_MOUSEMOVE (%04x %ld %ld)\n", hwnd, pt.x, pt.y);
+	    TRACE("WM_MOUSEMOVE (%p %ld %ld)\n", hwnd, pt.x, pt.y);
 
 	    if (infoPtr->nTool != nOldTool) {
 	        if(infoPtr->nTool == -1) { /* Moved out of all tools */
@@ -2065,7 +2065,7 @@
 static LRESULT
 TOOLTIPS_NotifyFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    FIXME ("hwnd=%x wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
+    FIXME ("hwnd=%p wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
 
     return 0;
 }
@@ -2147,7 +2147,7 @@
     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
     INT nOldTool;
 
-    TRACE("timer %d (%x) expired!\n", wParam, hwnd);
+    TRACE("timer %d (%p) expired!\n", wParam, hwnd);
 
     switch (wParam) {
     case ID_TIMERSHOW:
@@ -2164,7 +2164,7 @@
     case ID_TIMERLEAVE:
         nOldTool = infoPtr->nTool;
 	infoPtr->nTool = TOOLTIPS_CheckTool (hwnd, FALSE);
-	TRACE("tool (%x) %d %d %d\n", hwnd, nOldTool,
+	TRACE("tool (%p) %d %d %d\n", hwnd, nOldTool,
 	      infoPtr->nTool, infoPtr->nCurrentTool);
 	if (infoPtr->nTool != nOldTool) {
 	    if(infoPtr->nTool == -1) { /* Moved out of all tools */
@@ -2239,7 +2239,7 @@
 static LRESULT CALLBACK
 TOOLTIPS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
     if (!TOOLTIPS_GetInfoPtr(hwnd) && (uMsg != WM_CREATE) && (uMsg != WM_NCCREATE))
         return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     switch (uMsg)
diff --git a/dlls/comctl32/trackbar.c b/dlls/comctl32/trackbar.c
index 506b6be..9dc4e3b 100644
--- a/dlls/comctl32/trackbar.c
+++ b/dlls/comctl32/trackbar.c
@@ -1546,7 +1546,7 @@
 {
     TRACKBAR_INFO *infoPtr = (TRACKBAR_INFO *)GetWindowLongW (hwnd, 0);
 
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
+    TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
 
     if (!infoPtr && (uMsg != WM_CREATE))
         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
diff --git a/dlls/comctl32/treeview.c b/dlls/comctl32/treeview.c
index c57dd5f..ddf8ae9 100644
--- a/dlls/comctl32/treeview.c
+++ b/dlls/comctl32/treeview.c
@@ -540,7 +540,7 @@
     NMTVCUSTOMDRAW nmcdhdr;
     LPNMCUSTOMDRAW nmcd;
 
-    TRACE("drawstage:%lx hdc:%x\n", dwDrawStage, hdc);
+    TRACE("drawstage:%lx hdc:%p\n", dwDrawStage, hdc);
 
     nmcd = &nmcdhdr.nmcd;
     nmcd->hdr.hwndFrom = hwnd;
@@ -600,7 +600,7 @@
     nmcdhdr.clrTextBk = infoPtr->clrBk;
     nmcdhdr.iLevel = wineItem->iLevel;
 
-    TRACE("drawstage:%lx hdc:%x item:%lx, itemstate:%x, lItemlParam:%lx\n",
+    TRACE("drawstage:%lx hdc:%p item:%lx, itemstate:%x, lItemlParam:%lx\n",
 	  nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
 	  nmcd->uItemState, nmcd->lItemlParam);
 
@@ -1769,7 +1769,7 @@
 static LRESULT
 TREEVIEW_GetFont(TREEVIEW_INFO *infoPtr)
 {
-    TRACE("%x\n", infoPtr->hFont);
+    TRACE("%p\n", infoPtr->hFont);
     return (LRESULT)infoPtr->hFont;
 }
 
@@ -1789,7 +1789,7 @@
 {
     UINT uHeight = infoPtr->uItemHeight;
 
-    TRACE("%x %i\n", hFont, bRedraw);
+    TRACE("%p %i\n", hFont, bRedraw);
 
     infoPtr->hFont = hFont ? hFont : GetStockObject(SYSTEM_FONT);
 
@@ -4683,7 +4683,7 @@
     RECT rcClient;
     TREEVIEW_INFO *infoPtr;
 
-    TRACE("wnd %x, style %lx\n", hwnd, GetWindowLongA(hwnd, GWL_STYLE));
+    TRACE("wnd %p, style %lx\n", hwnd, GetWindowLongA(hwnd, GWL_STYLE));
 
     infoPtr = (TREEVIEW_INFO *)COMCTL32_Alloc(sizeof(TREEVIEW_INFO));
 
diff --git a/dlls/comctl32/updown.c b/dlls/comctl32/updown.c
index 351806f..3cff9ac 100644
--- a/dlls/comctl32/updown.c
+++ b/dlls/comctl32/updown.c
@@ -425,7 +425,7 @@
 UPDOWN_Buddy_SubclassProc(HWND  hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
     WNDPROC superClassWndProc = (WNDPROC)GetPropA(hwnd, BUDDY_SUPERCLASS_WNDPROC);
-    TRACE("hwnd=%04x, wndProc=%d, uMsg=%04x, wParam=%d, lParam=%d\n",
+    TRACE("hwnd=%p, wndProc=%d, uMsg=%04x, wParam=%d, lParam=%d\n",
 	  hwnd, (INT)superClassWndProc, uMsg, wParam, (UINT)lParam);
 
     if (uMsg == WM_KEYDOWN) {
@@ -458,7 +458,7 @@
     /* Is it a valid bud? */
     if(!IsWindow(bud)) return FALSE;
 
-    TRACE("(hwnd=%04x, bud=%04x)\n", infoPtr->Self, bud);
+    TRACE("(hwnd=%p, bud=%p)\n", infoPtr->Self, bud);
 
     /* there is already a body assigned */
     if (infoPtr->Buddy)  RemovePropA(infoPtr->Buddy, BUDDY_UPDOWN_HWND);
@@ -732,7 +732,7 @@
 	    if (dwStyle & UDS_AUTOBUDDY)
 		UPDOWN_SetBuddy (infoPtr, GetWindow (hwnd, GW_HWNDPREV));
 
-	    TRACE("UpDown Ctrl creation, hwnd=%04x\n", hwnd);
+	    TRACE("UpDown Ctrl creation, hwnd=%p\n", hwnd);
 	    break;
 
 	case WM_DESTROY:
@@ -742,7 +742,7 @@
 
 	    COMCTL32_Free (infoPtr);
 	    SetWindowLongW (hwnd, 0, 0);
-	    TRACE("UpDown Ctrl destruction, hwnd=%04x\n", hwnd);
+	    TRACE("UpDown Ctrl destruction, hwnd=%p\n", hwnd);
 	    break;
 
 	case WM_ENABLE:
@@ -830,7 +830,7 @@
 	    return 0;
 
 	case UDM_SETACCEL:
-	    TRACE("UpDown Ctrl new accel info, hwnd=%04x\n", hwnd);
+	    TRACE("UpDown Ctrl new accel info, hwnd=%p\n", hwnd);
 	    if(infoPtr->AccelVect) {
 		COMCTL32_Free (infoPtr->AccelVect);
 		infoPtr->AccelCount = 0;
@@ -846,7 +846,7 @@
 	    return infoPtr->Base;
 
 	case UDM_SETBASE:
-	    TRACE("UpDown Ctrl new base(%d), hwnd=%04x\n", wParam, hwnd);
+	    TRACE("UpDown Ctrl new base(%d), hwnd=%p\n", wParam, hwnd);
 	    if (wParam==10 || wParam==16) {
 		temp = infoPtr->Base;
 		infoPtr->Base = wParam;
@@ -868,7 +868,7 @@
 
 	case UDM_SETPOS:
 	    temp = SLOWORD(lParam);
-	    TRACE("UpDown Ctrl new value(%d), hwnd=%04x\n", temp, hwnd);
+	    TRACE("UpDown Ctrl new value(%d), hwnd=%p\n", temp, hwnd);
 	    if(!UPDOWN_InBounds(infoPtr, temp)) {
 		if(temp < infoPtr->MinVal) temp = infoPtr->MinVal;
 		if(temp > infoPtr->MaxVal) temp = infoPtr->MaxVal;
@@ -886,7 +886,7 @@
 	    infoPtr->MaxVal = SLOWORD(lParam); /* UD_MINVAL <= Max <= UD_MAXVAL */
 	    infoPtr->MinVal = SHIWORD(lParam); /* UD_MINVAL <= Min <= UD_MAXVAL */
                 	                       /* |Max-Min| <= UD_MAXVAL        */
-	    TRACE("UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
+	    TRACE("UpDown Ctrl new range(%d to %d), hwnd=%p\n",
 		  infoPtr->MinVal, infoPtr->MaxVal, hwnd);
 	    break;
 
@@ -900,7 +900,7 @@
 	    infoPtr->MaxVal = (INT)lParam;
 	    if (infoPtr->MaxVal <= infoPtr->MinVal)
 		infoPtr->MaxVal = infoPtr->MinVal + 1;
-	    TRACE("UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
+	    TRACE("UpDown Ctrl new range(%d to %d), hwnd=%p\n",
 		  infoPtr->MinVal, infoPtr->MaxVal, hwnd);
 	    break;
 
