Changeset 180 for trunk/src

Timestamp:

Jun 24, 1999, 6:37:46 PM (26 years ago)

Author:

cbratschi

Message:

Several COMCTL32 changes

Location:

trunk/src/comctl32

Files:

• propsheet.c (modified) (13 diffs)
• toolbar.c (modified) (16 diffs)
• tooltips.c (modified) (29 diffs)
• trackbar.c (modified) (32 diffs)
• updown.c (modified) (23 diffs)

trunk/src/comctl32/propsheet.c

@@ -1 @@
-/* $Id: propsheet.c,v 1.3 1999-06-10 16:22:01 achimha Exp $ */
+/* $Id: propsheet.c,v 1.4 1999-06-24 16:37:44 cbratschi Exp $ */
 /*
  * Property Sheets
@@ -6 +6 @@
  * Copyright 1999 Thuy Nguyen
  * Copyright 1999 Achim Hasenmueller
+ * Copyright 1999 Christoph Bratschi
  *
  * TODO:
@@ -251 +252 @@
       p += lstrlenW( (LPCWSTR)p ) + 1;
       break;
-  } 
+  }
 
   /* class */
@@ -286 +287 @@
   HRSRC hRes;
 
-  if(!(hRes = FindResourceA(COMCTL32_hModule,
+  if (!(hRes = FindResourceA(COMCTL32_hModule,
                             MAKEINTRESOURCEA(IDD_PROPSHEET),
                             RT_DIALOGA)))
     return FALSE;
 
-  if(!(template = (LPVOID)LoadResource(COMCTL32_hModule, hRes)))
+  if (!(template = (LPVOID)LoadResource(COMCTL32_hModule, hRes)))
     return FALSE;
 
@@ -315 +316 @@
 /******************************************************************************
  *            PROPSHEET_IsTooSmall
- * 
+ *
  * Verify that the resource property sheet is big enough.
  */
@@ -437 +438 @@
   /*
    * Get the size of the property sheet.
-   */ 
+   */
   GetClientRect(hwndParent, &rcSheet);
 
-  /* 
+  /*
    * All buttons will be at this y coordinate.
    */
@@ -476 +477 @@
     else
       x = rcSheet.right - (padding.x + buttonWidth);
-  
+
     SetWindowPos(hwndButton, 0, x, y, 0, 0,
                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
@@ -493 +494 @@
   {
     x = rcSheet.right - (padding.x + buttonWidth);
-  
+
     SetWindowPos(hwndButton, 0, x, y, 0, 0,
                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
@@ -613 +614 @@
 
   hwndPage = CreateDialogIndirectParamA(ppshpage->hInstance,
-                                        pTemplate,
-                                        hwndParent,
-                                        ppshpage->pfnDlgProc,
-                                        (LPARAM)ppshpage);
+                                        pTemplate,
+                                        hwndParent,
+                                        ppshpage->pfnDlgProc,
+                                        (LPARAM)ppshpage);
 
   ppInfo[index].hwndPage = hwndPage;
@@ -841 +842 @@
     default:
 //      FIXME(propsheet, "Invalid button index %d\n", buttonID);
-        break;
+        break;
   }
 }
@@ -1083 +1084 @@
   psInfo->proppage = COMCTL32_Alloc(sizeof(PropPageInfo) * psInfo->nPages);
 
-  if (index > 0)  
+  if (index > 0)
     memcpy(&psInfo->proppage[0], &oldPages[0], index * sizeof(PropPageInfo));
 
@@ -1233 +1234 @@
       }
 
-      ppshpage = PROPSHEET_GetPSPPage(psInfo, psInfo->active_page);      
+      ppshpage = PROPSHEET_GetPSPPage(psInfo, psInfo->active_page);
       PROPSHEET_CreatePage(hwnd, psInfo->active_page, psInfo, ppshpage, TRUE);
       SendMessageA(hwndTabCtrl, TCM_SETCURSEL, psInfo->active_page, 0);
@@ -1392 +1393 @@
     case PSM_REBOOTSYSTEM:
     {
-      PropSheetInfo* psInfo = (PropSheetInfo*) GetPropA(hwnd, 
+      PropSheetInfo* psInfo = (PropSheetInfo*) GetPropA(hwnd,
                                                         PropSheetInfoStr);
 

trunk/src/comctl32/toolbar.c

@@ -1 @@
-/* $Id: toolbar.c,v 1.5 1999-06-16 20:25:43 cbratschi Exp $ */
+/* $Id: toolbar.c,v 1.6 1999-06-24 16:37:45 cbratschi Exp $ */
 /*
  * Toolbar control
@@ -175 +175 @@
     RECT rc;
 
-    if (btnPtr->fsState & TBSTATE_HIDDEN)
-        return;
+    if (btnPtr->fsState & TBSTATE_HIDDEN) return;
 
     rc = btnPtr->rect;
-    if (btnPtr->fsStyle & TBSTYLE_SEP) {
-        if ((dwStyle & TBSTYLE_FLAT) && (btnPtr->idCommand == 0))
-            TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
-        return;
+    if (btnPtr->fsStyle & TBSTYLE_SEP)
+    {
+      if ((dwStyle & TBSTYLE_FLAT) && (btnPtr->idCommand == 0))
+          TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
+      return;
     }
 
     /* disabled */
-    if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
-        DrawEdge (hdc, &rc, EDGE_RAISED,
-                    BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
-
-        if (dwStyle & TBSTYLE_FLAT) {
-/*          if (infoPtr->himlDis) */
-                ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
-                                rc.left+1, rc.top+1, ILD_NORMAL);
-/*          else */
-/*              TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1); */
-        }
-        else
-            TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
-
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
-        return;
+    if (!(btnPtr->fsState & TBSTATE_ENABLED))
+    {
+      DrawEdge (hdc, &rc, EDGE_RAISED,
+                  BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+
+      if (dwStyle & TBSTYLE_FLAT)
+      {
+/*        if (infoPtr->himlDis) */
+              ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
+                              rc.left+1, rc.top+1, ILD_NORMAL);
+/*        else */
+/*            TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1); */
+      } else
+        TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
+
+      TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
+      return;
     }
 
     /* pressed TBSTYLE_BUTTON */
-    if (btnPtr->fsState & TBSTATE_PRESSED) {
-        DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
-        ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
-                        rc.left+2, rc.top+2, ILD_NORMAL);
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
-        return;
+    if (btnPtr->fsState & TBSTATE_PRESSED)
+    {
+      DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
+      ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
+                      rc.left+2, rc.top+2, ILD_NORMAL);
+      TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
+      return;
     }
 
@@ -229 +231 @@
             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
                             rc.left+2, rc.top+2, ILD_NORMAL);
-        else
+            else
             ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
                             rc.left+2, rc.top+2, ILD_NORMAL);
-        }
-        else
+        } else
             ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
                             rc.left+2, rc.top+2, ILD_NORMAL);
@@ -241 +242 @@
 
     /* indeterminate */
-    if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
-        DrawEdge (hdc, &rc, EDGE_RAISED,
-                    BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
-
-        TOOLBAR_DrawPattern (hdc, &rc);
-        TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
-        return;
+    if (btnPtr->fsState & TBSTATE_INDETERMINATE)
+    {
+      DrawEdge (hdc, &rc, EDGE_RAISED,
+                  BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+
+      TOOLBAR_DrawPattern (hdc, &rc);
+      TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
+      TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
+      return;
     }
 
     if (dwStyle & TBSTYLE_FLAT)
     {
-        if(btnPtr->bHot)
-            DrawEdge (hdc, &rc, BDR_RAISEDINNER,
-                       BF_RECT | BF_MIDDLE | BF_SOFT);
-
-        if(infoPtr->himlDef != NULL)
-            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
-                            rc.left +2, rc.top +2, ILD_NORMAL);
-        else
-            ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
-                            rc.left +2, rc.top +2, ILD_NORMAL);
-    }
-    else{
-    /* normal state */
-    DrawEdge (hdc, &rc, EDGE_RAISED,
+      if(btnPtr->bHot)
+          DrawEdge (hdc, &rc, BDR_RAISEDINNER,
+                     BF_RECT | BF_MIDDLE | BF_SOFT);
+
+      if(infoPtr->himlDef != NULL)
+          ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
+                          rc.left +2, rc.top +2, ILD_NORMAL);
+      else
+          ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
+                          rc.left +2, rc.top +2, ILD_NORMAL);
+    } else
+    {
+      /* normal state */
+      DrawEdge (hdc, &rc, EDGE_RAISED,
                 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 
-        ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
-                        rc.left+1, rc.top+1, ILD_NORMAL);
+      ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
+                      rc.left+1, rc.top+1, ILD_NORMAL);
     }
 
@@ -555 +557 @@
 
         /* Set the toolTip only for non-hidden, non-separator button */
-        if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP ))
+        if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP))
         {
             TTTOOLINFOA ti;
 
-            ZeroMemory (&ti, sizeof(TTTOOLINFOA));
+            ZeroMemory (&ti,sizeof(TTTOOLINFOA));
             ti.cbSize = sizeof(TTTOOLINFOA);
             ti.hwnd = hwnd;
             ti.uId = btnPtr->idCommand;
             ti.rect = btnPtr->rect;
-            SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
-                            0, (LPARAM)&ti);
+            SendMessageA(infoPtr->hwndToolTip,TTM_NEWTOOLRECTA,0,(LPARAM)&ti);
         }
 
@@ -712 +713 @@
     msg.wParam = wParam;
     msg.lParam = lParam;
-    msg.time = GetMessageTime ();
-    msg.pt.x = LOWORD(GetMessagePos ());
-    msg.pt.y = HIWORD(GetMessagePos ());
-
-    SendMessageA (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
+    msg.time = GetMessageTime();
+    msg.pt.x = LOWORD(GetMessagePos());
+    msg.pt.y = HIWORD(GetMessagePos());
+
+    SendMessageA(hwndTip,TTM_RELAYEVENT,0,(LPARAM)&msg);
 }
 
@@ -976 +977 @@
 
     /* insert new button data */
-    for (nCount = 0; nCount < nAddButtons; nCount++) {
+    for (nCount = 0; nCount < nAddButtons; nCount++)
+    {
         TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
         btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
@@ -986 +988 @@
         btnPtr->bHot      = FALSE;
 
-        if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
+        if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP))
+        {
             TTTOOLINFOA ti;
 
@@ -996 +999 @@
             ti.lpszText = LPSTR_TEXTCALLBACKA;
 
-            SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
-                            0, (LPARAM)&ti);
-        }
-    }
-
-    TOOLBAR_CalcToolbar (hwnd);
-
-    InvalidateRect(hwnd, NULL, FALSE);
+            SendMessageA (infoPtr->hwndToolTip,TTM_ADDTOOLA,0,(LPARAM)&ti);
+        }
+    }
+
+    TOOLBAR_CalcToolbar(hwnd);
+
+    InvalidateRect(hwnd,NULL,FALSE);
 
     return TRUE;
@@ -1752 +1754 @@
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 
-    if (infoPtr == NULL)
-        return 0;
+    if (infoPtr == NULL) return 0;
     return infoPtr->hwndToolTip;
 }
@@ -2056 +2057 @@
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 
-    if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
-        return FALSE;
+    if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0)) return FALSE;
 
     infoPtr->nBitmapWidth = (INT)LOWORD(lParam);
@@ -2123 +2123 @@
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 
-    if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
-        return FALSE;
+    if ((LOWORD(lParam) <= 0) || (HIWORD(lParam) <= 0)) return FALSE;
 
     infoPtr->nButtonWidth = (INT)LOWORD(lParam);
@@ -2449 +2448 @@
 
     infoPtr->bCaptured = FALSE;
-    infoPtr->bUnicode = IsWindowUnicode (hwnd);
+    infoPtr->bUnicode = IsWindowUnicode(hwnd);
     infoPtr->nButtonDown = -1;
     infoPtr->nOldHit = -1;
@@ -2460 +2459 @@
     infoPtr->hFont = CreateFontIndirectA (&logFont);
 
-    if (dwStyle & TBSTYLE_TOOLTIPS) {
+    if (dwStyle & TBSTYLE_TOOLTIPS)
+    {
         /* Create tooltip control */
         infoPtr->hwndToolTip =
-            CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
-                               CW_USEDEFAULT, CW_USEDEFAULT,
-                               CW_USEDEFAULT, CW_USEDEFAULT,
-                               hwnd, 0, 0, 0);
+            CreateWindowExA (WS_EX_TOOLWINDOW,TOOLTIPS_CLASSA,NULL,WS_POPUP,
+                               CW_USEDEFAULT,CW_USEDEFAULT,
+                               CW_USEDEFAULT,CW_USEDEFAULT,
+                               hwnd,0,0,0);
 
         /* Send NM_TOOLTIPSCREATED notification */
-        if (infoPtr->hwndToolTip) {
+        if (infoPtr->hwndToolTip)
+        {
             NMTOOLTIPSCREATED nmttc;
 
@@ -2692 +2693 @@
 
     if (infoPtr->hwndToolTip)
-        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                            WM_MOUSEMOVE, wParam, lParam);
+        TOOLBAR_RelayEvent (infoPtr->hwndToolTip,hwnd,
+                            WM_MOUSEMOVE,wParam,lParam);
 
     pt.x = (INT)LOWORD(lParam);
     pt.y = (INT)HIWORD(lParam);
 
-    nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
+    nHit = TOOLBAR_InternalHitTest(hwnd,&pt);
 
     if (infoPtr->nOldHit != nHit)
     {
-        /* Remove the effect of an old hot button */
-        if(infoPtr->nOldHit == infoPtr->nHotItem)
+      /* Remove the effect of an old hot button */
+      if(infoPtr->nOldHit == infoPtr->nHotItem)
+      {
+        oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
+        if (oldBtnPtr->bHot)
         {
-            oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
-            oldBtnPtr->bHot = FALSE;
-
-            InvalidateRect (hwnd, &oldBtnPtr->rect, TRUE);
-        }
-
-        /* It's not a separator or in nowhere. It's a hot button. */
-        if (nHit >= 0)
+          oldBtnPtr->bHot = FALSE;
+
+          InvalidateRect (hwnd, &oldBtnPtr->rect, TRUE);
+        }
+      }
+
+      /* It's not a separator or in nowhere. It's a hot button. */
+      if (nHit >= 0)
+      {
+        btnPtr = &infoPtr->buttons[nHit];
+        if (!btnPtr->bHot)
         {
-            btnPtr = &infoPtr->buttons[nHit];
-            btnPtr->bHot = TRUE;
-
-            hdc = GetDC (hwnd);
-            TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
-            ReleaseDC (hwnd, hdc);
-
-            infoPtr->nHotItem = nHit;
-        }
-
-    if (infoPtr->bCaptured) {
-            btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
-            if (infoPtr->nOldHit == infoPtr->nButtonDown) {
-                btnPtr->fsState &= ~TBSTATE_PRESSED;
-                hdc = GetDC (hwnd);
-                TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
-                ReleaseDC (hwnd, hdc);
-            }
-            else if (nHit == infoPtr->nButtonDown) {
-                btnPtr->fsState |= TBSTATE_PRESSED;
-                hdc = GetDC (hwnd);
-                TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
-                ReleaseDC (hwnd, hdc);
-            }
-        }
-        infoPtr->nOldHit = nHit;
+          btnPtr->bHot = TRUE;
+
+          hdc = GetDC (hwnd);
+          TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
+          ReleaseDC (hwnd, hdc);
+
+          infoPtr->nHotItem = nHit;
+        }
+      }
+
+      if (infoPtr->bCaptured)
+      {
+        btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
+        if (infoPtr->nOldHit == infoPtr->nButtonDown)
+        {
+          btnPtr->fsState &= ~TBSTATE_PRESSED;
+
+          hdc = GetDC (hwnd);
+          TOOLBAR_DrawButton(hwnd,btnPtr,hdc);
+          ReleaseDC(hwnd,hdc);
+        } else if (nHit == infoPtr->nButtonDown)
+        {
+          btnPtr->fsState |= TBSTATE_PRESSED;
+
+          hdc = GetDC(hwnd);
+          TOOLBAR_DrawButton(hwnd,btnPtr,hdc);
+          ReleaseDC(hwnd,hdc);
+        }
+      }
+      infoPtr->nOldHit = nHit;
     }
     return 0;
