4 * Copyright 1997 Dimitrie O. Paun
7 * - subclass the buddy window (in UPDOWN_SetBuddy) to process the
9 * - I am not sure about the default values for the Min, Max, Pos
10 * (in the UPDOWN_INFO the fields: MinVal, MaxVal, CurVal)
11 * - I think I do not handle correctly the WS_BORDER style.
12 * (Should be fixed. <ekohl@abo.rhein-zeitung.de>)
15 * Not much. The following have not been tested at all:
17 * - listbox as buddy window
20 * - UDS_ALIGNLEFT, ~UDS_WRAP
21 * (tested - they work)
22 * - integers with thousand separators.
23 * (fixed bugs. <noel@macadamian.com>)
25 * Even though the above list seems rather large, the control seems to
26 * behave very well so I am confident it does work in most (all) of the
29 * I do not like the arrows yet, I'll work more on them later on.
40 #include "debugtools.h"
42 DEFAULT_DEBUG_CHANNEL(updown)
44 /* Control configuration constants */
46 #define INITIAL_DELAY 500 /* initial timer until auto-increment kicks in */
47 #define REPEAT_DELAY 50 /* delay between auto-increments */
49 #define DEFAULT_WIDTH 14 /* default width of the ctrl */
50 #define DEFAULT_XSEP 0 /* default separation between buddy and crtl */
51 #define DEFAULT_ADDTOP 0 /* amount to extend above the buddy window */
52 #define DEFAULT_ADDBOT 0 /* amount to extend below the buddy window */
57 #define FLAG_INCR 0x01
58 #define FLAG_DECR 0x02
59 #define FLAG_MOUSEIN 0x04
60 #define FLAG_CLICKED (FLAG_INCR | FLAG_DECR)
65 static int accelIndex = -1;
67 #define UNKNOWN_PARAM(msg, wParam, lParam) WARN(\
68 "UpDown Ctrl: Unknown parameter(s) for message " #msg \
69 "(%04x): wp=%04x lp=%08lx\n", msg, wParam, lParam);
71 #define UPDOWN_GetInfoPtr(hwnd) ((UPDOWN_INFO *)GetWindowLongA (hwnd,0))
74 /***********************************************************************
76 * Tests if a given value 'val' is between the Min&Max limits
78 static BOOL UPDOWN_InBounds(HWND hwnd, int val)
80 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
82 if(infoPtr->MaxVal > infoPtr->MinVal)
83 return (infoPtr->MinVal <= val) && (val <= infoPtr->MaxVal);
85 return (infoPtr->MaxVal <= val) && (val <= infoPtr->MinVal);
88 /***********************************************************************
90 * Tests if we can change the current value by delta. If so, it changes
91 * it and returns TRUE. Else, it leaves it unchanged and returns FALSE.
93 static BOOL UPDOWN_OffsetVal(HWND hwnd, int delta)
95 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
97 /* check if we can do the modification first */
98 if(!UPDOWN_InBounds (hwnd, infoPtr->CurVal+delta)){
99 if (GetWindowLongA (hwnd, GWL_STYLE) & UDS_WRAP)
101 delta += (delta < 0 ? -1 : 1) *
102 (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1) *
103 (infoPtr->MinVal - infoPtr->MaxVal) +
104 (delta < 0 ? 1 : -1);
110 infoPtr->CurVal += delta;
114 /***********************************************************************
115 * UPDOWN_GetArrowRect
116 * wndPtr - pointer to the up-down wnd
117 * rect - will hold the rectangle
118 * incr - TRUE get the "increment" rect (up or right)
119 * FALSE get the "decrement" rect (down or left)
122 static void UPDOWN_GetArrowRect (HWND hwnd, RECT *rect, BOOL incr)
124 int len; /* will hold the width or height */
126 GetClientRect (hwnd, rect);
128 if (GetWindowLongA (hwnd, GWL_STYLE) & UDS_HORZ) {
129 len = rect->right - rect->left; /* compute the width */
131 rect->left = len/2+1;
136 len = rect->bottom - rect->top; /* compute the height */
138 rect->bottom = len/2;
144 /***********************************************************************
145 * UPDOWN_GetArrowFromPoint
146 * Returns the rectagle (for the up or down arrow) that contains pt.
147 * If it returns the up rect, it returns TRUE.
148 * If it returns the down rect, it returns FALSE.
151 UPDOWN_GetArrowFromPoint (HWND hwnd, RECT *rect, POINT pt)
153 UPDOWN_GetArrowRect (hwnd, rect, TRUE);
154 if(PtInRect(rect, pt))
157 UPDOWN_GetArrowRect (hwnd, rect, FALSE);
162 /***********************************************************************
163 * UPDOWN_GetThousandSep
164 * Returns the thousand sep. If an error occurs, it returns ','.
166 static char UPDOWN_GetThousandSep()
170 if(GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND,
171 sep, sizeof(sep)) != 1)
177 /***********************************************************************
179 * Tries to read the pos from the buddy window and if it succeeds,
180 * it stores it in the control's CurVal
182 * TRUE - if it read the integer from the buddy successfully
183 * FALSE - if an error occured
185 static BOOL UPDOWN_GetBuddyInt (HWND hwnd)
187 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
188 char txt[20], sep, *src, *dst;
191 if (!IsWindow(infoPtr->Buddy))
194 /*if the buddy is a list window, we must set curr index */
195 if (!lstrcmpA (infoPtr->szBuddyClass, "ListBox")){
196 newVal = SendMessageA(infoPtr->Buddy, LB_GETCARETINDEX, 0, 0);
201 /* we have a regular window, so will get the text */
202 if (!GetWindowTextA(infoPtr->Buddy, txt, sizeof(txt)))
205 sep = UPDOWN_GetThousandSep();
207 /* now get rid of the separators */
208 for(src = dst = txt; *src; src++)
213 /* try to convert the number and validate it */
214 newVal = strtol(txt, &src, infoPtr->Base);
215 if(*src || !UPDOWN_InBounds (hwnd, newVal))
218 TRACE("new value(%d) read from buddy (old=%d)\n",
219 newVal, infoPtr->CurVal);
222 infoPtr->CurVal = newVal;
227 /***********************************************************************
229 * Tries to set the pos to the buddy window based on current pos
231 * TRUE - if it set the caption of the buddy successfully
232 * FALSE - if an error occured
234 static BOOL UPDOWN_SetBuddyInt (HWND hwnd)
236 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
240 if (!IsWindow(infoPtr->Buddy))
243 TRACE("set new value(%d) to buddy.\n",
246 /*if the buddy is a list window, we must set curr index */
247 if(!lstrcmpA (infoPtr->szBuddyClass, "ListBox")){
248 SendMessageA(infoPtr->Buddy, LB_SETCURSEL, infoPtr->CurVal, 0);
250 else{ /* Regular window, so set caption to the number */
251 len = sprintf(txt1, (infoPtr->Base==16) ? "%X" : "%d", infoPtr->CurVal);
253 sep = UPDOWN_GetThousandSep();
255 /* Do thousands seperation if necessary */
256 if (!(GetWindowLongA (hwnd, GWL_STYLE) & UDS_NOTHOUSANDS) && (len > 3)) {
257 char txt2[20], *src = txt1, *dst = txt2;
259 lstrcpynA (dst, src, len%3 + 1); /* need to include the null */
263 for(len=0; *src; len++){
268 *dst = 0; /* null terminate it */
269 strcpy(txt1, txt2); /* move it to the proper place */
271 SetWindowTextA(infoPtr->Buddy, txt1);
277 /***********************************************************************
278 * UPDOWN_Draw [Internal]
280 * Draw the arrows. The background need not be erased.
282 static void UPDOWN_Draw (HWND hwnd, HDC hdc)
284 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
285 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
289 /* Draw the incr button */
290 UPDOWN_GetArrowRect (hwnd, &rect, TRUE);
291 prssed = (infoPtr->Flags & FLAG_INCR) && (infoPtr->Flags & FLAG_MOUSEIN);
292 DrawFrameControl(hdc, &rect, DFC_SCROLL,
293 (dwStyle & UDS_HORZ ? DFCS_SCROLLLEFT : DFCS_SCROLLUP) |
294 (prssed ? DFCS_PUSHED : 0) |
295 (dwStyle&WS_DISABLED ? DFCS_INACTIVE : 0) );
297 /* Draw the space between the buttons */
298 rect.top = rect.bottom; rect.bottom++;
299 DrawEdge(hdc, &rect, 0, BF_MIDDLE);
301 /* Draw the decr button */
302 UPDOWN_GetArrowRect(hwnd, &rect, FALSE);
303 prssed = (infoPtr->Flags & FLAG_DECR) && (infoPtr->Flags & FLAG_MOUSEIN);
304 DrawFrameControl(hdc, &rect, DFC_SCROLL,
305 (dwStyle & UDS_HORZ ? DFCS_SCROLLRIGHT : DFCS_SCROLLDOWN) |
306 (prssed ? DFCS_PUSHED : 0) |
307 (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
310 /***********************************************************************
311 * UPDOWN_Refresh [Internal]
313 * Synchronous drawing (must NOT be used in WM_PAINT).
316 static void UPDOWN_Refresh (HWND hwnd)
321 UPDOWN_Draw (hwnd, hdc);
322 ReleaseDC (hwnd, hdc);
326 /***********************************************************************
327 * UPDOWN_Paint [Internal]
329 * Asynchronous drawing (must ONLY be used in WM_PAINT).
332 static void UPDOWN_Paint (HWND hwnd)
337 hdc = BeginPaint (hwnd, &ps);
338 UPDOWN_Draw (hwnd, hdc);
339 EndPaint (hwnd, &ps);
342 /***********************************************************************
344 * Tests if 'hwndBud' is a valid window handle. If not, returns FALSE.
345 * Else, sets it as a new Buddy.
346 * Then, it should subclass the buddy
347 * If window has the UDS_ARROWKEYS, it subcalsses the buddy window to
348 * process the UP/DOWN arrow keys.
349 * If window has the UDS_ALIGNLEFT or UDS_ALIGNRIGHT style
350 * the size/pos of the buddy and the control are adjusted accordingly.
352 static BOOL UPDOWN_SetBuddy (HWND hwnd, HWND hwndBud)
354 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
355 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
356 RECT budRect; /* new coord for the buddy */
357 int x; /* new x position and width for the up-down */
359 *infoPtr->szBuddyClass = '\0';
361 /* Is is a valid bud? */
362 if(!IsWindow(hwndBud))
365 /* Store buddy window clas name */
366 GetClassNameA (hwndBud, infoPtr->szBuddyClass, 40);
368 if(dwStyle & UDS_ARROWKEYS){
369 FIXME("we need to subclass the buddy to process the arrow keys.\n");
372 /* do we need to do any adjustments? */
373 if(!(dwStyle & (UDS_ALIGNLEFT | UDS_ALIGNRIGHT)))
376 infoPtr->Buddy = hwndBud;
378 /* Get the rect of the buddy relative to its parent */
379 GetWindowRect(infoPtr->Buddy, &budRect);
380 MapWindowPoints(HWND_DESKTOP, GetParent(infoPtr->Buddy),
381 (POINT *)(&budRect.left), 2);
383 /* now do the positioning */
384 if(dwStyle & UDS_ALIGNRIGHT){
385 budRect.right -= DEFAULT_WIDTH+DEFAULT_XSEP;
386 x = budRect.right+DEFAULT_XSEP;
388 else{ /* UDS_ALIGNLEFT */
390 budRect.left += DEFAULT_WIDTH+DEFAULT_XSEP;
393 /* first adjust the buddy to accomodate the up/down */
394 SetWindowPos(infoPtr->Buddy, 0, budRect.left, budRect.top,
395 budRect.right - budRect.left, budRect.bottom - budRect.top,
396 SWP_NOACTIVATE|SWP_NOZORDER);
398 /* now position the up/down */
399 /* Since the UDS_ALIGN* flags were used, */
400 /* we will pick the position and size of the window. */
402 SetWindowPos (hwnd, 0, x, budRect.top-DEFAULT_ADDTOP,DEFAULT_WIDTH,
403 (budRect.bottom-budRect.top)+DEFAULT_ADDTOP+DEFAULT_ADDBOT,
404 SWP_NOACTIVATE|SWP_NOZORDER);
409 /***********************************************************************
412 * This function increments/decrements the CurVal by the
413 * 'delta' amount according to the 'incr' flag
414 * It notifies the parent as required.
415 * It handles wraping and non-wraping correctly.
416 * It is assumed that delta>0
418 static void UPDOWN_DoAction (HWND hwnd, int delta, BOOL incr)
420 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
421 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
422 int old_val = infoPtr->CurVal;
425 TRACE("%s by %d\n", incr ? "inc" : "dec", delta);
427 /* check if we can do the modification first */
428 delta *= (incr ? 1 : -1) * (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1);
429 if(!UPDOWN_OffsetVal (hwnd, delta))
432 /* so, if we can do the change, recompute delta and restore old value */
433 delta = infoPtr->CurVal - old_val;
434 infoPtr->CurVal = old_val;
436 /* We must notify parent now to obtain permission */
437 ni.iPos = infoPtr->CurVal;
439 ni.hdr.hwndFrom = hwnd;
440 ni.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
441 ni.hdr.code = UDN_DELTAPOS;
442 if (SendMessageA(GetParent (hwnd), WM_NOTIFY,
443 (WPARAM)ni.hdr.idFrom, (LPARAM)&ni))
444 return; /* we are not allowed to change */
446 /* Now adjust value with (maybe new) delta */
447 if (!UPDOWN_OffsetVal (hwnd, ni.iDelta))
450 /* Now take care about our buddy */
451 if(!IsWindow(infoPtr->Buddy))
452 return; /* Nothing else to do */
455 if (dwStyle & UDS_SETBUDDYINT)
456 UPDOWN_SetBuddyInt (hwnd);
458 /* Also, notify it */
459 /* FIXME: do we need to send the notification only if
460 we do not have the UDS_SETBUDDYINT style set? */
462 SendMessageA (GetParent (hwnd),
463 dwStyle & UDS_HORZ ? WM_HSCROLL : WM_VSCROLL,
464 MAKELONG(incr ? SB_LINEUP : SB_LINEDOWN, infoPtr->CurVal),
468 /***********************************************************************
471 * Returns TRUE if it is enabled as well as its buddy (if any)
474 static BOOL UPDOWN_IsEnabled (HWND hwnd)
476 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
478 if(GetWindowLongA (hwnd, GWL_STYLE) & WS_DISABLED)
480 return IsWindowEnabled(infoPtr->Buddy);
483 /***********************************************************************
486 * Deletes any timers, releases the mouse and does redraw if necessary.
487 * If the control is not in "capture" mode, it does nothing.
488 * If the control was not in cancel mode, it returns FALSE.
489 * If the control was in cancel mode, it returns TRUE.
491 static BOOL UPDOWN_CancelMode (HWND hwnd)
493 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
495 /* if not in 'capture' mode, do nothing */
496 if(!(infoPtr->Flags & FLAG_CLICKED))
499 KillTimer (hwnd, TIMERID1); /* kill all possible timers */
500 KillTimer (hwnd, TIMERID2);
502 if (GetCapture() == hwnd) /* let the mouse go */
503 ReleaseCapture(); /* if we still have it */
505 infoPtr->Flags = 0; /* get rid of any flags */
506 UPDOWN_Refresh (hwnd); /* redraw the control just in case */
511 /***********************************************************************
512 * UPDOWN_HandleMouseEvent
514 * Handle a mouse event for the updown.
515 * 'pt' is the location of the mouse event in client or
516 * windows coordinates.
518 static void UPDOWN_HandleMouseEvent (HWND hwnd, UINT msg, POINT pt)
520 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
521 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
527 case WM_LBUTTONDOWN: /* Initialise mouse tracking */
528 /* If we are already in the 'clicked' mode, then nothing to do */
529 if(infoPtr->Flags & FLAG_CLICKED)
532 /* If the buddy is an edit, will set focus to it */
533 if (!lstrcmpA (infoPtr->szBuddyClass, "Edit"))
534 SetFocus(infoPtr->Buddy);
536 /* Now see which one is the 'active' arrow */
537 temp = UPDOWN_GetArrowFromPoint (hwnd, &rect, pt);
539 /* Update the CurVal if necessary */
540 if (dwStyle & UDS_SETBUDDYINT)
541 UPDOWN_GetBuddyInt (hwnd);
543 /* Before we proceed, see if we can spin... */
544 if(!(dwStyle & UDS_WRAP))
545 if(( temp && infoPtr->CurVal==infoPtr->MaxVal) ||
546 (!temp && infoPtr->CurVal==infoPtr->MinVal))
549 /* Set up the correct flags */
551 infoPtr->Flags |= temp ? FLAG_INCR : FLAG_DECR;
552 infoPtr->Flags |= FLAG_MOUSEIN;
554 /* repaint the control */
555 UPDOWN_Refresh (hwnd);
557 /* process the click */
558 UPDOWN_DoAction (hwnd, 1, infoPtr->Flags & FLAG_INCR);
560 /* now capture all mouse messages */
563 /* and startup the first timer */
564 SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0);
568 /* If we are not in the 'clicked' mode, then nothing to do */
569 if(!(infoPtr->Flags & FLAG_CLICKED))
572 /* save the flags to see if any got modified */
573 temp = infoPtr->Flags;
575 /* Now get the 'active' arrow rectangle */
576 if (infoPtr->Flags & FLAG_INCR)
577 UPDOWN_GetArrowRect (hwnd, &rect, TRUE);
579 UPDOWN_GetArrowRect (hwnd, &rect, FALSE);
581 /* Update the flags if we are in/out */
582 if(PtInRect(&rect, pt))
583 infoPtr->Flags |= FLAG_MOUSEIN;
585 infoPtr->Flags &= ~FLAG_MOUSEIN;
586 if(accelIndex != -1) /* if we have accel info */
587 accelIndex = 0; /* reset it */
589 /* If state changed, redraw the control */
590 if(temp != infoPtr->Flags)
591 UPDOWN_Refresh (hwnd);
595 ERR("Impossible case!\n");
600 /***********************************************************************
603 LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
606 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
607 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
613 /* get rid of border, if any */
614 SetWindowLongA (hwnd, GWL_STYLE, dwStyle & ~WS_BORDER);
618 infoPtr = (UPDOWN_INFO*)COMCTL32_Alloc (sizeof(UPDOWN_INFO));
619 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
621 /* initialize the info struct */
622 infoPtr->AccelCount=0; infoPtr->AccelVect=0;
623 infoPtr->CurVal=0; infoPtr->MinVal=0; infoPtr->MaxVal=100; /*FIXME*/
624 infoPtr->Base = 10; /* Default to base 10 */
625 infoPtr->Buddy = 0; /* No buddy window yet */
626 infoPtr->Flags = 0; /* And no flags */
628 /* Do we pick the buddy win ourselves? */
629 if (dwStyle & UDS_AUTOBUDDY)
630 UPDOWN_SetBuddy (hwnd, GetWindow (hwnd, GW_HWNDPREV));
632 TRACE("UpDown Ctrl creation, hwnd=%04x\n", hwnd);
636 if(infoPtr->AccelVect)
637 COMCTL32_Free (infoPtr->AccelVect);
639 COMCTL32_Free (infoPtr);
641 TRACE("UpDown Ctrl destruction, hwnd=%04x\n", hwnd);
645 if (dwStyle & WS_DISABLED)
646 UPDOWN_CancelMode (hwnd);
651 /* if initial timer, kill it and start the repeat timer */
652 if(wParam == TIMERID1){
653 KillTimer(hwnd, TIMERID1);
654 /* if no accel info given, used default timer */
655 if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0){
660 accelIndex = 0; /* otherwise, use it */
661 temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
663 SetTimer(hwnd, TIMERID2, temp, 0);
666 /* now, if the mouse is above us, do the thing...*/
667 if(infoPtr->Flags & FLAG_MOUSEIN){
668 temp = accelIndex==-1 ? 1 : infoPtr->AccelVect[accelIndex].nInc;
669 UPDOWN_DoAction(hwnd, temp, infoPtr->Flags & FLAG_INCR);
671 if(accelIndex!=-1 && accelIndex < infoPtr->AccelCount-1){
672 KillTimer(hwnd, TIMERID2);
673 accelIndex++; /* move to the next accel info */
674 temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
675 /* make sure we have at least 1ms intervals */
676 SetTimer(hwnd, TIMERID2, temp, 0);
682 UPDOWN_CancelMode (hwnd);
686 if(!UPDOWN_CancelMode(hwnd))
688 /*If we released the mouse and our buddy is an edit */
689 /* we must select all text in it. */
690 if (!lstrcmpA (infoPtr->szBuddyClass, "Edit"))
691 SendMessageA(infoPtr->Buddy, EM_SETSEL, 0, MAKELONG(0, -1));
696 if(UPDOWN_IsEnabled(hwnd)){
698 CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
699 UPDOWN_HandleMouseEvent (hwnd, message, pt );
704 if((dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(hwnd)){
708 UPDOWN_GetBuddyInt (hwnd);
709 UPDOWN_DoAction (hwnd, 1, wParam==VK_UP);
720 if (wParam==0 && lParam==0) /*if both zero, */
721 return infoPtr->AccelCount; /*just return the accel count*/
722 if (wParam || lParam){
723 UNKNOWN_PARAM(UDM_GETACCEL, wParam, lParam);
726 temp = MIN(infoPtr->AccelCount, wParam);
727 memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL));
731 TRACE("UpDown Ctrl new accel info, hwnd=%04x\n", hwnd);
732 if(infoPtr->AccelVect){
733 COMCTL32_Free (infoPtr->AccelVect);
734 infoPtr->AccelCount = 0;
735 infoPtr->AccelVect = 0;
739 infoPtr->AccelVect = COMCTL32_Alloc (wParam*sizeof(UDACCEL));
740 if(infoPtr->AccelVect==0)
742 memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL));
746 if (wParam || lParam)
747 UNKNOWN_PARAM(UDM_GETBASE, wParam, lParam);
748 return infoPtr->Base;
751 TRACE("UpDown Ctrl new base(%d), hwnd=%04x\n",
753 if ( !(wParam==10 || wParam==16) || lParam)
754 UNKNOWN_PARAM(UDM_SETBASE, wParam, lParam);
755 if (wParam==10 || wParam==16){
756 temp = infoPtr->Base;
757 infoPtr->Base = wParam;
758 return temp; /* return the prev base */
763 if (wParam || lParam)
764 UNKNOWN_PARAM(UDM_GETBUDDY, wParam, lParam);
765 return infoPtr->Buddy;
769 UNKNOWN_PARAM(UDM_SETBUDDY, wParam, lParam);
770 temp = infoPtr->Buddy;
771 infoPtr->Buddy = wParam;
772 UPDOWN_SetBuddy (hwnd, wParam);
773 TRACE("UpDown Ctrl new buddy(%04x), hwnd=%04x\n",
774 infoPtr->Buddy, hwnd);
778 if (wParam || lParam)
779 UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
780 temp = UPDOWN_GetBuddyInt (hwnd);
781 return MAKELONG(infoPtr->CurVal, temp ? 0 : 1);
784 if (wParam || HIWORD(lParam))
785 UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
786 temp = SLOWORD(lParam);
787 TRACE("UpDown Ctrl new value(%d), hwnd=%04x\n",
789 if(!UPDOWN_InBounds(hwnd, temp)){
790 if(temp < infoPtr->MinVal)
791 temp = infoPtr->MinVal;
792 if(temp > infoPtr->MaxVal)
793 temp = infoPtr->MaxVal;
795 wParam = infoPtr->CurVal; /* save prev value */
796 infoPtr->CurVal = temp; /* set the new value */
797 if(dwStyle & UDS_SETBUDDYINT)
798 UPDOWN_SetBuddyInt (hwnd);
799 return wParam; /* return prev value */
802 if (wParam || lParam)
803 UNKNOWN_PARAM(UDM_GETRANGE, wParam, lParam);
804 return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal);
808 UNKNOWN_PARAM(UDM_SETRANGE, wParam, lParam); /* we must have: */
809 infoPtr->MaxVal = SLOWORD(lParam); /* UD_MINVAL <= Max <= UD_MAXVAL */
810 infoPtr->MinVal = SHIWORD(lParam); /* UD_MINVAL <= Min <= UD_MAXVAL */
811 /* |Max-Min| <= UD_MAXVAL */
812 TRACE("UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
813 infoPtr->MinVal, infoPtr->MaxVal, hwnd);
818 *(LPINT)wParam = infoPtr->MinVal;
820 *(LPINT)lParam = infoPtr->MaxVal;
824 infoPtr->MinVal = (INT)wParam;
825 infoPtr->MaxVal = (INT)lParam;
826 if (infoPtr->MaxVal <= infoPtr->MinVal)
827 infoPtr->MaxVal = infoPtr->MinVal + 1;
828 TRACE("UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
829 infoPtr->MinVal, infoPtr->MaxVal, hwnd);
833 if (message >= WM_USER)
834 ERR("unknown msg %04x wp=%04x lp=%08lx\n",
835 message, wParam, lParam);
836 return DefWindowProcA (hwnd, message, wParam, lParam);
843 /***********************************************************************
844 * UPDOWN_Register [Internal]
846 * Registers the updown window class.
850 UPDOWN_Register(void)
854 if( GlobalFindAtomA( UPDOWN_CLASSA ) ) return;
856 ZeroMemory( &wndClass, sizeof( WNDCLASSA ) );
857 wndClass.style = CS_GLOBALCLASS | CS_VREDRAW;
858 wndClass.lpfnWndProc = (WNDPROC)UpDownWindowProc;
859 wndClass.cbClsExtra = 0;
860 wndClass.cbWndExtra = sizeof(UPDOWN_INFO*);
861 wndClass.hCursor = LoadCursorA( 0, IDC_ARROWA );
862 wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
863 wndClass.lpszClassName = UPDOWN_CLASSA;
865 RegisterClassA( &wndClass );
869 /***********************************************************************
870 * UPDOWN_Unregister [Internal]
872 * Unregisters the updown window class.
876 UPDOWN_Unregister (void)
878 if (GlobalFindAtomA (UPDOWN_CLASSA))
879 UnregisterClassA (UPDOWN_CLASSA, (HINSTANCE)NULL);