Various cleanups:

dlls/comctl32/updown.c

@@ -39,8 +39,10 @@ DEFAULT_DEBUG_CHANNEL(updown);
 
 typedef struct
 {
+  HWND      Self;         /* Handle to this up-down control */
   UINT      AccelCount;   /* Number of elements in AccelVect */
   UDACCEL*  AccelVect;    /* Vector containing AccelCount elements */
+  INT       AccelIndex;   /* Current accel index, -1 if not accelerating */
   INT       Base;         /* Base to display nr in the buddy window */
   INT       CurVal;       /* Current up-down value */
   INT       MinVal;       /* Minimum up-down value */
@@ -74,8 +76,6 @@ typedef struct
 #define BUDDY_UPDOWN_HWND        "buddyUpDownHWND"
 #define BUDDY_SUPERCLASS_WNDPROC "buddySupperClassWndProc"
 
-static int accelIndex = -1;
-
 #define UNKNOWN_PARAM(msg, wParam, lParam) WARN(\
         "Unknown parameter(s) for message " #msg \
 	"(%04x): wp=%04x lp=%08lx\n", msg, wParam, lParam);
@@ -89,10 +89,8 @@ UPDOWN_Buddy_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  *           UPDOWN_InBounds
  * Tests if a given value 'val' is between the Min&Max limits
  */
-static BOOL UPDOWN_InBounds(HWND hwnd, int val)
+static BOOL UPDOWN_InBounds(UPDOWN_INFO *infoPtr, int val)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-
   if(infoPtr->MaxVal > infoPtr->MinVal)
     return (infoPtr->MinVal <= val) && (val <= infoPtr->MaxVal);
   else
@@ -104,13 +102,11 @@ static BOOL UPDOWN_InBounds(HWND hwnd, int val)
  * Tests if we can change the current value by delta. If so, it changes
  * it and returns TRUE. Else, it leaves it unchanged and returns FALSE.
  */
-static BOOL UPDOWN_OffsetVal(HWND hwnd, int delta)
+static BOOL UPDOWN_OffsetVal(UPDOWN_INFO *infoPtr, int delta)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-
   /* check if we can do the modification first */