@@ -2852 +2863 @@
     PAINTSTRUCT ps;
 
-    TOOLBAR_CalcToolbar( hwnd );
-    hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
-    TOOLBAR_Refresh (hwnd, hdc);
-    if (!wParam)
-        EndPaint (hwnd, &ps);
+    TOOLBAR_CalcToolbar(hwnd);
+    hdc = wParam==0 ? BeginPaint(hwnd,&ps) : (HDC)wParam;
+    TOOLBAR_Refresh(hwnd,hdc);
+    if (!wParam) EndPaint (hwnd, &ps);
     return 0;
 }

trunk/src/comctl32/tooltips.c

@@ -1 @@
-/* $Id: tooltips.c,v 1.5 1999-06-16 20:25:44 cbratschi Exp $ */
+/* $Id: tooltips.c,v 1.6 1999-06-24 16:37:45 cbratschi Exp $ */
 /*
  * Tool tip control
@@ -18 +18 @@
  */
 
+/* CB: Odin32 problems
+ - not defined colors: COLOR_INFOBK, COLOR_INFOTEXT
+ - WM_NCCREATE not handled first -> title bar visible if WS_POPUP wasn't set before
+*/
+
 #include <string.h>
 
@@ -53 +58 @@
     UINT uFlags = DT_EXTERNALLEADING;
 
-    if (infoPtr->nMaxTipWidth > -1)
-        uFlags |= DT_WORDBREAK;
-    if (GetWindowLongA (hwnd, GWL_STYLE) & TTS_NOPREFIX)
-        uFlags |= DT_NOPREFIX;
-    GetClientRect (hwnd, &rc);
+    if (infoPtr->nMaxTipWidth > -1) uFlags |= DT_WORDBREAK;
+    if (GetWindowLongA(hwnd,GWL_STYLE) & TTS_NOPREFIX) uFlags |= DT_NOPREFIX;
+    GetClientRect(hwnd,&rc);
 
     /* fill the background */
-    hBrush = CreateSolidBrush (infoPtr->clrBk);
-    FillRect (hdc, &rc, hBrush);
-    DeleteObject (hBrush);
+    hBrush = CreateSolidBrush(infoPtr->clrBk);
+    FillRect(hdc,&rc,hBrush);
+    DeleteObject(hBrush);
 
     /* calculate text rectangle */
-    rc.left   += (2 + infoPtr->rcMargin.left);
-    rc.top    += (2 + infoPtr->rcMargin.top);
-    rc.right  -= (2 + infoPtr->rcMargin.right);
-    rc.bottom -= (2 + infoPtr->rcMargin.bottom);
+    rc.left   += (2+infoPtr->rcMargin.left);
+    rc.top    += (2+infoPtr->rcMargin.top);
+    rc.right  -= (2+infoPtr->rcMargin.right);
+    rc.bottom -= (2+infoPtr->rcMargin.bottom);
 
     /* draw text */
-    oldBkMode = SetBkMode (hdc, TRANSPARENT);
-    SetTextColor (hdc, infoPtr->clrText);
-    hOldFont = SelectObject (hdc, infoPtr->hFont);
-    DrawTextW (hdc, infoPtr->szTipText, -1, &rc, uFlags);
-    SelectObject (hdc, hOldFont);
-    if (oldBkMode != TRANSPARENT)
-        SetBkMode (hdc, oldBkMode);
+    oldBkMode = SetBkMode(hdc,TRANSPARENT);
+    SetTextColor(hdc,infoPtr->clrText);
+    hOldFont = SelectObject(hdc,infoPtr->hFont);
+    DrawTextW(hdc,infoPtr->szTipText,-1,&rc,uFlags);
+    SelectObject(hdc,hOldFont);
+    if (oldBkMode != TRANSPARENT) SetBkMode(hdc,oldBkMode);
 }
 
 
 static VOID
-TOOLTIPS_GetTipText (HWND hwnd, TOOLTIPS_INFO *infoPtr, INT nTool)
+TOOLTIPS_GetTipText(HWND hwnd,TOOLTIPS_INFO *infoPtr,INT nTool)
 {
     TTTOOL_INFO *toolPtr = &infoPtr->tools[nTool];
 
-    if ((toolPtr->hinst) && (HIWORD((UINT)toolPtr->lpszText) == 0)) {
-        /* load a resource */
-//      TRACE (tooltips, "load res string %x %x\n",
-//             toolPtr->hinst, (int)toolPtr->lpszText);
-        LoadStringW (toolPtr->hinst, (UINT)toolPtr->lpszText,
-                       infoPtr->szTipText, INFOTIPSIZE);
-    }
-    else if (toolPtr->lpszText) {
-        if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW) {
-            NMTTDISPINFOA ttnmdi;
-
-            /* fill NMHDR struct */
-            ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFOA));
-            ttnmdi.hdr.hwndFrom = hwnd;
-            ttnmdi.hdr.idFrom = toolPtr->uId;
-            ttnmdi.hdr.code = TTN_GETDISPINFOA;
-            ttnmdi.lpszText = (LPSTR)&ttnmdi.szText;
-            ttnmdi.uFlags = toolPtr->uFlags;
-            ttnmdi.lParam = toolPtr->lParam;
-
-//          TRACE (tooltips, "hdr.idFrom = %x\n", ttnmdi.hdr.idFrom);
-            SendMessageA (toolPtr->hwnd, WM_NOTIFY,
-                            (WPARAM)toolPtr->uId, (LPARAM)&ttnmdi);
-
-            if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.szText) == 0)) {
-                LoadStringW (ttnmdi.hinst, (UINT)ttnmdi.szText,
-                               infoPtr->szTipText, INFOTIPSIZE);
-                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
-                    toolPtr->hinst = ttnmdi.hinst;
-                    toolPtr->lpszText = (LPWSTR)ttnmdi.szText;
-                }
-            }
-            else if (ttnmdi.szText[0]) {
-                lstrcpynAtoW (infoPtr->szTipText, ttnmdi.szText, 80);
-                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
-                    INT len = lstrlenA (ttnmdi.szText);
-                    toolPtr->hinst = 0;
-                    toolPtr->lpszText = COMCTL32_Alloc ((len+1)* sizeof(WCHAR));
-                    lstrcpyAtoW (toolPtr->lpszText, ttnmdi.szText);
-                }
-            }
-            else if (ttnmdi.lpszText == 0) {
-                /* no text available */
-                infoPtr->szTipText[0] = L'\0';
-            }
-            else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA) {
-                lstrcpynAtoW (infoPtr->szTipText, ttnmdi.lpszText, INFOTIPSIZE);
-                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
-                    INT len = lstrlenA (ttnmdi.lpszText);
-                    toolPtr->hinst = 0;
-                    toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
-                    lstrcpyAtoW (toolPtr->lpszText, ttnmdi.lpszText);
-                }
-            }
-            else {
-//              ERR (tooltips, "recursive text callback!\n");
-                infoPtr->szTipText[0] = '\0';
-            }
+    if ((toolPtr->hinst) && (HIWORD((UINT)toolPtr->lpszText) == 0))
+    {
+      /* load a resource */
+//    TRACE (tooltips,"load res string %x %x\n",toolPtr->hinst,(int)toolPtr->lpszText);
+      LoadStringW(toolPtr->hinst,(UINT)toolPtr->lpszText,infoPtr->szTipText,INFOTIPSIZE);
+    } else if (toolPtr->lpszText)
+    {
+      if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW)
+      {
+        NMTTDISPINFOA ttnmdi;
+
+        /* fill NMHDR struct */
+        ZeroMemory (&ttnmdi,sizeof(NMTTDISPINFOA));
+        ttnmdi.hdr.hwndFrom = hwnd;
+        ttnmdi.hdr.idFrom = toolPtr->uId;
+        ttnmdi.hdr.code = TTN_GETDISPINFOA;
+        ttnmdi.lpszText = (LPSTR)&ttnmdi.szText;
+        ttnmdi.uFlags = toolPtr->uFlags;
+        ttnmdi.lParam = toolPtr->lParam;
+        //          TRACE (tooltips, "hdr.idFrom = %x\n", ttnmdi.hdr.idFrom);
+        SendMessageA (toolPtr->hwnd,WM_NOTIFY,(WPARAM)toolPtr->uId,(LPARAM)&ttnmdi);
+
+        if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.szText) == 0))
+        {
+          LoadStringW (ttnmdi.hinst,(UINT)ttnmdi.szText,infoPtr->szTipText,INFOTIPSIZE);
+          if (ttnmdi.uFlags & TTF_DI_SETITEM)
+          {
+            toolPtr->hinst = ttnmdi.hinst;
+            toolPtr->lpszText = (LPWSTR)ttnmdi.szText;
+          }
+        } else if (ttnmdi.szText[0])
+        {
+          lstrcpynAtoW (infoPtr->szTipText,ttnmdi.szText,80);
+          if (ttnmdi.uFlags & TTF_DI_SETITEM)
+          {
+            INT len = lstrlenA(ttnmdi.szText);
+            toolPtr->hinst = 0;
+            toolPtr->lpszText = COMCTL32_Alloc((len+1)* sizeof(WCHAR));
+            lstrcpyAtoW(toolPtr->lpszText,ttnmdi.szText);
+          }
+        } else if (ttnmdi.lpszText == 0)
+        {
+          /* no text available */
+          infoPtr->szTipText[0] = L'\0';
+        } else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA)
+        {
+          lstrcpynAtoW(infoPtr->szTipText,ttnmdi.lpszText,INFOTIPSIZE);
+          if (ttnmdi.uFlags & TTF_DI_SETITEM)
+          {
+            INT len = lstrlenA(ttnmdi.lpszText);
+            toolPtr->hinst = 0;
+            toolPtr->lpszText = COMCTL32_Alloc((len+1)*sizeof(WCHAR));
+            lstrcpyAtoW(toolPtr->lpszText,ttnmdi.lpszText);
+          }
+        } else
+        {
+//        ERR (tooltips, "recursive text callback!\n");
+          infoPtr->szTipText[0] = '\0';
         }
-        else {
-            /* the item is a usual (unicode) text */
-//          lstrcpynW (infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
-            strncpy(infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
-        }
-    }
-    else {
-        /* no text available */
-        infoPtr->szTipText[0] = L'\0';
+      } else
+      {
+        /* the item is a usual (unicode) text */
+      lstrcpynW (infoPtr->szTipText,toolPtr->lpszText,INFOTIPSIZE);
+      }
+    }
+    else
+    {
+      /* no text available */
+      infoPtr->szTipText[0] = L'\0';
     }
 
@@ -159 +162 @@
 }
 
-
 static VOID
-TOOLTIPS_CalcTipSize (HWND hwnd, TOOLTIPS_INFO *infoPtr, LPSIZE lpSize)
+TOOLTIPS_CalcTipSize (HWND hwnd,TOOLTIPS_INFO *infoPtr,LPSIZE lpSize)
 {
     HDC hdc;
     HFONT hOldFont;
     UINT uFlags = DT_EXTERNALLEADING | DT_CALCRECT;
-    RECT rc = {0, 0, 0, 0};
-
-    if (infoPtr->nMaxTipWidth > -1) {
-        rc.right = infoPtr->nMaxTipWidth;
-        uFlags |= DT_WORDBREAK;
-    }
-    if (GetWindowLongA (hwnd, GWL_STYLE) & TTS_NOPREFIX)
-        uFlags |= DT_NOPREFIX;
+    RECT rc = {0,0,0,0};
+
+    if (infoPtr->nMaxTipWidth > -1)
+    {
+      rc.right = infoPtr->nMaxTipWidth;
+      uFlags |= DT_WORDBREAK;
+    }
+    if (GetWindowLongA(hwnd,GWL_STYLE) & TTS_NOPREFIX) uFlags |= DT_NOPREFIX;
 //    TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
 
-    hdc = GetDC (hwnd);
-    hOldFont = SelectObject (hdc, infoPtr->hFont);
-    DrawTextW (hdc, infoPtr->szTipText, -1, &rc, uFlags);
-    SelectObject (hdc, hOldFont);
-    ReleaseDC (hwnd, hdc);
-
-    lpSize->cx = rc.right - rc.left + 4 +
-                 infoPtr->rcMargin.left + infoPtr->rcMargin.right;
-    lpSize->cy = rc.bottom - rc.top + 4 +
-                 infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
+    hdc = GetDC(hwnd);
+    hOldFont = SelectObject(hdc,infoPtr->hFont);
+    DrawTextW(hdc,infoPtr->szTipText,-1,&rc,uFlags);
+    SelectObject(hdc,hOldFont);
+    ReleaseDC(hwnd,hdc);
+
+    lpSize->cx = rc.right-rc.left+4+infoPtr->rcMargin.left+infoPtr->rcMargin.right;
+    lpSize->cy = rc.bottom-rc.top+4+infoPtr->rcMargin.bottom+infoPtr->rcMargin.top;
 }
 