-  if(!UPDOWN_InBounds (hwnd, infoPtr->CurVal+delta)){
-    if (GetWindowLongA (hwnd, GWL_STYLE) & UDS_WRAP)
+  if(!UPDOWN_InBounds (infoPtr, infoPtr->CurVal+delta)){
+    if (GetWindowLongW (infoPtr->Self, GWL_STYLE) & UDS_WRAP)
     {
       delta += (delta < 0 ? -1 : 1) *
 	(infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1) *
@@ -131,13 +127,12 @@ static BOOL UPDOWN_OffsetVal(HWND hwnd, int delta)
  * When we have a buddy set and that we are aligned on our buddy, we
  * want to draw a sunken edge to make like we are part of that control.
  */
-static BOOL UPDOWN_HasBuddyBorder(HWND hwnd)
+static BOOL UPDOWN_HasBuddyBorder(UPDOWN_INFO* infoPtr)
 {  
-  UPDOWN_INFO* infoPtr = UPDOWN_GetInfoPtr (hwnd); 
-  DWORD        dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
 
   return  ( ((dwStyle & (UDS_ALIGNLEFT | UDS_ALIGNRIGHT)) != 0) &&
-	    (SendMessageA(hwnd, UDM_GETBUDDY, 0, 0) != 0) &&
+	    (SendMessageW(infoPtr->Self, UDM_GETBUDDY, 0, 0) != 0) &&
 	    (lstrcmpiA(infoPtr->szBuddyClass, "EDIT") == 0 ) );
 }
 
@@ -147,25 +142,23 @@ static BOOL UPDOWN_HasBuddyBorder(HWND hwnd)
  * rect     - will hold the rectangle
  * incr     - TRUE  get the "increment" rect (up or right)
  *            FALSE get the "decrement" rect (down or left)
- *          
  */
-static void UPDOWN_GetArrowRect (HWND hwnd, RECT *rect, BOOL incr)
+static void UPDOWN_GetArrowRect (UPDOWN_INFO* infoPtr, RECT *rect, BOOL incr)
 {
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
   int   len; /* will hold the width or height */
 
-  GetClientRect (hwnd, rect);
+  GetClientRect (infoPtr->Self, rect);
 
   /*
    * Make sure we calculate the rectangle to fit even if we draw the
    * border.
    */
-  if (UPDOWN_HasBuddyBorder(hwnd))       
-  {
+  if (UPDOWN_HasBuddyBorder(infoPtr)) {
     if (dwStyle & UDS_ALIGNLEFT)
-      rect->left+=DEFAULT_BUDDYBORDER;
+      rect->left += DEFAULT_BUDDYBORDER;
     else
-      rect->right-=DEFAULT_BUDDYBORDER;
+      rect->right -= DEFAULT_BUDDYBORDER;
     
     InflateRect(rect, 0, -DEFAULT_BUDDYBORDER);
   }
@@ -181,8 +174,7 @@ static void UPDOWN_GetArrowRect (HWND hwnd, RECT *rect, BOOL incr)
       rect->left = rect->left + len/2; 
     else
       rect->right =  rect->left + len/2;
-  }
-  else {
+  } else {
     len = rect->bottom - rect->top + 1; /* compute the height */
     if (incr)
       rect->bottom =  rect->top + len/2;
@@ -197,14 +189,12 @@ static void UPDOWN_GetArrowRect (HWND hwnd, RECT *rect, BOOL incr)
  * If it returns the up rect, it returns TRUE.
  * If it returns the down rect, it returns FALSE.
  */
-static BOOL
-UPDOWN_GetArrowFromPoint (HWND hwnd, RECT *rect, POINT pt)
+static BOOL UPDOWN_GetArrowFromPoint (UPDOWN_INFO* infoPtr, RECT *rect, POINT pt)
 {
-    UPDOWN_GetArrowRect (hwnd, rect, TRUE);
-  if(PtInRect(rect, pt))
-    return TRUE;
+  UPDOWN_GetArrowRect (infoPtr, rect, TRUE);
+  if(PtInRect(rect, pt)) return TRUE;
 
-    UPDOWN_GetArrowRect (hwnd, rect, FALSE);
+  UPDOWN_GetArrowRect (infoPtr, rect, FALSE);
   return FALSE;
 }
 
@@ -213,12 +203,11 @@ UPDOWN_GetArrowFromPoint (HWND hwnd, RECT *rect, POINT pt)
  *           UPDOWN_GetThousandSep
  * Returns the thousand sep. If an error occurs, it returns ','.
  */
-static char UPDOWN_GetThousandSep()
+static CHAR UPDOWN_GetThousandSep()
 {
-  char sep[2];
+  CHAR sep[2];
 
-  if(GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, 
-		      sep, sizeof(sep)) != 1)
+  if(GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, sep, 2) != 1)
     return ',';
 
   return sep[0];
@@ -232,9 +221,8 @@ static char UPDOWN_GetThousandSep()
  *   TRUE  - if it read the integer from the buddy successfully
  *   FALSE - if an error occured
  */
-static BOOL UPDOWN_GetBuddyInt (HWND hwnd)
+static BOOL UPDOWN_GetBuddyInt (UPDOWN_INFO *infoPtr)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
   char txt[20], sep, *src, *dst;
   int newVal;
 
@@ -256,17 +244,15 @@ static BOOL UPDOWN_GetBuddyInt (HWND hwnd)
 
     /* now get rid of the separators */
     for(src = dst = txt; *src; src++)
-      if(*src != sep)
-	*dst++ = *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)) 
+    if(*src || !UPDOWN_InBounds (infoPtr, newVal)) 
       return FALSE;
 
-    TRACE("new value(%d) read from buddy (old=%d)\n", 
-		 newVal, infoPtr->CurVal);
+    TRACE("new value(%d) from buddy (old=%d)\n", newVal, infoPtr->CurVal);
   }
   
   infoPtr->CurVal = newVal;
@@ -281,17 +267,15 @@ static BOOL UPDOWN_GetBuddyInt (HWND hwnd)
  *   TRUE  - if it set the caption of the  buddy successfully
  *   FALSE - if an error occured
  */
-static BOOL UPDOWN_SetBuddyInt (HWND hwnd)
+static BOOL UPDOWN_SetBuddyInt (UPDOWN_INFO *infoPtr)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
   char txt1[20], sep;
   int len;
 
   if (!IsWindow(infoPtr->Buddy)) 
     return FALSE;
 
-  TRACE("set new value(%d) to buddy.\n",
-	       infoPtr->CurVal);
+  TRACE("set new value(%d) to buddy.\n", infoPtr->CurVal);
 
   /*if the buddy is a list window, we must set curr index */
   if(!lstrcmpA (infoPtr->szBuddyClass, "ListBox")){
@@ -303,16 +287,15 @@ static BOOL UPDOWN_SetBuddyInt (HWND hwnd)
     sep = UPDOWN_GetThousandSep(); 
 
     /* Do thousands seperation if necessary */
-    if (!(GetWindowLongA (hwnd, GWL_STYLE) & UDS_NOTHOUSANDS) && (len > 3)) {
+    if (!(GetWindowLongA (infoPtr->Self, GWL_STYLE) & UDS_NOTHOUSANDS) && (len > 3)) {
       char txt2[20], *src = txt1, *dst = txt2;
-      if(len%3 > 0){
+      if(len % 3 > 0) {
 	lstrcpynA (dst, src, len%3 + 1);      /* need to include the null */ 
 	dst += len%3;
 	src += len%3;
       }
-      for(len=0; *src; len++){
-	if(len%3==0)
-	  *dst++ = sep;
+      for(len=0; *src; len++) {
+	if(len%3==0) *dst++ = sep;
 	*dst++ = *src++;
       }
       *dst = 0;           /* null terminate it */
@@ -330,12 +313,12 @@ static BOOL UPDOWN_SetBuddyInt (HWND hwnd)
  * When we have a buddy set and that we are aligned on our buddy, we
  * want to draw a sunken edge to make like we are part of that control.
  */
-static void UPDOWN_DrawBuddyBorder (HWND hwnd, HDC hdc)
+static void UPDOWN_DrawBuddyBorder (UPDOWN_INFO *infoPtr, HDC hdc)
 {
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD dwStyle = GetWindowLongA (infoPtr->Self, GWL_STYLE);
   RECT  clientRect;
 
-  GetClientRect(hwnd, &clientRect);
+  GetClientRect(infoPtr->Self, &clientRect);
 
   if (dwStyle & UDS_ALIGNLEFT)
     DrawEdge(hdc, &clientRect, EDGE_SUNKEN, BF_BOTTOM | BF_LEFT | BF_TOP);
@@ -348,21 +331,20 @@ static void UPDOWN_DrawBuddyBorder (HWND hwnd, HDC hdc)
  *
  * Draw the arrows. The background need not be erased.
  */
-static void UPDOWN_Draw (HWND hwnd, HDC hdc)
+static void UPDOWN_Draw (UPDOWN_INFO *infoPtr, HDC hdc)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD dwStyle = GetWindowLongA (infoPtr->Self, GWL_STYLE);
   BOOL prssed;
   RECT rect;
 
   /*
    * Draw the common border between ourselves and our buddy.
    */
-  if (UPDOWN_HasBuddyBorder(hwnd))
-    UPDOWN_DrawBuddyBorder(hwnd, hdc);
+  if (UPDOWN_HasBuddyBorder(infoPtr))
+    UPDOWN_DrawBuddyBorder(infoPtr, hdc);
   
   /* Draw the incr button */
-  UPDOWN_GetArrowRect (hwnd, &rect, TRUE);
+  UPDOWN_GetArrowRect (infoPtr, &rect, TRUE);
   prssed = (infoPtr->Flags & FLAG_INCR) && (infoPtr->Flags & FLAG_MOUSEIN);
   DrawFrameControl(hdc, &rect, DFC_SCROLL, 
 	(dwStyle & UDS_HORZ ? DFCS_SCROLLRIGHT : DFCS_SCROLLUP) |
@@ -374,7 +356,7 @@ static void UPDOWN_Draw (HWND hwnd, HDC hdc)
   DrawEdge(hdc, &rect, 0, BF_MIDDLE);
 		    
   /* Draw the decr button */
-  UPDOWN_GetArrowRect(hwnd, &rect, FALSE);
+  UPDOWN_GetArrowRect(infoPtr, &rect, FALSE);
   prssed = (infoPtr->Flags & FLAG_DECR) && (infoPtr->Flags & FLAG_MOUSEIN);
   DrawFrameControl(hdc, &rect, DFC_SCROLL, 
 	(dwStyle & UDS_HORZ ? DFCS_SCROLLLEFT : DFCS_SCROLLDOWN) |
@@ -388,13 +370,11 @@ static void UPDOWN_Draw (HWND hwnd, HDC hdc)
  * Synchronous drawing (must NOT be used in WM_PAINT).
  * Calls UPDOWN_Draw.
  */
-static void UPDOWN_Refresh (HWND hwnd)
+static void UPDOWN_Refresh (UPDOWN_INFO *infoPtr)
 {
-    HDC hdc;
-  
-    hdc = GetDC (hwnd);
-    UPDOWN_Draw (hwnd, hdc);
-    ReleaseDC (hwnd, hdc);
+    HDC hdc = GetDC (infoPtr->Self);
+    UPDOWN_Draw (infoPtr, hdc);
+    ReleaseDC (infoPtr->Self, hdc);
 }
 
 
@@ -404,23 +384,22 @@ static void UPDOWN_Refresh (HWND hwnd)
  * Asynchronous drawing (must ONLY be used in WM_PAINT).
  * Calls UPDOWN_Draw.
  */
-static void UPDOWN_Paint (HWND hwnd, HDC passedDC)
+static void UPDOWN_Paint (UPDOWN_INFO *infoPtr, HDC hdc)
 {
+    if (hdc) {
+      UPDOWN_Draw (infoPtr, hdc);
+    } else {
       PAINTSTRUCT ps;
-    HDC         hdc = passedDC;
-
-    if (passedDC == 0)
-      hdc = BeginPaint (hwnd, &ps);
 
-    UPDOWN_Draw (hwnd, hdc);
-
-    if (passedDC == 0)
-      EndPaint (hwnd, &ps);
+      hdc = BeginPaint (infoPtr->Self, &ps);
+      UPDOWN_Draw (infoPtr, hdc);
+      EndPaint (infoPtr->Self, &ps);
+    }
 }
 
 /***********************************************************************
  *           UPDOWN_SetBuddy
- * Tests if 'hwndBud' is a valid window handle. If not, returns FALSE.
+ * Tests if 'bud' is a valid window handle. If not, returns FALSE.
  * Else, sets it as a new Buddy.
  * Then, it should subclass the buddy 
  * If window has the UDS_ARROWKEYS, it subcalsses the buddy window to
@@ -428,45 +407,43 @@ static void UPDOWN_Paint (HWND hwnd, HDC passedDC)
  * If window has the UDS_ALIGNLEFT or UDS_ALIGNRIGHT style
  * the size/pos of the buddy and the control are adjusted accordingly.
  */
-static BOOL UPDOWN_SetBuddy (HWND hwnd, HWND hwndBud)
+static BOOL UPDOWN_SetBuddy (UPDOWN_INFO* infoPtr, HWND bud)
 {
-  UPDOWN_INFO* infoPtr = UPDOWN_GetInfoPtr (hwnd); 
-  DWORD        dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD        dwStyle = GetWindowLongA (infoPtr->Self, GWL_STYLE);
   RECT         budRect;  /* new coord for the buddy */
   int          x,width;  /* new x position and width for the up-down */
   WNDPROC baseWndProc, currWndProc;
  	  
   /* Is it a valid bud? */
-  if(!IsWindow(hwndBud))
-    return FALSE;
+  if(!IsWindow(bud)) return FALSE;
 
   /* there is already a body assigned */
   if ( infoPtr->Buddy )  
     RemovePropA(infoPtr->Buddy, BUDDY_UPDOWN_HWND);
 
   /* Store buddy window handle */
-  infoPtr->Buddy = hwndBud;   
+  infoPtr->Buddy = bud;   
 
   /* keep upDown ctrl hwnd in a buddy property */            
-  SetPropA( hwndBud, BUDDY_UPDOWN_HWND, hwnd); 
+  SetPropA( bud, BUDDY_UPDOWN_HWND, infoPtr->Self); 
 
   /* Store buddy window clas name */
   memset(infoPtr->szBuddyClass, 0, UPDOWN_BUDDYCLASSNAMELEN);
-  GetClassNameA (hwndBud, infoPtr->szBuddyClass, UPDOWN_BUDDYCLASSNAMELEN-1);
+  GetClassNameA (bud, infoPtr->szBuddyClass, UPDOWN_BUDDYCLASSNAMELEN-1);
 
   if(dwStyle & UDS_ARROWKEYS){
     /* Note that I don't clear the BUDDY_SUPERCLASS_WNDPROC property 
        when we reset the upDown ctrl buddy to another buddy because it is not 
        good to break the window proc chain. */
 
-	currWndProc = (WNDPROC) GetWindowLongA(hwndBud, GWL_WNDPROC);
+	currWndProc = (WNDPROC) GetWindowLongA(bud, GWL_WNDPROC);
 	if (currWndProc != UPDOWN_Buddy_SubclassProc) 
 	{
 		// replace the buddy's WndProc with ours
-		baseWndProc = (WNDPROC)SetWindowLongA(hwndBud, GWL_WNDPROC,
+		baseWndProc = (WNDPROC)SetWindowLongA(bud, GWL_WNDPROC,
 			      (LPARAM)UPDOWN_Buddy_SubclassProc); 
 		// and save the base class' WndProc 
- 		SetPropA(hwndBud, BUDDY_SUPERCLASS_WNDPROC, (HANDLE)baseWndProc);
+ 		SetPropA(bud, BUDDY_SUPERCLASS_WNDPROC, (HANDLE)baseWndProc);
 	}
 	// else
 	// its already been subclassed, don't overwrite BUDDY_SUPERCLASS_WNDPROC
@@ -505,7 +482,7 @@ static BOOL UPDOWN_SetBuddy (HWND hwnd, HWND hwndBud)
    * to look as if it is integrated with the buddy control. 
    * We nudge the control or change it size to overlap.
    */
-  if (UPDOWN_HasBuddyBorder(hwnd))
+  if (UPDOWN_HasBuddyBorder(infoPtr))
   {
     if(dwStyle & UDS_ALIGNLEFT)
       width+=DEFAULT_BUDDYBORDER;
@@ -513,7 +490,7 @@ static BOOL UPDOWN_SetBuddy (HWND hwnd, HWND hwndBud)
       x-=DEFAULT_BUDDYBORDER;
   }
 
-  SetWindowPos (hwnd, infoPtr->Buddy, 
+  SetWindowPos (infoPtr->Self, infoPtr->Buddy, 
 		x, budRect.top-DEFAULT_ADDTOP,
 		width, (budRect.bottom-budRect.top)+DEFAULT_ADDTOP+DEFAULT_ADDBOT,
 		SWP_NOACTIVATE);
@@ -530,10 +507,9 @@ static BOOL UPDOWN_SetBuddy (HWND hwnd, HWND hwndBud)
  * It handles wraping and non-wraping correctly.
  * It is assumed that delta>0
  */
-static void UPDOWN_DoAction (HWND hwnd, int delta, BOOL incr)
+static void UPDOWN_DoAction (UPDOWN_INFO *infoPtr, int delta, BOOL incr)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd); 
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD dwStyle = GetWindowLongA (infoPtr->Self, GWL_STYLE);
   NM_UPDOWN ni;
 
   TRACE("%s by %d\n", incr ? "inc" : "dec", delta);
@@ -544,28 +520,28 @@ static void UPDOWN_DoAction (HWND hwnd, int delta, BOOL incr)
   /* We must notify parent now to obtain permission */
   ni.iPos = infoPtr->CurVal;
   ni.iDelta = delta;
-  ni.hdr.hwndFrom = hwnd;
-  ni.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+  ni.hdr.hwndFrom = infoPtr->Self;
+  ni.hdr.idFrom   = GetWindowLongA (infoPtr->Self, GWL_ID);
   ni.hdr.code = UDN_DELTAPOS; 
-  if (!SendMessageA(GetParent (hwnd), WM_NOTIFY,
+  if (!SendMessageA(GetParent (infoPtr->Self), WM_NOTIFY,
 		   (WPARAM)ni.hdr.idFrom, (LPARAM)&ni))
   {
      /* Parent said: OK to adjust */
 
      /* Now adjust value with (maybe new) delta */
-     if (UPDOWN_OffsetVal (hwnd, ni.iDelta))
+     if (UPDOWN_OffsetVal (infoPtr, ni.iDelta))
      {
         /* Now take care about our buddy */
         if(infoPtr->Buddy && IsWindow(infoPtr->Buddy)
            && (dwStyle & UDS_SETBUDDYINT) )
-           UPDOWN_SetBuddyInt (hwnd);
+           UPDOWN_SetBuddyInt (infoPtr);
      }
   }
   
   /* Also, notify it. This message is sent in any case. */
-  SendMessageA (GetParent (hwnd), 
+  SendMessageA (GetParent (infoPtr->Self), 
 		dwStyle & UDS_HORZ ? WM_HSCROLL : WM_VSCROLL, 
-		 MAKELONG(SB_THUMBPOSITION, infoPtr->CurVal), hwnd);
+		 MAKELONG(SB_THUMBPOSITION, infoPtr->CurVal), infoPtr->Self);
 }
 
 /***********************************************************************
@@ -574,11 +550,9 @@ static void UPDOWN_DoAction (HWND hwnd, int delta, BOOL incr)
  * Returns TRUE if it is enabled as well as its buddy (if any)
  *         FALSE otherwise
  */
-static BOOL UPDOWN_IsEnabled (HWND hwnd)
+static BOOL UPDOWN_IsEnabled (UPDOWN_INFO *infoPtr)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-
-  if(GetWindowLongA (hwnd, GWL_STYLE) & WS_DISABLED)
+  if(GetWindowLongA (infoPtr->Self, GWL_STYLE) & WS_DISABLED)
     return FALSE;
   if(infoPtr->Buddy)
     return IsWindowEnabled(infoPtr->Buddy);
@@ -593,22 +567,20 @@ static BOOL UPDOWN_IsEnabled (HWND hwnd)
  * If the control was not in cancel mode, it returns FALSE. 
  * If the control was in cancel mode, it returns TRUE.
  */
-static BOOL UPDOWN_CancelMode (HWND hwnd)
+static BOOL UPDOWN_CancelMode (UPDOWN_INFO *infoPtr)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
- 
   /* if not in 'capture' mode, do nothing */
   if(!(infoPtr->Flags & FLAG_CLICKED))
     return FALSE;
 
-  KillTimer (hwnd, TIMERID1); /* kill all possible timers */
-  KillTimer (hwnd, TIMERID2);
+  KillTimer (infoPtr->Self, TIMERID1); /* kill all possible timers */
+  KillTimer (infoPtr->Self, TIMERID2);
   
-  if (GetCapture() == hwnd)    /* let the mouse go         */
+  if (GetCapture() == infoPtr->Self)   /* let the mouse go         */
     ReleaseCapture();                  /* if we still have it      */  
   
   infoPtr->Flags = 0;                  /* get rid of any flags     */
-  UPDOWN_Refresh (hwnd);       /* redraw the control just in case */
+  UPDOWN_Refresh (infoPtr);            /* redraw the control just in case */
   
   return TRUE;
 }
@@ -620,10 +592,9 @@ static BOOL UPDOWN_CancelMode (HWND hwnd)
  * 'pt' is the location of the mouse event in client or
  * windows coordinates. 
  */
-static void UPDOWN_HandleMouseEvent (HWND hwnd, UINT msg, POINT pt)
+static void UPDOWN_HandleMouseEvent (UPDOWN_INFO *infoPtr, UINT msg, POINT pt)
 {
-  UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
-  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+  DWORD dwStyle = GetWindowLongA (infoPtr->Self, GWL_STYLE);
   RECT rect;
   int temp;
 
@@ -639,11 +610,11 @@ static void UPDOWN_HandleMouseEvent (HWND hwnd, UINT msg, POINT pt)
 	SetFocus(infoPtr->Buddy);
 
       /* Now see which one is the 'active' arrow */
-      temp = UPDOWN_GetArrowFromPoint (hwnd, &rect, pt);
+      temp = UPDOWN_GetArrowFromPoint (infoPtr, &rect, pt);
 
       /* Update the CurVal if necessary */
       if (dwStyle & UDS_SETBUDDYINT)
-	UPDOWN_GetBuddyInt (hwnd);
+	UPDOWN_GetBuddyInt (infoPtr);
 	
       /* Set up the correct flags */
       infoPtr->Flags  = 0; 
@@ -651,16 +622,16 @@ static void UPDOWN_HandleMouseEvent (HWND hwnd, UINT msg, POINT pt)
       infoPtr->Flags |= FLAG_MOUSEIN;
       
       /* repaint the control */
-      UPDOWN_Refresh (hwnd);
+      UPDOWN_Refresh (infoPtr);
 
       /* process the click */
-      UPDOWN_DoAction (hwnd, 1, infoPtr->Flags & FLAG_INCR);
+      UPDOWN_DoAction (infoPtr, 1, infoPtr->Flags & FLAG_INCR);
 
       /* now capture all mouse messages */
-      SetCapture (hwnd);
+      SetCapture (infoPtr->Self);
 
       /* and startup the first timer */
-      SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0); 
+      SetTimer(infoPtr->Self, TIMERID1, INITIAL_DELAY, 0); 
       break;
 
     case WM_MOUSEMOVE:
@@ -673,21 +644,21 @@ static void UPDOWN_HandleMouseEvent (HWND hwnd, UINT msg, POINT pt)
 
       /* Now get the 'active' arrow rectangle */
       if (infoPtr->Flags & FLAG_INCR)
-	UPDOWN_GetArrowRect (hwnd, &rect, TRUE);
+	UPDOWN_GetArrowRect (infoPtr, &rect, TRUE);
       else
-	UPDOWN_GetArrowRect (hwnd, &rect, FALSE);
+	UPDOWN_GetArrowRect (infoPtr, &rect, FALSE);
 
       /* Update the flags if we are in/out */
       if(PtInRect(&rect, pt))
 	infoPtr->Flags |=  FLAG_MOUSEIN;
       else{
 	infoPtr->Flags &= ~FLAG_MOUSEIN;
-	if(accelIndex != -1) /* if we have accel info */
-	  accelIndex = 0;    /* reset it              */
+	if(infoPtr->AccelIndex != -1) /* if we have accel info */
+	  infoPtr->AccelIndex = 0;    /* reset it              */
       }
       /* If state changed, redraw the control */
       if(temp != infoPtr->Flags)
-	UPDOWN_Refresh (hwnd);
+	UPDOWN_Refresh (infoPtr);
       break;
 
       default:
@@ -719,15 +690,20 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
 
       /* initialize the info struct */
-      infoPtr->AccelCount=0; infoPtr->AccelVect=0; 
-      infoPtr->CurVal=0; infoPtr->MinVal=0; infoPtr->MaxVal=9999;
+      infoPtr->Self = hwnd;
+      infoPtr->AccelCount = 0;
+      infoPtr->AccelVect = 0;
+      infoPtr->AccelIndex = -1;
+      infoPtr->CurVal = 0; 
+      infoPtr->MinVal = 0; 
+      infoPtr->MaxVal = 9999;
       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));
+	UPDOWN_SetBuddy (infoPtr, GetWindow (hwnd, GW_HWNDPREV));
 	
       TRACE("UpDown Ctrl creation, hwnd=%04x\n", hwnd);
       break;
@@ -746,9 +722,9 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
 	
     case WM_ENABLE:
       if (dwStyle & WS_DISABLED)
-	UPDOWN_CancelMode (hwnd);
+	UPDOWN_CancelMode (infoPtr);
 
-      UPDOWN_Refresh (hwnd);
+      UPDOWN_Refresh (infoPtr);
       break;
 
     case WM_TIMER:
@@ -757,25 +733,25 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
 	KillTimer(hwnd, TIMERID1);
 	/* if no accel info given, used default timer */
 	if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0){
-	  accelIndex = -1;
+	  infoPtr->AccelIndex = -1;
 	  temp = REPEAT_DELAY;
 	}
 	else{
-	  accelIndex = 0; /* otherwise, use it */
-	  temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
+	  infoPtr->AccelIndex = 0; /* otherwise, use it */
+	  temp = infoPtr->AccelVect[infoPtr->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);
+	temp = infoPtr->AccelIndex == -1 ? 1 : infoPtr->AccelVect[infoPtr->AccelIndex].nInc;
+	UPDOWN_DoAction(infoPtr, temp, infoPtr->Flags & FLAG_INCR);
 	
-	if(accelIndex!=-1 && accelIndex < infoPtr->AccelCount-1){
+	if(infoPtr->AccelIndex != -1 && infoPtr->AccelIndex < infoPtr->AccelCount-1){
 	  KillTimer(hwnd, TIMERID2);
-	  accelIndex++; /* move to the next accel info */
-	  temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
+	  infoPtr->AccelIndex++; /* move to the next accel info */
+	  temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1;
 	  /* make sure we have at least 1ms intervals */
 	  SetTimer(hwnd, TIMERID2, temp, 0);	    
 	}
@@ -783,11 +759,11 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       break;
 
     case WM_CANCELMODE:
-      UPDOWN_CancelMode (hwnd);
+      UPDOWN_CancelMode (infoPtr);
       break;
 
     case WM_LBUTTONUP:
-      if(!UPDOWN_CancelMode(hwnd))
+      if(!UPDOWN_CancelMode(infoPtr))
 	break;
 
       SendMessageA(GetParent(hwnd), dwStyle & UDS_HORZ ? WM_HSCROLL : WM_VSCROLL,
@@ -801,29 +777,29 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       
     case WM_LBUTTONDOWN:
     case WM_MOUSEMOVE:
-      if(UPDOWN_IsEnabled(hwnd)){
+      if(UPDOWN_IsEnabled(infoPtr)){
 	POINT pt;
         pt.x = SLOWORD(lParam);
         pt.y = SHIWORD(lParam);
-	UPDOWN_HandleMouseEvent (hwnd, message, pt );
+	UPDOWN_HandleMouseEvent (infoPtr, message, pt );
       }
     break;
 
     case WM_KEYDOWN:
-      if((dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(hwnd)){
+      if((dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(infoPtr)){
 	switch(wParam){
 	case VK_UP:  
 	case VK_DOWN:
-	  UPDOWN_GetBuddyInt (hwnd);
+	  UPDOWN_GetBuddyInt (infoPtr);
 	  /* FIXME: Paint the according button pressed for some time, like win95 does*/
-	  UPDOWN_DoAction (hwnd, 1, wParam==VK_UP);
+	  UPDOWN_DoAction (infoPtr, 1, wParam==VK_UP);
 	  break;
 	}
       }
       break;
       
     case WM_PAINT:
-      UPDOWN_Paint (hwnd, (HDC)wParam);
+      UPDOWN_Paint (infoPtr, (HDC)wParam);
       break;
     
     case UDM_GETACCEL:
@@ -858,8 +834,7 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       return infoPtr->Base;
 
     case UDM_SETBASE:
-      TRACE("UpDown Ctrl new base(%d), hwnd=%04x\n", 
-		     wParam, hwnd);
+      TRACE("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){
@@ -878,24 +853,22 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       if (lParam)
 	UNKNOWN_PARAM(UDM_SETBUDDY, wParam, lParam);
       temp = infoPtr->Buddy;
-      UPDOWN_SetBuddy (hwnd, wParam);
-      TRACE("UpDown Ctrl new buddy(%04x), hwnd=%04x\n", 
-		     infoPtr->Buddy, hwnd);
+      UPDOWN_SetBuddy (infoPtr, wParam);
+      TRACE("UpDown Ctrl new buddy(%04x), hwnd=%04x\n", infoPtr->Buddy, hwnd);
       return temp;
 
     case UDM_GETPOS:
       if (wParam || lParam)
 	UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
-      temp = UPDOWN_GetBuddyInt (hwnd);
+      temp = UPDOWN_GetBuddyInt (infoPtr);
       return MAKELONG(infoPtr->CurVal, temp ? 0 : 1);
 
     case UDM_SETPOS:
       if (wParam || HIWORD(lParam))
 	UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
       temp = SLOWORD(lParam);
-      TRACE("UpDown Ctrl new value(%d), hwnd=%04x\n",
-		     temp, hwnd);
-      if(!UPDOWN_InBounds(hwnd, temp)){
+      TRACE("UpDown Ctrl new value(%d), hwnd=%04x\n", temp, hwnd);
+      if(!UPDOWN_InBounds(infoPtr, temp)){
 	if(temp < infoPtr->MinVal)  
 	  temp = infoPtr->MinVal;
 	if(temp > infoPtr->MaxVal)
@@ -904,7 +877,7 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       wParam = infoPtr->CurVal; /* save prev value   */
       infoPtr->CurVal = temp;   /* set the new value */
       if(dwStyle & UDS_SETBUDDYINT)
-	UPDOWN_SetBuddyInt (hwnd);
+	UPDOWN_SetBuddyInt (infoPtr);
       return wParam;            /* return prev value */
       
     case UDM_GETRANGE:
@@ -944,7 +917,7 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       return infoPtr->CurVal;
 
     case UDM_SETPOS32:
-      if(!UPDOWN_InBounds(hwnd, (int)lParam)){
+      if(!UPDOWN_InBounds(infoPtr, (int)lParam)){
 	if((int)lParam < infoPtr->MinVal)
 	  lParam = infoPtr->MinVal;
 	if((int)lParam > infoPtr->MaxVal)
@@ -953,13 +926,12 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
       temp = infoPtr->CurVal; /* save prev value   */
       infoPtr->CurVal = (int)lParam;   /* set the new value */
       if(dwStyle & UDS_SETBUDDYINT)
-	UPDOWN_SetBuddyInt (hwnd);
+	UPDOWN_SetBuddyInt (infoPtr);
       return temp;            /* return prev value */
 
     default: 
       if (message >= WM_USER) 
-      	ERR("unknown msg %04x wp=%04x lp=%08lx\n", 
-	     message, wParam, lParam);
+      	ERR("unknown msg %04x wp=%04x lp=%08lx\n", message, wParam, lParam);
       return DefWindowProcA (hwnd, message, wParam, lParam); 
     } 
 
@@ -998,8 +970,8 @@ UPDOWN_Buddy_SubclassProc (
         }
         else
         {
-	  UPDOWN_GetBuddyInt(upDownHwnd);
-          UPDOWN_DoAction(upDownHwnd, 1, wParam==VK_UP);
+	  UPDOWN_GetBuddyInt(infoPtr);
+          UPDOWN_DoAction(infoPtr, 1, wParam==VK_UP);
         }
 
         break;