@@ -198 +198 @@
     NMHDR  hdr;
 
-    if (infoPtr->nTool == -1) {
+    if (infoPtr->nTool == -1)
+    {
 //      TRACE (tooltips, "invalid tool (-1)!\n");
         return;
@@ -207 +208 @@
 //    TRACE (tooltips, "Show tooltip pre %d!\n", infoPtr->nTool);
 
-    TOOLTIPS_GetTipText (hwnd, infoPtr, infoPtr->nCurrentTool);
-
-    if (infoPtr->szTipText[0] == L'\0') {
+    TOOLTIPS_GetTipText(hwnd,infoPtr,infoPtr->nCurrentTool);
+
+    if (infoPtr->szTipText[0] == L'\0')
+    {
         infoPtr->nCurrentTool = -1;
         return;
@@ -220 +222 @@
     hdr.idFrom = toolPtr->uId;
     hdr.code = TTN_SHOW;
-    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
-                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
+    SendMessageA(toolPtr->hwnd,WM_NOTIFY,
+                    (WPARAM)toolPtr->uId,(LPARAM)&hdr);
 
 //    TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
@@ -228 +230 @@
 //    TRACE (tooltips, "size %d - %d\n", size.cx, size.cy);
 
-    if (toolPtr->uFlags & TTF_CENTERTIP) {
+    if (toolPtr->uFlags & TTF_CENTERTIP)
+    {
         RECT rc;
 
         if (toolPtr->uFlags & TTF_IDISHWND)
             GetWindowRect ((HWND)toolPtr->uId, &rc);
-        else {
+        else
+        {
             rc = toolPtr->rect;
             MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
@@ -239 +243 @@
         rect.left = (rc.left + rc.right - size.cx) / 2;
         rect.top  = rc.bottom + 2;
-    }
-    else {
-        GetCursorPos ((LPPOINT)&rect);
+    } else
+    {
+        GetCursorPos((LPPOINT)&rect);
         rect.top += 20;
     }
@@ -252 +256 @@
     rect.bottom = rect.top + size.cy;
 
-    AdjustWindowRectEx (&rect, GetWindowLongA (hwnd, GWL_STYLE),
-                        FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
-
-    SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
-                    rect.right - rect.left, rect.bottom - rect.top,
+    AdjustWindowRectEx (&rect,GetWindowLongA(hwnd, GWL_STYLE),
+                        FALSE,GetWindowLongA(hwnd, GWL_EXSTYLE));
+
+    SetWindowPos (hwnd,HWND_TOP,rect.left,rect.top,
+                    rect.right-rect.left,rect.bottom-rect.top,
                     SWP_SHOWWINDOW | SWP_NOACTIVATE);
 
     /* repaint the tooltip */
-    hdc = GetDC (hwnd);
-    TOOLTIPS_Refresh (hwnd, hdc);
-    ReleaseDC (hwnd, hdc);
-
-    SetTimer (hwnd, ID_TIMERPOP, infoPtr->nAutoPopTime, 0);
+    hdc = GetDC(hwnd);
+    TOOLTIPS_Refresh(hwnd,hdc);
+    ReleaseDC(hwnd,hdc);
+
+    SetTimer (hwnd,ID_TIMERPOP,infoPtr->nAutoPopTime,0);
 }
 
@@ -303 +307 @@
     NMHDR hdr;
 
-    if (infoPtr->nTrackTool == -1) {
-//      TRACE (tooltips, "invalid tracking tool (-1)!\n");
-        return;
+    if (infoPtr->nTrackTool == -1)
+    {
+//    TRACE (tooltips, "invalid tracking tool (-1)!\n");
+      return;
     }
 
 //    TRACE (tooltips, "show tracking tooltip pre %d!\n", infoPtr->nTrackTool);
 
-    TOOLTIPS_GetTipText (hwnd, infoPtr, infoPtr->nTrackTool);
-
-    if (infoPtr->szTipText[0] == L'\0') {
-        infoPtr->nTrackTool = -1;
-        return;
+    TOOLTIPS_GetTipText(hwnd,infoPtr,infoPtr->nTrackTool);
+
+    if (infoPtr->szTipText[0] == L'\0')
+    {
+      infoPtr->nTrackTool = -1;
+      return;
     }
 
@@ -323 +329 @@
     hdr.idFrom = toolPtr->uId;
     hdr.code = TTN_SHOW;
-    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
-                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
+    SendMessageA(toolPtr->hwnd,WM_NOTIFY,(WPARAM)toolPtr->uId,(LPARAM)&hdr);
 
 //    TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
 
-    TOOLTIPS_CalcTipSize (hwnd, infoPtr, &size);
+    TOOLTIPS_CalcTipSize(hwnd,infoPtr,&size);
 //    TRACE (tooltips, "size %d - %d\n", size.cx, size.cy);
 
-    if (toolPtr->uFlags & TTF_ABSOLUTE) {
-        rect.left = infoPtr->xTrackPos;
-        rect.top  = infoPtr->yTrackPos;
-
-        if (toolPtr->uFlags & TTF_CENTERTIP) {
-            rect.left -= (size.cx / 2);
-            rect.top  -= (size.cy / 2);
-        }
-    }
-    else {
-        RECT rcTool;
-
-        if (toolPtr->uFlags & TTF_IDISHWND)
-            GetWindowRect ((HWND)toolPtr->uId, &rcTool);
-        else {
-            rcTool = toolPtr->rect;
-            MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rcTool, 2);
-        }
-
-        GetCursorPos ((LPPOINT)&rect);
-        rect.top += 20;
-
-        if (toolPtr->uFlags & TTF_CENTERTIP) {
-            rect.left -= (size.cx / 2);
-            rect.top  -= (size.cy / 2);
-        }
-
-        /* smart placement */
-        if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) &&
-            (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom))
-            rect.left = rcTool.right;
+    if (toolPtr->uFlags & TTF_ABSOLUTE)
+    {
+      rect.left = infoPtr->xTrackPos;
+      rect.top  = infoPtr->yTrackPos;
+
+      if (toolPtr->uFlags & TTF_CENTERTIP)
+      {
+        rect.left -= (size.cx/2);
+        rect.top  -= (size.cy/2);
+      }
+    } else
+    {
+      RECT rcTool;
+
+      if (toolPtr->uFlags & TTF_IDISHWND)
+      {
+        GetWindowRect((HWND)toolPtr->uId,&rcTool); //screen coordinates
+      } else
+      {
+        rcTool = toolPtr->rect;
+        MapWindowPoints(toolPtr->hwnd,(HWND)0,(LPPOINT)&rcTool,2);
+      }
+
+      GetCursorPos ((LPPOINT)&rect);
+      rect.top += 20;
+
+      if (toolPtr->uFlags & TTF_CENTERTIP)
+      {
+        rect.left -= (size.cx / 2);
+        rect.top  -= (size.cy / 2);
+      }
+
+      /* smart placement */
+      if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) &&
+          (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom))
+          rect.left = rcTool.right;
     }
 
 //    TRACE (tooltips, "pos %d - %d\n", rect.left, rect.top);
 
-    rect.right = rect.left + size.cx;
-    rect.bottom = rect.top + size.cy;
-
-    AdjustWindowRectEx (&rect, GetWindowLongA (hwnd, GWL_STYLE),
-                        FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
-
-    SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
-                    rect.right - rect.left, rect.bottom - rect.top,
+    rect.right = rect.left+size.cx;
+    rect.bottom = rect.top+size.cy;
+
+    AdjustWindowRectEx (&rect,GetWindowLongA(hwnd,GWL_STYLE),
+                        FALSE,GetWindowLongA(hwnd,GWL_EXSTYLE));
+
+    SetWindowPos (hwnd,HWND_TOP,rect.left,rect.top,
+                    rect.right-rect.left,rect.bottom-rect.top,
                     SWP_SHOWWINDOW | SWP_NOACTIVATE );
 
@@ -564 +574 @@
 
 static LRESULT
-TOOLTIPS_AddToolA (HWND hwnd, WPARAM wParam, LPARAM lParam)
-{
-    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
+TOOLTIPS_AddToolA(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
     LPTTTOOLINFOA lpToolInfo = (LPTTTOOLINFOA)lParam;
     TTTOOL_INFO *toolPtr;
 
+    if (lpToolInfo == NULL) return FALSE;
+    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
+
+//    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
+//         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
+//         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
+
+    if (infoPtr->uNumTools == 0)
+    {
+      infoPtr->tools = COMCTL32_Alloc(sizeof(TTTOOL_INFO));
+      toolPtr = infoPtr->tools;
+    } else
+    {
+      TTTOOL_INFO *oldTools = infoPtr->tools;
+
+      //CB: check if already exists!
+
+      infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO)*(infoPtr->uNumTools+1));
+      memcpy (infoPtr->tools,oldTools,infoPtr->uNumTools*sizeof(TTTOOL_INFO));
+      COMCTL32_Free(oldTools);
+      toolPtr = &infoPtr->tools[infoPtr->uNumTools];
+    }
+
+    infoPtr->uNumTools++;
+
+    /* copy tool data */
+    toolPtr->uFlags = lpToolInfo->uFlags;
+    toolPtr->hwnd   = lpToolInfo->hwnd;
+    toolPtr->uId    = lpToolInfo->uId;
+    toolPtr->rect   = lpToolInfo->rect;
+    toolPtr->hinst  = lpToolInfo->hinst;
+
+    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0))
+    {
+//    TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
+      toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
+    } else if (lpToolInfo->lpszText)
+    {
+      if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
+      {
+//      TRACE (tooltips, "add CALLBACK!\n");
+        toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
+      } else
+      {
+        INT len = lstrlenA (lpToolInfo->lpszText);
+//          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
+        toolPtr->lpszText = COMCTL32_Alloc((len+1)*sizeof(WCHAR));
+        lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
+      }
+    } else toolPtr->lpszText = NULL;
+
+    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
+        toolPtr->lParam = lpToolInfo->lParam;
+
+    /* install subclassing hook */
+    if (toolPtr->uFlags & TTF_SUBCLASS)
+    {
+      if (toolPtr->uFlags & TTF_IDISHWND)
+      {
+        LPTT_SUBCLASS_INFO lpttsi =
+            (LPTT_SUBCLASS_INFO)GetPropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
+        if (lpttsi == NULL)
+        {
+          lpttsi = (LPTT_SUBCLASS_INFO)COMCTL32_Alloc(sizeof(TT_SUBCLASS_INFO));
+          lpttsi->wpOrigProc =
+              (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
+              GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
+          lpttsi->hwndToolTip = hwnd;
+          lpttsi->uRefCount++;
+          SetPropA ((HWND)toolPtr->uId,COMCTL32_aSubclass,(HANDLE)lpttsi);
+        }
+//          else
+//              WARN (tooltips, "A window tool must only be listed once!\n");
+      } else
+      {
+        LPTT_SUBCLASS_INFO lpttsi =
+           (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
+        if (lpttsi == NULL)
+        {
+          lpttsi = (LPTT_SUBCLASS_INFO)COMCTL32_Alloc(sizeof(TT_SUBCLASS_INFO));
+          lpttsi->wpOrigProc =
+              (WNDPROC)SetWindowLongA (toolPtr->hwnd,
+              GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
+          lpttsi->hwndToolTip = hwnd;
+          lpttsi->uRefCount++;
+          SetPropA(toolPtr->hwnd,COMCTL32_aSubclass,(HANDLE)lpttsi);
+        } else lpttsi->uRefCount++;
+      }
+//      TRACE (tooltips, "subclassing installed!\n");
+    }
+
+    return TRUE;
+}
+
+
+static LRESULT
+TOOLTIPS_AddToolW (HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
+    LPTTTOOLINFOW lpToolInfo = (LPTTTOOLINFOW)lParam;
+    TTTOOL_INFO *toolPtr;
+
     if (lpToolInfo == NULL)
         return FALSE;
-    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
+    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
         return FALSE;
 
@@ -607 +719 @@
     }
     else if (lpToolInfo->lpszText) {
-        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA) {
+        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW) {
 //          TRACE (tooltips, "add CALLBACK!\n");
             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
         }
         else {
-            INT len = lstrlenA (lpToolInfo->lpszText);
-//          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
+            INT len = lstrlenW (lpToolInfo->lpszText);
+//          TRACE (tooltips, "add text \"%s\"!\n",
+//                 debugstr_w(lpToolInfo->lpszText));
             toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
+            lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
         }
     }
 
-    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
+    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
         toolPtr->lParam = lpToolInfo->lParam;
 
@@ -665 +778 @@
 
 static LRESULT
-TOOLTIPS_AddToolW (HWND hwnd, WPARAM wParam, LPARAM lParam)
-{
-    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
-    LPTTTOOLINFOW lpToolInfo = (LPTTTOOLINFOW)lParam;
-    TTTOOL_INFO *toolPtr;
-
-    if (lpToolInfo == NULL)
-        return FALSE;
-    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
-        return FALSE;
-
-//    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
-//         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
-//         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
-
-    if (infoPtr->uNumTools == 0) {
-        infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
-        toolPtr = infoPtr->tools;
-    }
-    else {
-        TTTOOL_INFO *oldTools = infoPtr->tools;
-        infoPtr->tools =
-            COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
-        memcpy (infoPtr->tools, oldTools,
-                infoPtr->uNumTools * sizeof(TTTOOL_INFO));
-        COMCTL32_Free (oldTools);
-        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
-    }
-
-    infoPtr->uNumTools++;
-
-    /* copy tool data */
-    toolPtr->uFlags = lpToolInfo->uFlags;
-    toolPtr->hwnd   = lpToolInfo->hwnd;
-    toolPtr->uId    = lpToolInfo->uId;
-    toolPtr->rect   = lpToolInfo->rect;
-    toolPtr->hinst  = lpToolInfo->hinst;
-
-    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
-//      TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
-        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
-    }
-    else if (lpToolInfo->lpszText) {
-        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW) {
-//          TRACE (tooltips, "add CALLBACK!\n");
-            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
-        }
-        else {
-            INT len = lstrlenW (lpToolInfo->lpszText);
-//          TRACE (tooltips, "add text \"%s\"!\n",
-//                 debugstr_w(lpToolInfo->lpszText));
-            toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
-        }
-    }
-
-    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
-        toolPtr->lParam = lpToolInfo->lParam;
-
-    /* install subclassing hook */
-    if (toolPtr->uFlags & TTF_SUBCLASS) {
-        if (toolPtr->uFlags & TTF_IDISHWND) {
-            LPTT_SUBCLASS_INFO lpttsi =
-                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
-            if (lpttsi == NULL) {
-                lpttsi =
-                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
-                lpttsi->wpOrigProc =
-                    (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
-                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
-                lpttsi->hwndToolTip = hwnd;
-                lpttsi->uRefCount++;
-                SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
-                            (HANDLE)lpttsi);
-            }
-//          else
-//              WARN (tooltips, "A window tool must only be listed once!\n");
-        }
-        else {
-            LPTT_SUBCLASS_INFO lpttsi =
-                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
-            if (lpttsi == NULL) {
-                lpttsi =
-                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
-                lpttsi->wpOrigProc =
-                    (WNDPROC)SetWindowLongA (toolPtr->hwnd,
-                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
-                lpttsi->hwndToolTip = hwnd;
-                lpttsi->uRefCount++;
-                SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
-            }
-            else
-                lpttsi->uRefCount++;
-        }
-//      TRACE (tooltips, "subclassing installed!\n");
-    }
-
-    return TRUE;
-}
-
-
-static LRESULT
 TOOLTIPS_DelToolA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1401 +1412 @@
     POINT pt;
 
-    if (lParam == 0) {
-//      ERR (tooltips, "lpMsg == NULL!\n");
-        return 0;
-    }
-
-    switch (lpMsg->message) {
+    if (lParam == 0)
+    {
+//    ERR (tooltips, "lpMsg == NULL!\n");
+      return 0;
+    }
+
+    switch (lpMsg->message)
+    {
         case WM_LBUTTONDOWN:
         case WM_LBUTTONUP:
@@ -1414 +1427 @@
         case WM_RBUTTONUP:
             pt = lpMsg->pt;
-            ScreenToClient (lpMsg->hwnd, &pt);
+            ScreenToClient(lpMsg->hwnd,&pt);
             infoPtr->nOldTool = infoPtr->nTool;
-            infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
+            infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr,lpMsg->hwnd,&pt);
 //          TRACE (tooltips, "tool (%x) %d %d\n",
 //                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
@@ -1424 +1437 @@
         case WM_MOUSEMOVE:
             pt = lpMsg->pt;
-            ScreenToClient (lpMsg->hwnd, &pt);
+            ScreenToClient(lpMsg->hwnd,&pt);
             infoPtr->nOldTool = infoPtr->nTool;
-            infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
+            infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr,lpMsg->hwnd,&pt);
 //          TRACE (tooltips, "tool (%x) %d %d\n",
 //                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
 //          TRACE (tooltips, "WM_MOUSEMOVE (%04x %ld %ld)\n",
 //                 hwnd, pt.x, pt.y);
-            if ((infoPtr->bActive) && (infoPtr->nTool != infoPtr->nOldTool)) {
-                if (infoPtr->nOldTool == -1) {
-                    SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nInitialTime, 0);
-//                  TRACE (tooltips, "timer 1 started!\n");
-                }
-                else {
-                    TOOLTIPS_Hide (hwnd, infoPtr);
-                    SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
-//                  TRACE (tooltips, "timer 2 started!\n");
-                }
+infoPtr->bActive = TRUE;//CB: somewhere reset, find it!!!
+            if (infoPtr->bActive && (infoPtr->nTool != infoPtr->nOldTool))
+            {
+              if (infoPtr->nOldTool == -1)
+              {
+                SetTimer(hwnd,ID_TIMERSHOW,infoPtr->nInitialTime,0);
+//              TRACE (tooltips, "timer 1 started!\n");
+              } else
+              {
+                TOOLTIPS_Hide(hwnd,infoPtr);
+                SetTimer (hwnd,ID_TIMERSHOW,infoPtr->nReshowTime,0);
+//              TRACE (tooltips, "timer 2 started!\n");
+              }
             }
-            if (infoPtr->nCurrentTool != -1) {
-                SetTimer (hwnd, ID_TIMERLEAVE, 100, 0);
-//              TRACE (tooltips, "timer 3 started!\n");
+            if (infoPtr->nCurrentTool != -1)
+            {
+              SetTimer(hwnd,ID_TIMERLEAVE,100,0);
+//            TRACE (tooltips, "timer 3 started!\n");
             }
             break;
@@ -1655 +1672 @@
     LPTTTOOLINFOA lpToolInfo = (LPTTTOOLINFOA)lParam;
 
-    if (lpToolInfo == NULL)
-        return 0;
-    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
-        return FALSE;
-
-    if ((BOOL)wParam) {
-        /* activate */
-        infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
-        if (infoPtr->nTrackTool != -1) {
-//          TRACE (tooltips, "activated!\n");
-            infoPtr->bTrackActive = TRUE;
-            TOOLTIPS_TrackShow (hwnd, infoPtr);
-        }
-    }
-    else {
-        /* deactivate */
-        TOOLTIPS_TrackHide (hwnd, infoPtr);
-
-        infoPtr->bTrackActive = FALSE;
-        infoPtr->nTrackTool = -1;
+    if (lpToolInfo == NULL) return 0;
+    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
+
+    if ((BOOL)wParam)
+    {
+      /* activate */
+      infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA(infoPtr,lpToolInfo);
+      if (infoPtr->nTrackTool != -1)
+      {
+//      TRACE (tooltips, "activated!\n");
+        infoPtr->bTrackActive = TRUE;
+        TOOLTIPS_TrackShow(hwnd,infoPtr);
+      }
+    } else
+    {
+      /* deactivate */
+      TOOLTIPS_TrackHide(hwnd,infoPtr);
+
+      infoPtr->bTrackActive = FALSE;
+      infoPtr->nTrackTool = -1;
 
 //      TRACE (tooltips, "deactivated!\n");
@@ -1691 +1708 @@
     infoPtr->yTrackPos = (INT)HIWORD(lParam);
 
-    if (infoPtr->bTrackActive) {
+    if (infoPtr->bTrackActive)
+    {
 //      TRACE (tooltips, "[%d %d]\n",
 //             infoPtr->xTrackPos, infoPtr->yTrackPos);
 
-        TOOLTIPS_TrackShow (hwnd, infoPtr);
+      TOOLTIPS_TrackShow(hwnd,infoPtr);
     }
 
@@ -1722 +1740 @@
     INT nTool;
 
-    if (lpToolInfo == NULL)
-        return 0;
-    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
-        return FALSE;
-
-    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
+    if (lpToolInfo == NULL) return 0;
+    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
+
+    nTool = TOOLTIPS_GetToolFromInfoA(infoPtr,lpToolInfo);
     if (nTool == -1) return 0;
 
@@ -1737 +1753 @@
     toolPtr->hinst  = lpToolInfo->hinst;
 
-    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)){
-        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
-    }
-    else if (lpToolInfo->lpszText) {
-        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
-            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
-        else {
-            if (toolPtr->lpszText) {
-                COMCTL32_Free (toolPtr->lpszText);
-                toolPtr->lpszText = NULL;
-            }
-            if (lpToolInfo->lpszText) {
-                INT len = lstrlenA (lpToolInfo->lpszText);
-                toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
-                lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
-            }
+    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0))
+    {
+      toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
+    } else if (lpToolInfo->lpszText)
+    {
+      if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA) toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
+      else
+      {
+        if (toolPtr->lpszText)
+        {
+          COMCTL32_Free(toolPtr->lpszText);
+          toolPtr->lpszText = NULL;
         }
+        if (lpToolInfo->lpszText)
+        {
+          INT len = lstrlenA(lpToolInfo->lpszText);
+          toolPtr->lpszText = COMCTL32_Alloc((len+1)*sizeof(WCHAR));
+          lstrcpyAtoW(toolPtr->lpszText,lpToolInfo->lpszText);
+        }
+      }
     }
 
     /* force repaint */
-    if (infoPtr->bActive)
-        TOOLTIPS_Show (hwnd, infoPtr);
-    else if (infoPtr->bTrackActive)
-        TOOLTIPS_TrackShow (hwnd, infoPtr);
+    if (infoPtr->bActive) TOOLTIPS_Show(hwnd,infoPtr);
+    else if (infoPtr->bTrackActive) TOOLTIPS_TrackShow(hwnd,infoPtr);
 
     return 0;
@@ -1835 +1852 @@
 
     /* allocate memory for info structure */
-    infoPtr = (TOOLTIPS_INFO *)COMCTL32_Alloc (sizeof(TOOLTIPS_INFO));
-    SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
+    infoPtr = (TOOLTIPS_INFO *)COMCTL32_Alloc(sizeof(TOOLTIPS_INFO));
+    SetWindowLongA(hwnd,0,(DWORD)infoPtr);
 
     /* initialize info structure */
     infoPtr->bActive = TRUE;
     infoPtr->bTrackActive = FALSE;
-    infoPtr->clrBk   = GetSysColor (COLOR_INFOBK);
-    infoPtr->clrText = GetSysColor (COLOR_INFOTEXT);
+    infoPtr->clrBk   = RGB(0,0,0);//GetSysColor(COLOR_INFOBK);//CB: to change
+    infoPtr->clrText = RGB(255,255,255);//GetSysColor(COLOR_INFOTEXT);//CB: to change
 
     nclm.cbSize = sizeof(NONCLIENTMETRICSA);
-    SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
-    infoPtr->hFont = CreateFontIndirectA (&nclm.lfStatusFont);
+    SystemParametersInfoA(SPI_GETNONCLIENTMETRICS,0,&nclm,0);
+    infoPtr->hFont = CreateFontIndirectA(&nclm.lfStatusFont);
 
     infoPtr->nMaxTipWidth = -1;
@@ -1859 +1876 @@
     infoPtr->nInitialTime   = 500;
 
-    nResult = (INT) SendMessageA (GetParent (hwnd), WM_NOTIFYFORMAT,
-                                  (WPARAM)hwnd, (LPARAM)NF_QUERY);
+    SetRectEmpty(&infoPtr->rcMargin);
+
+    nResult = (INT)SendMessageA(GetParent(hwnd),WM_NOTIFYFORMAT,(WPARAM)hwnd,(LPARAM)NF_QUERY);
 //    if (nResult == NFR_ANSI)
 //      TRACE (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_ANSI\n");
@@ -1868 +1886 @@
 //      FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: error!\n");
 
-    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
+    SetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
 
     return 0;
@@ -1877 +1895 @@
 TOOLTIPS_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
+    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
     TTTOOL_INFO *toolPtr;
     INT i;
 
     /* free tools */
-    if (infoPtr->tools) {
-        for (i = 0; i < infoPtr->uNumTools; i++) {
-            toolPtr = &infoPtr->tools[i];
-            if ((toolPtr->hinst) && (toolPtr->lpszText)) {
-                if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
-                    COMCTL32_Free (toolPtr->lpszText);
-            }
-
-            /* remove subclassing */
-            if (toolPtr->uFlags & TTF_SUBCLASS) {
-                LPTT_SUBCLASS_INFO lpttsi;
-
-                if (toolPtr->uFlags & TTF_IDISHWND)
-                    lpttsi = (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
-                else
-                    lpttsi = (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
-
-                if (lpttsi) {
-                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
-                                      (LONG)lpttsi->wpOrigProc);
-                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
-                    COMCTL32_Free (&lpttsi);
-                }
-            }
+    if (infoPtr->tools)
+    {
+      for (i = 0;i < infoPtr->uNumTools;i++)
+      {
+        toolPtr = &infoPtr->tools[i];
+        if ((toolPtr->hinst) && (toolPtr->lpszText))
+        {
+          if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(toolPtr->lpszText);
         }
-        COMCTL32_Free (infoPtr->tools);
+
+        /* remove subclassing */
+        if (toolPtr->uFlags & TTF_SUBCLASS)
+        {
+          LPTT_SUBCLASS_INFO lpttsi;
+
+          if (toolPtr->uFlags & TTF_IDISHWND)
+              lpttsi = (LPTT_SUBCLASS_INFO)GetPropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
+          else
+              lpttsi = (LPTT_SUBCLASS_INFO)GetPropA(toolPtr->hwnd,COMCTL32_aSubclass);
+
+          if (lpttsi)
+          {
+            SetWindowLongA ((HWND)toolPtr->uId,GWL_WNDPROC,(LONG)lpttsi->wpOrigProc);
+            RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
+            COMCTL32_Free (&lpttsi);
+          }
+        }
+      }
+      COMCTL32_Free (infoPtr->tools);
     }
 
@@ -1914 +1935 @@
 
     /* free tool tips info data */
-    COMCTL32_Free (infoPtr);
+    COMCTL32_Free(infoPtr);
 
     return 0;
@@ -1959 +1980 @@
 TOOLTIPS_NCCreate (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+    DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+    DWORD dwExStyle = GetWindowLongA(hwnd,GWL_EXSTYLE);
 
     dwStyle &= 0x0000FFFF;
     dwStyle |= (WS_POPUP | WS_BORDER | WS_CLIPSIBLINGS);
-    SetWindowLongA (hwnd, GWL_STYLE, dwStyle);
+    SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
+
+    SetWindowLongA(hwnd,GWL_EXSTYLE,dwExStyle | WS_EX_TOOLWINDOW);
 
     return TRUE;
@@ -2073 +2097 @@
     switch (wParam)
     {
-        case ID_TIMERSHOW:
-            KillTimer (hwnd, ID_TIMERSHOW);
-            if (TOOLTIPS_CheckTool (hwnd, TRUE) == infoPtr->nTool)
-                TOOLTIPS_Show (hwnd, infoPtr);
-            break;
-
-        case ID_TIMERPOP:
-            TOOLTIPS_Hide (hwnd, infoPtr);
-            break;
-
-        case ID_TIMERLEAVE:
-            KillTimer (hwnd, ID_TIMERLEAVE);
-            if (TOOLTIPS_CheckTool (hwnd, FALSE) == -1) {
-                infoPtr->nTool = -1;
-                infoPtr->nOldTool = -1;
-                TOOLTIPS_Hide (hwnd, infoPtr);
-            }
-            break;
+      case ID_TIMERSHOW:
+          KillTimer (hwnd,ID_TIMERSHOW);
+          if (TOOLTIPS_CheckTool(hwnd,TRUE) == infoPtr->nTool)
+              TOOLTIPS_Show(hwnd,infoPtr);
+          break;
+
+      case ID_TIMERPOP:
+          TOOLTIPS_Hide (hwnd, infoPtr);
+          break;
+
+      case ID_TIMERLEAVE:
+          KillTimer (hwnd,ID_TIMERLEAVE);
+          if (TOOLTIPS_CheckTool(hwnd,FALSE) == -1)
+          {
+            infoPtr->nTool = -1;
+            infoPtr->nOldTool = -1;
+            TOOLTIPS_Hide(hwnd,infoPtr);
+          }
+          break;
     }
     return 0;

trunk/src/comctl32/trackbar.c

@@ -1 @@
-/* $Id: trackbar.c,v 1.6 1999-06-21 15:28:44 cbratschi Exp $ */
+/* $Id: trackbar.c,v 1.7 1999-06-24 16:37:45 cbratschi Exp $ */
 /*
  * Trackbar control
@@ -54 +54 @@
 #define THUMB_MINLEN 4
 
-#define CHANNEL_NOSEL_HEIGHT 4
-#define CHANNEL_MIN_HEIGHT   4
-#define CHANNEL_THUMB_DIFF   8
+#define CHANNEL_NOSEL_HEIGHT 4 //min no sel height
+#define CHANNEL_MIN_HEIGHT   6 //min sel height
+#define CHANNEL_THUMB_DIFF   8 //sel thumb, channel difference
 #define CHANNEL_SPACE        8
-#define CHANNEL_SCALE_SPACE  CHANNEL_THUMB_DIFF/2+SCALE_SIZE+SCALE_SPACE+BORDER_SIZE
-#define CHANNEL_THUMB_SPACE  CHANNEL_THUMB_DIFF+BORDER_SIZE
+#define CHANNEL_SCALE_SPACE  SCALE_SIZE+SCALE_SPACE+BORDER_SIZE
+#define CHANNEL_THUMB_SPACE  BORDER_SIZE
 
 /* scroll mode */
@@ -102 +102 @@
     }
 
-    if (!(dwStyle & TBS_AUTOTICKS)) return;
-
-    if (infoPtr->uTicFreq == 0)
+    if (infoPtr->uTicFreq && infoPtr->nRangeMax > infoPtr->nRangeMin && (dwStyle & TBS_AUTOTICKS))
+    {
+      //Tics without start and end tic
+      nrTics = (infoPtr->nRangeMax-infoPtr->nRangeMin)/infoPtr->uTicFreq-1;
+      if (nrTics <= 0)
+      {
+        COMCTL32_Free(infoPtr->tics);
+        infoPtr->tics = NULL;
+        infoPtr->uNumTics = 0;
+        return;
+      }
+    } else
     {
       COMCTL32_Free(infoPtr->tics);
@@ -112 +121 @@
     }
 
-    if (infoPtr->uTicFreq && infoPtr->nRangeMax > infoPtr->nRangeMin && (dwStyle & TBS_AUTOTICKS))
-    {
-      //Tics without start and end tic
-      nrTics = (infoPtr->nRangeMax-infoPtr->nRangeMin)/infoPtr->uTicFreq-1;
-    } else
-    {
-      COMCTL32_Free(infoPtr->tics);
-      infoPtr->tics = NULL;
-      infoPtr->uNumTics = 0;
-      return;
-    }
-
     if (nrTics != infoPtr->uNumTics)
     {
@@ -173 +170 @@
     INT channelSize;
     RECT lpRect,*channel = &infoPtr->rcChannel;
+    INT thumbDiff;
 
     GetClientRect(hwnd,&lpRect);
@@ -179 +177 @@
     else channelSize = CHANNEL_NOSEL_HEIGHT;
 
+    thumbDiff = (infoPtr->uThumbLen-channelSize)/2;
+
     if (dwStyle & TBS_VERT)
     {
@@ -184 +184 @@
       channel->bottom = lpRect.bottom-CHANNEL_SPACE;
 
-      if (dwStyle & TBS_BOTH)
+      if (dwStyle & TBS_BOTH || dwStyle & TBS_NOTICKS)
       { //center
         channel->left  = (lpRect.right-channelSize)/2;
@@ -190 +190 @@
       } else if (dwStyle & TBS_LEFT)
       {
-        channel->left  = lpRect.left+CHANNEL_SCALE_SPACE;
+        channel->left  = lpRect.left+thumbDiff+CHANNEL_SCALE_SPACE;
         channel->right = channel->left+channelSize;
       } else
       { //Right, align left
-        channel->left = lpRect.left+CHANNEL_THUMB_SPACE;
+        channel->left = lpRect.left+thumbDiff+CHANNEL_THUMB_SPACE;
         channel->right = channel->left+channelSize;
       }
@@ -201 +201 @@
       channel->left = lpRect.left+CHANNEL_SPACE;
       channel->right = lpRect.right-CHANNEL_SPACE;
-      if (dwStyle & TBS_BOTH)
+      if (dwStyle & TBS_BOTH || dwStyle & TBS_NOTICKS)
       { //center
         channel->top    = (lpRect.bottom-channelSize)/2;
@@ -207 +207 @@
       } else if (dwStyle & TBS_TOP)
       {
-        channel->top    = lpRect.top+CHANNEL_SCALE_SPACE;
+        channel->top    = lpRect.top+thumbDiff+CHANNEL_SCALE_SPACE;
         channel->bottom = channel->top+channelSize;
       } else
       { //Bottom, align top
-        channel->top    = lpRect.top+CHANNEL_THUMB_SPACE;
+        channel->top    = lpRect.top+thumbDiff+CHANNEL_THUMB_SPACE;
         channel->bottom = channel->top+channelSize;
       }
@@ -680 +680 @@
     {
       int ticFlags = dwStyle & 0x0f;
-      COLORREF clrTic = GetSysColor(COLOR_3DDKSHADOW);
+      COLORREF clrTic = RGB(0,0,0);//CB: black instead of GetSysColor(COLOR_3DDKSHADOW);
 
       for (i = 0;i < infoPtr->uNumTics;i++)
@@ -714 +714 @@
    HRGN hrgn,hrgnLast,hrgnNew;
 
-   if (dwStyle & TBS_NOTHUMB) return;
-
    //last
    lastRect = infoPtr->rcFullThumb;
 
    //new
-   if (infoPtr->flags & TB_DRAGPOSVALID) infoPtr->nPos = infoPtr->dragPos;
+   if (infoPtr->flags & TB_DRAGPOSVALID)
+   {
+     infoPtr->nPos = infoPtr->dragPos;
+     infoPtr->flags &= ~TB_DRAGPOSVALID;
+   }
    if (infoPtr->nPos == lastPos) return;
+
+   if (dwStyle & TBS_NOTHUMB) return;
 
    TRACKBAR_CalcThumb(hwnd,infoPtr);
@@ -1131 +1135 @@
     TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
     int newMin,newMax;
+    DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+
     newMin = (INT)LOWORD(lParam);
     newMax = (INT)HIWORD(lParam);
 
+    if (newMin >= newMax) return 0;
     if (newMin == infoPtr->nRangeMin && newMax == infoPtr->nRangeMax) return 0;
 
@@ -1141 +1148 @@
     if (infoPtr->nPos < infoPtr->nRangeMin)
     {
-        infoPtr->nPos = infoPtr->nRangeMin;
-        infoPtr->flags |= TB_THUMBPOSCHANGED;
-    }
-
+      infoPtr->nPos = infoPtr->nRangeMin;
+      infoPtr->flags |= TB_THUMBPOSCHANGED;
+    }
     if (infoPtr->nPos > infoPtr->nRangeMax)
     {
-        infoPtr->nPos = infoPtr->nRangeMax;
-        infoPtr->flags |= TB_THUMBPOSCHANGED;
+      infoPtr->nPos = infoPtr->nRangeMax;
+      infoPtr->flags |= TB_THUMBPOSCHANGED;
+    }
+
+    if (infoPtr->nSelMin < infoPtr->nRangeMin)
+    {
+      infoPtr->nSelMin = infoPtr->nRangeMin;
+      infoPtr->flags |= TB_SELECTIONCHANGED;
+    }
+    if (infoPtr->nSelMin > infoPtr->nRangeMax)
+    {
+      infoPtr->nSelMin = infoPtr->nRangeMax;
+      infoPtr->flags |= TB_SELECTIONCHANGED;
+    }
+    if (infoPtr->nSelMax < infoPtr->nRangeMin)
+    {
+      infoPtr->nSelMax = infoPtr->nRangeMin;
+      infoPtr->flags |= TB_SELECTIONCHANGED;
+    }
+    if (infoPtr->nSelMax > infoPtr->nRangeMax)
+    {
+      infoPtr->nSelMax = infoPtr->nRangeMax;
+      infoPtr->flags |= TB_SELECTIONCHANGED;
     }
 
@@ -1166 +1193 @@
     TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
 
+    if ((INT)lParam <= infoPtr->nRangeMin) return 0;
     if (infoPtr->nRangeMax == (INT)lParam) return 0;
 
@@ -1171 +1199 @@
     if (infoPtr->nPos > infoPtr->nRangeMax)
     {
-        infoPtr->nPos = infoPtr->nRangeMax;
-        infoPtr->flags |=TB_THUMBPOSCHANGED;
+      infoPtr->nPos = infoPtr->nRangeMax;
+      infoPtr->flags |=TB_THUMBPOSCHANGED;
     }
 
@@ -1190 +1218 @@
     TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
 
+    if ((INT)lParam >= infoPtr->nRangeMax) return 0;
     if (infoPtr->nRangeMin == (INT)lParam) return 0;
 
@@ -1195 +1224 @@
     if (infoPtr->nPos < infoPtr->nRangeMin)
     {
-        infoPtr->nPos = infoPtr->nRangeMin;
-        infoPtr->flags |=TB_THUMBPOSCHANGED;
+      infoPtr->nPos = infoPtr->nRangeMin;
+      infoPtr->flags |=TB_THUMBPOSCHANGED;
     }
 
@@ -1216 +1245 @@
     if (infoPtr->uTicFreq == (UINT)wParam) return 0;
 
-    if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBS_AUTOTICKS)) return 0;
+    if (!(GetWindowLongA(hwnd,GWL_STYLE) & TBS_AUTOTICKS)) return 0;
 
     infoPtr->uTicFreq = (UINT)wParam;
@@ -1229 +1258 @@
 
 static LRESULT
-TRACKBAR_SetSel (HWND hwnd, WPARAM wParam, LPARAM lParam)
-{
-    TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
-    INT newMin,newMax;
-
+TRACKBAR_SetSel(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+    TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
+    INT newMin,newMax,oldMin,oldMax;
+
+    oldMin = infoPtr->nSelMin;
+    oldMax = infoPtr->nSelMax;
     newMin = (INT)LOWORD(lParam);
     newMax = (INT)HIWORD(lParam);
@@ -1241 +1272 @@
     infoPtr->nSelMax = newMax;
 
-    infoPtr->flags |=TB_SELECTIONCHANGED;
-
-    if (!GetWindowLongA (hwnd, GWL_STYLE) & TBS_ENABLESELRANGE)
-        return 0;
-
-    if (infoPtr->nSelMin < infoPtr->nRangeMin)
-        infoPtr->nSelMin = infoPtr->nRangeMin;
-    if (infoPtr->nSelMax > infoPtr->nRangeMax)
-        infoPtr->nSelMax = infoPtr->nRangeMax;
-
-    if (wParam) TRACKBAR_Refresh(hwnd);
+    if (infoPtr->nSelMin < infoPtr->nRangeMin) infoPtr->nSelMin = infoPtr->nRangeMin;
+    if (infoPtr->nSelMin > infoPtr->nRangeMax) infoPtr->nSelMin = infoPtr->nRangeMax;
+    if (infoPtr->nSelMax > infoPtr->nRangeMax) infoPtr->nSelMax = infoPtr->nRangeMax;
+    if (infoPtr->nSelMax < infoPtr->nRangeMin) infoPtr->nSelMax = infoPtr->nRangeMin;
+
+    if (infoPtr->nSelMin > infoPtr->nSelMax) infoPtr->nSelMin = infoPtr->nSelMax;
+
+    if (!GetWindowLongA(hwnd, GWL_STYLE) & TBS_ENABLESELRANGE) return 0;
+
+    if (oldMin != newMin || oldMax != newMax)
+    {
+      infoPtr->flags |= TB_SELECTIONCHANGED;
+      if (wParam) TRACKBAR_Refresh(hwnd);
+    }
 
     return 0;
@@ -1261 +1295 @@
 {
     TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
+    INT oldMax;
 
     if (infoPtr->nSelMax == (INT)lParam) return 0;
 
-    if (!GetWindowLongA (hwnd, GWL_STYLE) & TBS_ENABLESELRANGE)
-        return 0;
-
+    oldMax = infoPtr->nSelMax;
     infoPtr->nSelMax = (INT)lParam;
-    infoPtr->flags |= TB_SELECTIONCHANGED;
-
-    if (infoPtr->nSelMax > infoPtr->nRangeMax)
-        infoPtr->nSelMax = infoPtr->nRangeMax;
-
-    if (wParam) TRACKBAR_Refresh(hwnd);
+
+    if (infoPtr->nSelMax > infoPtr->nRangeMax) infoPtr->nSelMax = infoPtr->nRangeMax;
+    if (infoPtr->nSelMax < infoPtr->nRangeMin) infoPtr->nSelMax = infoPtr->nRangeMin;
+
+    if (infoPtr->nSelMin > infoPtr->nSelMax) infoPtr->nSelMin = infoPtr->nSelMax;
+
+    if (!GetWindowLongA(hwnd,GWL_STYLE) & TBS_ENABLESELRANGE) return 0;
+
+    if (oldMax != infoPtr->nSelMax)
+    {
+      infoPtr->flags |= TB_SELECTIONCHANGED;
+      if (wParam) TRACKBAR_Refresh(hwnd);
+    }
 
     return 0;
@@ -1283 +1323 @@
 {
     TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
+    INT oldMin;
 
     if (infoPtr->nSelMin == (INT)lParam) return 0;
 
-    if (!GetWindowLongA (hwnd, GWL_STYLE) & TBS_ENABLESELRANGE)
-        return 0;
-
+    oldMin = infoPtr->nSelMin;
     infoPtr->nSelMin = (INT)lParam;
-    infoPtr->flags |= TB_SELECTIONCHANGED;
-
-    if (infoPtr->nSelMin < infoPtr->nRangeMin)
-        infoPtr->nSelMin = infoPtr->nRangeMin;
-
-    if (wParam) TRACKBAR_Refresh(hwnd);
+
+    if (infoPtr->nSelMin < infoPtr->nRangeMin) infoPtr->nSelMin = infoPtr->nRangeMin;
+    if (infoPtr->nSelMin > infoPtr->nRangeMax) infoPtr->nSelMin = infoPtr->nRangeMax;
+
+    if (infoPtr->nSelMin > infoPtr->nSelMax) infoPtr->nSelMin = infoPtr->nSelMax;
+
+    if (!GetWindowLongA(hwnd,GWL_STYLE) & TBS_ENABLESELRANGE) return 0;
+
+    if (oldMin != infoPtr->nSelMin)
+    {
+      infoPtr->flags |= TB_SELECTIONCHANGED;
+      if (wParam) TRACKBAR_Refresh(hwnd);
+    }
 
     return 0;
@@ -1406 +1452 @@
     INT scaleSize;
 
-    GetWindowRect(hwnd,&clientRect);
+    GetClientRect(hwnd,&clientRect);
     infoPtr->uThumbLen = THUMB_LEN;   /* initial thumb length */
 
@@ -1455 +1501 @@
     infoPtr->uTicFreq   = 1;
     infoPtr->tics       = NULL;
-    infoPtr->clrBk      = GetSysColor (COLOR_3DFACE);
-    infoPtr->hwndNotify = GetParent (hwnd);
+    infoPtr->clrBk      = GetSysColor(COLOR_3DFACE);
+    infoPtr->hwndNotify = GetParent(hwnd);
 
     TRACKBAR_InitializeThumb (hwnd);
 
     /* Create tooltip control */
-    if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_TOOLTIPS) {
-        TTTOOLINFOA ti;
-
-        infoPtr->hwndToolTip =
-            CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
-                             CW_USEDEFAULT, CW_USEDEFAULT,
-                             CW_USEDEFAULT, CW_USEDEFAULT,
-                             hwnd, 0, 0, 0);
-
-        /* Send NM_TOOLTIPSCREATED notification */
-        if (infoPtr->hwndToolTip) {
-            NMTOOLTIPSCREATED nmttc;
-
-            nmttc.hdr.hwndFrom = hwnd;
-            nmttc.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-            nmttc.hdr.code = NM_TOOLTIPSCREATED;
-            nmttc.hwndToolTips = infoPtr->hwndToolTip;
-
-            SendMessageA (GetParent (hwnd), WM_NOTIFY,
-                          (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
-        }
-
-        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
-        ti.cbSize   = sizeof(TTTOOLINFOA);
-        ti.uFlags   = TTF_IDISHWND | TTF_TRACK;
-        ti.hwnd     = hwnd;
-        ti.uId      = 0;
-        ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK */
-        SetRectEmpty (&ti.rect);
-
-        SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA, 0, (LPARAM)&ti);
+    if (GetWindowLongA(hwnd,GWL_STYLE) & TBS_TOOLTIPS)
+    {
+      TTTOOLINFOA ti;
+
+      infoPtr->hwndToolTip =
+          CreateWindowExA (WS_EX_TOOLWINDOW,TOOLTIPS_CLASSA,NULL,WS_POPUP,
+                           CW_USEDEFAULT,CW_USEDEFAULT,
+                           CW_USEDEFAULT,CW_USEDEFAULT,
+                           hwnd,0,0,0);
+
+      /* Send NM_TOOLTIPSCREATED notification */
+      if (infoPtr->hwndToolTip)
+      {
+        NMTOOLTIPSCREATED nmttc;
+
+        nmttc.hdr.hwndFrom = hwnd;
+        nmttc.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
+        nmttc.hdr.code = NM_TOOLTIPSCREATED;
+        nmttc.hwndToolTips = infoPtr->hwndToolTip;
+
+        SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmttc.hdr.idFrom,(LPARAM)&nmttc);
+      }
+
+      ZeroMemory(&ti,sizeof(TTTOOLINFOA));
+      ti.cbSize   = sizeof(TTTOOLINFOA);
+      ti.uFlags   = TTF_TRACK | TTF_CENTERTIP;
+      ti.hwnd     = hwnd;
+      ti.uId      = 0;
+      ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK */
+      SetRectEmpty(&ti.rect);
+
+      SendMessageA(infoPtr->hwndToolTip,TTM_ADDTOOLA,0,(LPARAM)&ti);
     }
 
@@ -1504 +1551 @@
 
     /* delete tooltip control */
-    if (infoPtr->hwndToolTip)
-        DestroyWindow (infoPtr->hwndToolTip);
-
-    COMCTL32_Free (infoPtr);
+    if (infoPtr->hwndToolTip) DestroyWindow(infoPtr->hwndToolTip);
+
+    COMCTL32_Free(infoPtr->tics);
+    COMCTL32_Free(infoPtr);
+
     return 0;
 }
@@ -1549 +1597 @@
            TTTOOLINFOA ti;
            POINT pt;
-
-           GetCursorPos (&pt);
-           SendMessageA (infoPtr->hwndToolTip, TTM_TRACKPOSITION, 0,
-                         (LPARAM)MAKELPARAM(pt.x, pt.y));
+           char buf[80];
+
+           GetCursorPos(&pt);
+           SendMessageA(infoPtr->hwndToolTip,TTM_TRACKPOSITION,0,(LPARAM)MAKELPARAM(pt.x,pt.y));
 
            ti.cbSize   = sizeof(TTTOOLINFOA);
            ti.uId      = 0;
            ti.hwnd     = (UINT)hwnd;
+           ti.hinst = 0;
+           sprintf (buf,"%d",infoPtr->nPos);
+           ti.lpszText = (LPSTR)buf;
 
            infoPtr->flags |= TB_SHOW_TOOLTIP;
-           SetCapture (hwnd);
-           SendMessageA (infoPtr->hwndToolTip, TTM_TRACKACTIVATE,
-                         (WPARAM)TRUE, (LPARAM)&ti);
+           SetCapture(hwnd);
+
+           SendMessageA(infoPtr->hwndToolTip,TTM_UPDATETIPTEXTA,0,(LPARAM)&ti);
+           SendMessageA(infoPtr->hwndToolTip,TTM_TRACKACTIVATE,(WPARAM)TRUE,(LPARAM)&ti);
          }
          SetCapture(hwnd);
@@ -1634 +1686 @@
 
     if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_TOOLTIPS)
-    {  /* disable tooltip */
-        TTTOOLINFOA ti;
-
-        ti.cbSize   = sizeof(TTTOOLINFOA);
-        ti.uId      = 0;
-        ti.hwnd     = (UINT)hwnd;
-
-        infoPtr->flags &= ~TB_SHOW_TOOLTIP;
-        SendMessageA (infoPtr->hwndToolTip, TTM_TRACKACTIVATE,
-                      (WPARAM)FALSE, (LPARAM)&ti);
+    { /* disable tooltip */
+      TTTOOLINFOA ti;
+
+      ti.cbSize   = sizeof(TTTOOLINFOA);
+      ti.uId      = 0;
+      ti.hwnd     = (UINT)hwnd;
+
+      infoPtr->flags &= ~TB_SHOW_TOOLTIP;
+      SendMessageA (infoPtr->hwndToolTip,TTM_TRACKACTIVATE,(WPARAM)FALSE,(LPARAM)&ti);
     }
 
@@ -1792 +1843 @@
 //    TRACE (trackbar, "%x\n",code);
 
-    if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_VERT)
-        return (BOOL) SendMessageA (GetParent (hwnd),
-                                    WM_VSCROLL, (WPARAM)code, (LPARAM)hwnd);
-
-    return (BOOL) SendMessageA (GetParent (hwnd),
-                                WM_HSCROLL, (WPARAM)code, (LPARAM)hwnd);
+    if (GetWindowLongA(hwnd, GWL_STYLE) & TBS_VERT)
+    {
+      return (BOOL)SendMessageA(GetParent(hwnd),WM_VSCROLL,(WPARAM)code,(LPARAM)hwnd);
+    } else
+    {
+      return (BOOL)SendMessageA(GetParent(hwnd),WM_HSCROLL,(WPARAM)code,(LPARAM)hwnd);
+    }
 }
 
@@ -1805 +1857 @@
 {
     TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
-    DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+    DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     SHORT clickPlace;
     DOUBLE dragPos;
-    char buf[80];
-    INT lastDragPos;
 
 //    TRACE (trackbar, "%x\n",wParam);
 
-    if (dwStyle & TBS_VERT) clickPlace=(SHORT)HIWORD(lParam);
-    else clickPlace=(SHORT)LOWORD(lParam);
-
     if (!(infoPtr->flags & TB_DRAG_MODE)) return TRUE;
 
-    lastDragPos = infoPtr->dragPos;
-    dragPos = TRACKBAR_ConvertPlaceToPosition (infoPtr, clickPlace,
-                                               dwStyle & TBS_VERT);
+    if (dwStyle & TBS_VERT) clickPlace = (SHORT)HIWORD(lParam);
+    else clickPlace = (SHORT)LOWORD(lParam);
+
+    dragPos = TRACKBAR_ConvertPlaceToPosition(infoPtr,clickPlace,dwStyle & TBS_VERT);
     if (dragPos > ((INT)dragPos)+0.5) infoPtr->dragPos = dragPos + 1;
     else infoPtr->dragPos = dragPos;
 
-    if (lastDragPos == infoPtr->dragPos) return TRUE; //nothing changed
+    if (infoPtr->nPos == infoPtr->dragPos) return TRUE; //nothing changed
 
     infoPtr->flags |= TB_DRAGPOSVALID;
-    TRACKBAR_SendNotify (hwnd, TB_THUMBTRACK | (infoPtr->nPos>>16));
+
+    TRACKBAR_UpdateThumbPosition(hwnd,infoPtr->nPos); //infoPtr->nPos now set
+
+    TRACKBAR_SendNotify(hwnd,TB_THUMBTRACK | (infoPtr->nPos >> 16));
 
     if (infoPtr->flags & TB_SHOW_TOOLTIP)
     {
-        POINT pt;
-        TTTOOLINFOA ti;
-
-        ti.cbSize = sizeof(TTTOOLINFOA);
-        ti.hwnd = hwnd;
-        ti.uId = 0;
-        ti.hinst=0;
-        sprintf (buf,"%d",infoPtr->nPos);
-        ti.lpszText = (LPSTR) buf;
-        GetCursorPos (&pt);
-
-        if (dwStyle & TBS_VERT) {
-            SendMessageA (infoPtr->hwndToolTip, TTM_TRACKPOSITION,
-                          0, (LPARAM)MAKELPARAM(pt.x+5, pt.y+15));
-        } else {
-            SendMessageA (infoPtr->hwndToolTip, TTM_TRACKPOSITION,
-                          0, (LPARAM)MAKELPARAM(pt.x+15, pt.y+5));
-        }
-        SendMessageA (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTA,
-                      0, (LPARAM)&ti);
-    }
-
-    TRACKBAR_UpdateThumbPosition(hwnd,lastDragPos);
+      POINT pt;
+      TTTOOLINFOA ti;
+      char buf[80];
+
+      ti.cbSize = sizeof(TTTOOLINFOA);
+      ti.hwnd = hwnd;
+      ti.uId = 0;
+      ti.hinst = 0;
+      sprintf (buf,"%d",infoPtr->nPos);
+      ti.lpszText = (LPSTR)buf;
+      GetCursorPos(&pt);
+
+      SendMessageA(infoPtr->hwndToolTip,TTM_UPDATETIPTEXTA,0,(LPARAM)&ti);
+      if (dwStyle & TBS_VERT)
+      {
+        SendMessageA(infoPtr->hwndToolTip,TTM_TRACKPOSITION,0,(LPARAM)MAKELPARAM(pt.x+5,pt.y+15)); //CB: optimize
+      } else
+      {
+        SendMessageA(infoPtr->hwndToolTip,TTM_TRACKPOSITION,0,(LPARAM)MAKELPARAM(pt.x+15,pt.y+5)); //CB: optimize
+      }
+    }
 
     return TRUE;
@@ -1862 +1911 @@
 TRACKBAR_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
+    TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr(hwnd);
     INT pos;
 
 //    TRACE (trackbar, "%x\n",wParam);
 
-    pos=infoPtr->nPos;
+    if (infoPtr->flags & TB_DRAG_MODE) return TRUE;
+
+    pos = infoPtr->nPos;
     switch (wParam) {
     case VK_LEFT:
@@ -1924 +1975 @@
 TRACKBAR_KeyUp (HWND hwnd, WPARAM wParam)
 {
+    TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr(hwnd);
+
+    if (infoPtr->flags & TB_DRAG_MODE) return TRUE;
+
     switch (wParam) {
     case VK_LEFT:

trunk/src/comctl32/updown.c

@@ -1 @@
-/* $Id: updown.c,v 1.4 1999-06-16 20:25:45 cbratschi Exp $ */
+/* $Id: updown.c,v 1.5 1999-06-24 16:37:46 cbratschi Exp $ */
 /*
  * Updown control
@@ -8 +8 @@
  *
  * TODO:
- *   - subclass the buddy window (in UPDOWN_SetBuddy) to process the
+ *   - subclass the buddy window (in UPDOWN_SetBuddyHandle) to process the
  *     arrow keys
  *   - I am not sure about the default values for the Min, Max, Pos
@@ -33 +33 @@
  */
 
+/* CB: Odin32 problems
+  - Open32 doesn't look for CS_DBLCLKS -> double clicks always sent
+*/
+
 #include <stdlib.h>
 #include <stdio.h>
@@ -71 +75 @@
 #define UNKNOWN_PARAM(msg, wParam, lParam)
 
-#define UPDOWN_GetInfoPtr(hwnd) ((UPDOWN_INFO *)GetWindowLongA (hwnd,0))
+#define UPDOWN_GetInfoPtr(hwnd) ((UPDOWN_INFO *)GetWindowLongA(hwnd,0))
 
 
@@ -128 +132 @@
   GetClientRect (hwnd, rect);
 
-  if (GetWindowLongA (hwnd, GWL_STYLE) & UDS_HORZ) {
-    len = rect->right - rect->left; /* compute the width */
-    if (incr)
-      rect->left = len/2+1;
-    else
-      rect->right = len/2;
-  }
-  else {
-    len = rect->bottom - rect->top; /* compute the height */
-    if (incr)
-      rect->bottom = len/2;
-    else
-      rect->top = len/2+1;
+  if (GetWindowLongA(hwnd, GWL_STYLE) & UDS_HORZ)
+  {
+    len = rect->right-rect->left; /* compute the width */
+    if (incr) rect->left = len/2+1;
+    else rect->right = len/2;
+  } else
+  {
+    len = rect->bottom-rect->top; /* compute the height */
+    if (incr) rect->bottom = len/2;
+    else rect->top = len/2+1;
   }
 }
@@ -191 +192 @@
   int newVal;
 
-  if (!IsWindow(infoPtr->Buddy))
-    return FALSE;
+  if (!IsWindow(infoPtr->Buddy)) return FALSE;
 
   /*if the buddy is a list window, we must set curr index */
-  if (!lstrcmpA (infoPtr->szBuddyClass, "ListBox")){
-    newVal = SendMessageA(infoPtr->Buddy, LB_GETCARETINDEX, 0, 0);
-    if(newVal < 0)
-      return FALSE;
-  }
-  else{
+  if (!lstrcmpA(infoPtr->szBuddyClass,"ListBox"))
+  {
+    newVal = SendMessageA(infoPtr->Buddy,LB_GETCARETINDEX,0,0);
+    if(newVal < 0) return FALSE;
+  } else
+  {
     /* we have a regular window, so will get the text */
-    if (!GetWindowTextA(infoPtr->Buddy, txt, sizeof(txt)))
-      return FALSE;
+    if (!GetWindowTextA(infoPtr->Buddy,txt,sizeof(txt))) return FALSE;
 
     sep = UPDOWN_GetThousandSep();
 
     /* now get rid of the separators */
-    for(src = dst = txt; *src; src++)
-      if(*src != sep)
+    for(src = dst = txt;*src;src++)
+      if (*src != sep)
         *dst++ = *src;
     *dst = 0;
 
     /* try to convert the number and validate it */
-    newVal = strtol(txt, &src, infoPtr->Base);
-    if(*src || !UPDOWN_InBounds (hwnd, newVal))
-      return FALSE;
+    newVal = strtol(txt,&src,infoPtr->Base);
+    if (*src || !UPDOWN_InBounds(hwnd,newVal)) return FALSE;
 
 //    TRACE(updown, "new value(%d) read from buddy (old=%d)\n",
@@ -223 +221 @@
 
   infoPtr->CurVal = newVal;
+
   return TRUE;
 }
@@ -236 +235 @@
 static BOOL UPDOWN_SetBuddyInt (HWND hwnd)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-  char txt1[20], sep;
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  char txt1[20],sep;
   int len;
 
-  if (!IsWindow(infoPtr->Buddy))
-    return FALSE;
+  if (!IsWindow(infoPtr->Buddy)) return FALSE;
 
 //  TRACE(updown, "set new value(%d) to buddy.\n",
@@ -247 +245 @@
 
   /*if the buddy is a list window, we must set curr index */
-  if(!lstrcmpA (infoPtr->szBuddyClass, "ListBox")){
-    SendMessageA(infoPtr->Buddy, LB_SETCURSEL, infoPtr->CurVal, 0);
-  }
-  else{ /* Regular window, so set caption to the number */
-    len = sprintf(txt1, (infoPtr->Base==16) ? "%X" : "%d", infoPtr->CurVal);
+  if(!lstrcmpA(infoPtr->szBuddyClass, "ListBox"))
+  {
+    SendMessageA(infoPtr->Buddy,LB_SETCURSEL,infoPtr->CurVal,0);
+  } else
+  { /* Regular window, so set caption to the number */
+    len = sprintf(txt1,(infoPtr->Base == 16) ? "%X" : "%d",infoPtr->CurVal);
 
     sep = UPDOWN_GetThousandSep();
@@ -282 +281 @@
  * Draw the arrows. The background need not be erased.
  */
-static void UPDOWN_Draw (HWND hwnd, HDC hdc)
-{
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+static void UPDOWN_Draw(HWND hwnd,HDC hdc)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
   BOOL prssed;
   RECT rect;
@@ -298 +297 @@
 
   /* Draw the space between the buttons */
-  rect.top = rect.bottom; rect.bottom++;
+  rect.top = rect.bottom;
+  rect.bottom++;
   DrawEdge(hdc, &rect, 0, BF_MIDDLE);
 
@@ -343 +343 @@
 
 /***********************************************************************
- *           UPDOWN_SetBuddy
+ *           UPDOWN_SetBuddyHandle
  * Tests if 'hwndBud' is a valid window handle. If not, returns FALSE.
  * Else, sets it as a new Buddy.
@@ -352 +352 @@
  * the size/pos of the buddy and the control are adjusted accordingly.
  */
-static BOOL UPDOWN_SetBuddy (HWND hwnd, HWND hwndBud)
+static BOOL UPDOWN_SetBuddyHandle (HWND hwnd, HWND hwndBud)
 {
   UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
@@ -420 +420 @@
 static void UPDOWN_DoAction (HWND hwnd, int delta, BOOL incr)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
   int old_val = infoPtr->CurVal;
   NM_UPDOWN ni;
@@ -429 +429 @@
   /* check if we can do the modification first */
   delta *= (incr ? 1 : -1) * (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1);
-  if(!UPDOWN_OffsetVal (hwnd, delta))
-    return;
+  if(!UPDOWN_OffsetVal(hwnd,delta)) return;
 
   /* so, if we can do the change, recompute delta and restore old value */
-  delta = infoPtr->CurVal - old_val;
+  delta = infoPtr->CurVal-old_val;
   infoPtr->CurVal = old_val;
 
@@ -440 +439 @@
   ni.iDelta = delta;
   ni.hdr.hwndFrom = hwnd;
-  ni.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+  ni.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
   ni.hdr.code = UDN_DELTAPOS;
-  if (SendMessageA(GetParent (hwnd), WM_NOTIFY,
-                   (WPARAM)ni.hdr.idFrom, (LPARAM)&ni))
+  if (SendMessageA(GetParent(hwnd),WM_NOTIFY,
+                   (WPARAM)ni.hdr.idFrom,(LPARAM)&ni))
     return; /* we are not allowed to change */
 
   /* Now adjust value with (maybe new) delta */
-  if (!UPDOWN_OffsetVal (hwnd, ni.iDelta))
-    return;
+  if (!UPDOWN_OffsetVal (hwnd,ni.iDelta)) return;
 
   /* Now take care about our buddy */
@@ -455 +453 @@
 
 
-  if (dwStyle & UDS_SETBUDDYINT)
-    UPDOWN_SetBuddyInt (hwnd);
+  if (dwStyle & UDS_SETBUDDYINT) UPDOWN_SetBuddyInt(hwnd);
 
   /* Also, notify it */
@@ -529 +526 @@
     case WM_LBUTTONDOWN:  /* Initialise mouse tracking */
       /* If we are already in the 'clicked' mode, then nothing to do */
-      if(infoPtr->Flags & FLAG_CLICKED)
-        return;
+      if (infoPtr->Flags & FLAG_CLICKED) return;
 
       /* If the buddy is an edit, will set focus to it */
-      if (!lstrcmpA (infoPtr->szBuddyClass, "Edit"))
-        SetFocus(infoPtr->Buddy);
+      if (!lstrcmpA(infoPtr->szBuddyClass,"Edit")) SetFocus(infoPtr->Buddy);
 
       /* Now see which one is the 'active' arrow */
-      temp = UPDOWN_GetArrowFromPoint (hwnd, &rect, pt);
+      temp = UPDOWN_GetArrowFromPoint(hwnd,&rect,pt);
 
       /* Update the CurVal if necessary */
-      if (dwStyle & UDS_SETBUDDYINT)
-        UPDOWN_GetBuddyInt (hwnd);
+      if (dwStyle & UDS_SETBUDDYINT) UPDOWN_GetBuddyInt(hwnd);
 
       /* Before we proceed, see if we can spin... */
-      if(!(dwStyle & UDS_WRAP))
-        if(( temp && infoPtr->CurVal==infoPtr->MaxVal) ||
-           (!temp && infoPtr->CurVal==infoPtr->MinVal))
+      if (!(dwStyle & UDS_WRAP))
+        if ((temp && infoPtr->CurVal == infoPtr->MaxVal) ||
+           (!temp && infoPtr->CurVal == infoPtr->MinVal))
           return;
 
@@ -558 +552 @@
 
       /* process the click */
-      UPDOWN_DoAction (hwnd, 1, infoPtr->Flags & FLAG_INCR);
+      UPDOWN_DoAction (hwnd,1,infoPtr->Flags & FLAG_INCR);
 
       /* now capture all mouse messages */
@@ -564 +558 @@
 
       /* and startup the first timer */
-      SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0);
+      SetTimer(hwnd,TIMERID1,INITIAL_DELAY,0);
       break;
 
     case WM_MOUSEMOVE:
       /* If we are not in the 'clicked' mode, then nothing to do */
-      if(!(infoPtr->Flags & FLAG_CLICKED))
-        return;
+      if (!(infoPtr->Flags & FLAG_CLICKED)) return;
 
       /* save the flags to see if any got modified */
@@ -601 +594 @@
 }
 
+//Message handling
+
+static LRESULT UPDOWN_NCCreate(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+
+  /* get rid of border, if any */
+  SetWindowLongA(hwnd,GWL_STYLE,dwStyle & ~WS_BORDER);
+  return TRUE;
+}
+
+static LRESULT UPDOWN_Create(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr;
+  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+
+  infoPtr = (UPDOWN_INFO*)COMCTL32_Alloc(sizeof(UPDOWN_INFO));
+  SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
+
+  /* initialize the info struct */
+  infoPtr->AccelCount = 0;
+  infoPtr->AccelVect = 0;
+  infoPtr->CurVal = 0;
+  infoPtr->MinVal = 0;
+  infoPtr->MaxVal = 100; /*FIXME*/
+  infoPtr->Base  = 10; /* Default to base 10  */
+  infoPtr->Buddy = 0;  /* No buddy window yet */
+  infoPtr->Flags = 0;  /* And no flags        */
+
+  /* Do we pick the buddy win ourselves? */
+  if (dwStyle & UDS_AUTOBUDDY) UPDOWN_SetBuddyHandle(hwnd,GetWindow(hwnd,GW_HWNDPREV));
+
+//      TRACE(updown, "UpDown Ctrl creation, hwnd=%04x\n", hwnd);
+
+  return 0;
+}
+
+static LRESULT UPDOWN_Destroy(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if(infoPtr->AccelVect) COMCTL32_Free(infoPtr->AccelVect);
+
+  COMCTL32_Free (infoPtr);
+
+//      TRACE(updown, "UpDown Ctrl destruction, hwnd=%04x\n", hwnd);
+
+  return 0;
+}
+
+static LRESULT UPDOWN_Enable(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+
+  if (dwStyle & WS_DISABLED) UPDOWN_CancelMode(hwnd);
+  UPDOWN_Paint(hwnd);
+
+  return 0;
+}
+
+static LRESULT UPDOWN_Timer(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  int temp;
+
+  /* if initial timer, kill it and start the repeat timer */
+  if(wParam == TIMERID1)
+  {
+    KillTimer(hwnd, TIMERID1);
+    /* if no accel info given, used default timer */
+    if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0)
+    {
+      accelIndex = -1;
+      temp = REPEAT_DELAY;
+    } else
+    {
+      accelIndex = 0; /* otherwise, use it */
+      temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
+    }
+    SetTimer(hwnd, TIMERID2, temp, 0);
+   }
+
+   /* now, if the mouse is above us, do the thing...*/
+   if(infoPtr->Flags & FLAG_MOUSEIN)
+   {
+     temp = accelIndex==-1 ? 1 : infoPtr->AccelVect[accelIndex].nInc;
+     UPDOWN_DoAction(hwnd, temp, infoPtr->Flags & FLAG_INCR);
+
+     if(accelIndex!=-1 && accelIndex < infoPtr->AccelCount-1)
+     {
+       KillTimer(hwnd, TIMERID2);
+       accelIndex++; /* move to the next accel info */
+       temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
+       /* make sure we have at least 1ms intervals */
+       SetTimer(hwnd, TIMERID2, temp, 0);
+     }
+   }
+
+   return 0;
+}
+
+static LRESULT UPDOWN_LButtonUp(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if (!UPDOWN_CancelMode(hwnd)) return 0;
+   /*If we released the mouse and our buddy is an edit */
+   /* we must select all text in it.                   */
+   if (!lstrcmpA(infoPtr->szBuddyClass,"Edit"))
+       SendMessageA(infoPtr->Buddy,EM_SETSEL,0,MAKELONG(0,-1));
+
+   return 0;
+}
+
+static LRESULT UPDOWN_KeyDown(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+
+  if((dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(hwnd))
+  {
+    switch(wParam)
+    {
+      case VK_UP:
+      case VK_DOWN:
+        UPDOWN_GetBuddyInt (hwnd);
+        UPDOWN_DoAction (hwnd, 1, wParam==VK_UP);
+        break;
+    }
+  }
+
+  return 0;
+}
+
+static LRESULT UPDOWN_GetAccel(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  INT temp;
+
+  if (wParam == 0 && lParam == 0)    /*if both zero, */
+     return infoPtr->AccelCount;  /*just return the accel count*/
+  if (wParam || lParam)
+  {
+    UNKNOWN_PARAM(UDM_GETACCEL,wParam,lParam);
+    return 0;
+  }
+  temp = MIN(infoPtr->AccelCount,wParam);
+  memcpy((void *)lParam,infoPtr->AccelVect,temp*sizeof(UDACCEL));
+
+  return temp;
+}
+
+static LRESULT UPDOWN_SetAccel(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  //      TRACE(updown, "UpDown Ctrl new accel info, hwnd=%04x\n", hwnd);
+  if(infoPtr->AccelVect)
+  {
+    COMCTL32_Free(infoPtr->AccelVect);
+    infoPtr->AccelCount = 0;
+    infoPtr->AccelVect  = 0;
+  }
+  if(wParam == 0) return TRUE;
+  infoPtr->AccelVect = COMCTL32_Alloc(wParam*sizeof(UDACCEL));
+  if(infoPtr->AccelVect == 0) return FALSE;
+  memcpy(infoPtr->AccelVect,(void*)lParam,wParam*sizeof(UDACCEL));
+
+  return TRUE;
+}
+
+static LRESULT UPDOWN_GetBase(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if (wParam || lParam) UNKNOWN_PARAM(UDM_GETBASE,wParam,lParam);
+
+  return infoPtr->Base;
+}
+
+static LRESULT UPDOWN_SetBase(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  INT temp;
+
+  //      TRACE(updown, "UpDown Ctrl new base(%d), hwnd=%04x\n",
+  //                   wParam, hwnd);
+  if (!(wParam==10 || wParam==16) || lParam) UNKNOWN_PARAM(UDM_SETBASE,wParam,lParam);
+  if (wParam==10 || wParam==16)
+  {
+    temp = infoPtr->Base;
+    infoPtr->Base = wParam;
+    return temp;       /* return the prev base */
+  }
+
+  return 0;
+}
+
+static LRESULT UPDOWN_GetBuddy(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if (wParam || lParam) UNKNOWN_PARAM(UDM_GETBUDDY,wParam,lParam);
+
+  return infoPtr->Buddy;
+}
+
+
+static LRESULT UPDOWN_SetBuddy(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  INT temp;
+
+  if (lParam) UNKNOWN_PARAM(UDM_SETBUDDY,wParam,lParam);
+  temp = infoPtr->Buddy;
+  infoPtr->Buddy = wParam;
+  UPDOWN_SetBuddyHandle(hwnd,wParam);
+//      TRACE(updown, "UpDown Ctrl new buddy(%04x), hwnd=%04x\n",
+//                   infoPtr->Buddy, hwnd);
+
+  return temp;
+}
+
+static LRESULT UPDOWN_GetPos(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  INT temp;
+
+  if (wParam || lParam) UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
+  temp = UPDOWN_GetBuddyInt(hwnd);
+
+  return MAKELONG(infoPtr->CurVal,temp ? 0:1);
+}
+
+static LRESULT UPDOWN_SetPos(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
+  INT temp;
+
+  if (wParam || HIWORD(lParam)) UNKNOWN_PARAM(UDM_GETPOS,wParam,lParam);
+  temp = SLOWORD(lParam);
+//      TRACE(updown, "UpDown Ctrl new value(%d), hwnd=%04x\n",
+//                   temp, hwnd);
+  if (!UPDOWN_InBounds(hwnd, temp))
+  {
+    if (temp < infoPtr->MinVal) temp = infoPtr->MinVal;
+    if (temp > infoPtr->MaxVal) temp = infoPtr->MaxVal;
+  }
+  wParam = infoPtr->CurVal; /* save prev value   */
+  infoPtr->CurVal = temp;   /* set the new value */
+  if (dwStyle & UDS_SETBUDDYINT) UPDOWN_SetBuddyInt (hwnd);
+
+  return wParam;            /* return prev value */
+}
+
+static LRESULT UPDOWN_GetRange(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if (wParam || lParam) UNKNOWN_PARAM(UDM_GETRANGE, wParam, lParam);
+
+  return MAKELONG(infoPtr->MaxVal,infoPtr->MinVal);
+}
+
+static LRESULT UPDOWN_SetRange(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if (wParam) UNKNOWN_PARAM(UDM_SETRANGE,wParam,lParam); /* we must have:     */
+  infoPtr->MaxVal = SLOWORD(lParam); /* UD_MINVAL <= Max <= UD_MAXVAL */
+  infoPtr->MinVal = SHIWORD(lParam); /* UD_MINVAL <= Min <= UD_MAXVAL */
+                                     /* |Max-Min| <= UD_MAXVAL        */
+//      TRACE(updown, "UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
+//                   infoPtr->MinVal, infoPtr->MaxVal, hwnd);
+
+  return 0;
+}
+
+static LRESULT UPDOWN_GetRange32(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  if (wParam) *(LPINT)wParam = infoPtr->MinVal;
+  if (lParam) *(LPINT)lParam = infoPtr->MaxVal;
+
+  return 0;
+}
+
+static LRESULT UPDOWN_SetRange32(HWND hwnd,WPARAM wParam,LPARAM lParam)
+{
+  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(hwnd);
+
+  infoPtr->MinVal = (INT)wParam;
+  infoPtr->MaxVal = (INT)lParam;
+  if (infoPtr->MaxVal <= infoPtr->MinVal) infoPtr->MaxVal = infoPtr->MinVal+1;
+//      TRACE(updown, "UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
+//                   infoPtr->MinVal, infoPtr->MaxVal, hwnd);
+
+  return 0;
+}
+
 /***********************************************************************
  *           UpDownWndProc
@@ -607 +901 @@
                                 LPARAM lParam)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
-  int temp;
-
   switch(message)
     {
     case WM_NCCREATE:
-      /* get rid of border, if any */
-      SetWindowLongA (hwnd, GWL_STYLE, dwStyle & ~WS_BORDER);
-      return TRUE;
+      return UPDOWN_NCCreate(hwnd,wParam,lParam);
 
     case WM_CREATE:
-      infoPtr = (UPDOWN_INFO*)COMCTL32_Alloc (sizeof(UPDOWN_INFO));
-      SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
-
-      /* initialize the info struct */
-      infoPtr->AccelCount=0; infoPtr->AccelVect=0;
-      infoPtr->CurVal=0; infoPtr->MinVal=0; infoPtr->MaxVal=100; /*FIXME*/
-      infoPtr->Base  = 10; /* Default to base 10  */
-      infoPtr->Buddy = 0;  /* No buddy window yet */
-      infoPtr->Flags = 0;  /* And no flags        */
-
-      /* Do we pick the buddy win ourselves? */
-      if (dwStyle & UDS_AUTOBUDDY)
-        UPDOWN_SetBuddy (hwnd, GetWindow (hwnd, GW_HWNDPREV));
-
-//      TRACE(updown, "UpDown Ctrl creation, hwnd=%04x\n", hwnd);
+      return UPDOWN_Create(hwnd,wParam,lParam);
+
+    case WM_DESTROY:
+      return UPDOWN_Destroy(hwnd,wParam,lParam);
+
+    case WM_ENABLE:
+      return UPDOWN_Enable(hwnd,wParam,lParam);
+
+    case WM_TIMER:
+      return UPDOWN_Timer(hwnd,wParam,lParam);
+
+    case WM_CANCELMODE:
+      UPDOWN_CancelMode(hwnd);
       break;
 
-    case WM_DESTROY:
-      if(infoPtr->AccelVect)
-        COMCTL32_Free (infoPtr->AccelVect);
-
-      COMCTL32_Free (infoPtr);
-
-//      TRACE(updown, "UpDown Ctrl destruction, hwnd=%04x\n", hwnd);
-      break;
-
-    case WM_ENABLE:
-      if (dwStyle & WS_DISABLED)
-        UPDOWN_CancelMode (hwnd);
-      UPDOWN_Paint (hwnd);
-      break;
-
-    case WM_TIMER:
-      /* if initial timer, kill it and start the repeat timer */
-      if(wParam == TIMERID1){
-        KillTimer(hwnd, TIMERID1);
-        /* if no accel info given, used default timer */
-        if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0){
-          accelIndex = -1;
-          temp = REPEAT_DELAY;
-        }
-        else{
-          accelIndex = 0; /* otherwise, use it */
-          temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
-        }
-        SetTimer(hwnd, TIMERID2, temp, 0);
-      }
-
-      /* now, if the mouse is above us, do the thing...*/
-      if(infoPtr->Flags & FLAG_MOUSEIN){
-        temp = accelIndex==-1 ? 1 : infoPtr->AccelVect[accelIndex].nInc;
-        UPDOWN_DoAction(hwnd, temp, infoPtr->Flags & FLAG_INCR);
-
-        if(accelIndex!=-1 && accelIndex < infoPtr->AccelCount-1){
-          KillTimer(hwnd, TIMERID2);
-          accelIndex++; /* move to the next accel info */
-          temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
-          /* make sure we have at least 1ms intervals */
-          SetTimer(hwnd, TIMERID2, temp, 0);
-        }
+    case WM_LBUTTONUP:
+      return UPDOWN_LButtonUp(hwnd,wParam,lParam);
+
+    case WM_LBUTTONDOWN:
+    case WM_MOUSEMOVE:
+      if(UPDOWN_IsEnabled(hwnd))
+      {
+        POINT pt;
+        CONV_POINT16TO32((POINT16 *)&lParam,&pt);
+        UPDOWN_HandleMouseEvent(hwnd,message,pt);
       }
       break;
 
-    case WM_CANCELMODE:
-      UPDOWN_CancelMode (hwnd);
+    case WM_KEYDOWN:
+      return UPDOWN_KeyDown(hwnd,wParam,lParam);
+
+    case WM_PAINT:
+      UPDOWN_Paint(hwnd);
       break;
 
-    case WM_LBUTTONUP:
-      if(!UPDOWN_CancelMode(hwnd))
-        break;
-      /*If we released the mouse and our buddy is an edit */
-      /* we must select all text in it.                   */
-      if (!lstrcmpA (infoPtr->szBuddyClass, "Edit"))
-          SendMessageA(infoPtr->Buddy, EM_SETSEL, 0, MAKELONG(0, -1));
-      break;
-
-    case WM_LBUTTONDOWN:
-    case WM_MOUSEMOVE:
-      if(UPDOWN_IsEnabled(hwnd)){
-        POINT pt;
-        CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
-        UPDOWN_HandleMouseEvent (hwnd, message, pt );
-      }
-    break;
-
-    case WM_KEYDOWN:
-      if((dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(hwnd)){
-        switch(wParam){
-        case VK_UP:
-        case VK_DOWN:
-          UPDOWN_GetBuddyInt (hwnd);
-          UPDOWN_DoAction (hwnd, 1, wParam==VK_UP);
-          break;
-        }
-      }
-      break;
-
-    case WM_PAINT:
-      UPDOWN_Paint (hwnd);
-      break;
-
     case UDM_GETACCEL:
-      if (wParam==0 && lParam==0)    /*if both zero, */
-        return infoPtr->AccelCount;  /*just return the accel count*/
-      if (wParam || lParam){
-        UNKNOWN_PARAM(UDM_GETACCEL, wParam, lParam);
-        return 0;
-      }
-      temp = MIN(infoPtr->AccelCount, wParam);
-      memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL));
-      return temp;
+      return UPDOWN_GetAccel(hwnd,wParam,lParam);
 
     case UDM_SETACCEL:
-//      TRACE(updown, "UpDown Ctrl new accel info, hwnd=%04x\n", hwnd);
-      if(infoPtr->AccelVect){
-        COMCTL32_Free (infoPtr->AccelVect);
-        infoPtr->AccelCount = 0;
-        infoPtr->AccelVect  = 0;
-      }
-      if(wParam==0)
-        return TRUE;
-      infoPtr->AccelVect = COMCTL32_Alloc (wParam*sizeof(UDACCEL));
-      if(infoPtr->AccelVect==0)
-        return FALSE;
-      memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL));
-      return TRUE;
+      return UPDOWN_SetAccel(hwnd,wParam,lParam);
 
     case UDM_GETBASE:
-      if (wParam || lParam)
-        UNKNOWN_PARAM(UDM_GETBASE, wParam, lParam);
-      return infoPtr->Base;
+      return UPDOWN_GetBase(hwnd,wParam,lParam);
 
     case UDM_SETBASE:
-//      TRACE(updown, "UpDown Ctrl new base(%d), hwnd=%04x\n",
-//                   wParam, hwnd);
-      if ( !(wParam==10 || wParam==16) || lParam)
-        UNKNOWN_PARAM(UDM_SETBASE, wParam, lParam);
-      if (wParam==10 || wParam==16){
-        temp = infoPtr->Base;
-        infoPtr->Base = wParam;
-        return temp;       /* return the prev base */
-      }
-      break;
+      return UPDOWN_SetBase(hwnd,wParam,lParam);
 
     case UDM_GETBUDDY:
-      if (wParam || lParam)
-        UNKNOWN_PARAM(UDM_GETBUDDY, wParam, lParam);
-      return infoPtr->Buddy;
+      return UPDOWN_GetBuddy(hwnd,wParam,lParam);
 
     case UDM_SETBUDDY:
-      if (lParam)
-        UNKNOWN_PARAM(UDM_SETBUDDY, wParam, lParam);
-      temp = infoPtr->Buddy;
-      infoPtr->Buddy = wParam;
-      UPDOWN_SetBuddy (hwnd, wParam);
-//      TRACE(updown, "UpDown Ctrl new buddy(%04x), hwnd=%04x\n",
-//                   infoPtr->Buddy, hwnd);
-      return temp;
+      return UPDOWN_SetBuddy(hwnd,wParam,lParam);
 
     case UDM_GETPOS:
-      if (wParam || lParam)
-        UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
-      temp = UPDOWN_GetBuddyInt (hwnd);
-      return MAKELONG(infoPtr->CurVal, temp ? 0 : 1);
+      return UPDOWN_GetPos(hwnd,wParam,lParam);
 
     case UDM_SETPOS:
-      if (wParam || HIWORD(lParam))
-        UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
-      temp = SLOWORD(lParam);
-//      TRACE(updown, "UpDown Ctrl new value(%d), hwnd=%04x\n",
-//                   temp, hwnd);
-      if(!UPDOWN_InBounds(hwnd, temp)){
-        if(temp < infoPtr->MinVal)
-          temp = infoPtr->MinVal;
-        if(temp > infoPtr->MaxVal)
-          temp = infoPtr->MaxVal;
-      }
-      wParam = infoPtr->CurVal; /* save prev value   */
-      infoPtr->CurVal = temp;   /* set the new value */
-      if(dwStyle & UDS_SETBUDDYINT)
-        UPDOWN_SetBuddyInt (hwnd);
-      return wParam;            /* return prev value */
+      return UPDOWN_SetPos(hwnd,wParam,lParam);
 
     case UDM_GETRANGE:
-      if (wParam || lParam)
-        UNKNOWN_PARAM(UDM_GETRANGE, wParam, lParam);
-      return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal);
+      return UPDOWN_GetRange(hwnd,wParam,lParam);
 
     case UDM_SETRANGE:
-      if (wParam)
-        UNKNOWN_PARAM(UDM_SETRANGE, wParam, lParam); /* we must have:     */
-      infoPtr->MaxVal = SLOWORD(lParam); /* UD_MINVAL <= Max <= UD_MAXVAL */
-      infoPtr->MinVal = SHIWORD(lParam); /* UD_MINVAL <= Min <= UD_MAXVAL */
-                                         /* |Max-Min| <= UD_MAXVAL        */
-//      TRACE(updown, "UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
-//                   infoPtr->MinVal, infoPtr->MaxVal, hwnd);
-      break;
+      return UPDOWN_SetRange(hwnd,wParam,lParam);
 
     case UDM_GETRANGE32:
-      if (wParam)
-        *(LPINT)wParam = infoPtr->MinVal;
-      if (lParam)
-        *(LPINT)lParam = infoPtr->MaxVal;
-      break;
+      return UPDOWN_GetRange32(hwnd,wParam,lParam);
 
     case UDM_SETRANGE32:
-      infoPtr->MinVal = (INT)wParam;
-      infoPtr->MaxVal = (INT)lParam;
-      if (infoPtr->MaxVal <= infoPtr->MinVal)
-        infoPtr->MaxVal = infoPtr->MinVal + 1;
-//      TRACE(updown, "UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
-//                   infoPtr->MinVal, infoPtr->MaxVal, hwnd);
-      break;
+      return UPDOWN_SetRange32(hwnd,wParam,lParam);
 
     default:
@@ -837 +982 @@
 //      ERR (updown, "unknown msg %04x wp=%04x lp=%08lx\n",
 //           message, wParam, lParam);
-      return DefWindowProcA (hwnd, message, wParam, lParam);
+      return DefWindowProcA(hwnd,message,wParam,lParam);
     }