bb7890326419868cb67d4f3201bf87e8785c87fd
[reactos.git] / reactos / dll / win32 / comctl32 / updown.c
1 /*
2 * Updown control
3 *
4 * Copyright 1997, 2002 Dimitrie O. Paun
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * NOTE
21 *
22 * This code was audited for completeness against the documented features
23 * of Comctl32.dll version 6.0 on Sep. 9, 2002, by Dimitrie O. Paun.
24 *
25 * Unless otherwise noted, we believe this code to be complete, as per
26 * the specification mentioned above.
27 * If you discover missing features, or bugs, please note them below.
28 *
29 */
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <stdarg.h>
34 #include <stdio.h>
35
36 #include "windef.h"
37 #include "winbase.h"
38 #include "wingdi.h"
39 #include "winuser.h"
40 #include "winnls.h"
41 #include "commctrl.h"
42 #include "comctl32.h"
43 #include "uxtheme.h"
44 #include "tmschema.h"
45 #include "wine/unicode.h"
46 #include "wine/debug.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(updown);
49
50 typedef struct
51 {
52 HWND Self; /* Handle to this up-down control */
53 HWND Notify; /* Handle to the parent window */
54 DWORD dwStyle; /* The GWL_STYLE for this window */
55 UINT AccelCount; /* Number of elements in AccelVect */
56 UDACCEL* AccelVect; /* Vector containing AccelCount elements */
57 INT AccelIndex; /* Current accel index, -1 if not accel'ing */
58 INT Base; /* Base to display nr in the buddy window */
59 INT CurVal; /* Current up-down value */
60 INT MinVal; /* Minimum up-down value */
61 INT MaxVal; /* Maximum up-down value */
62 HWND Buddy; /* Handle to the buddy window */
63 INT BuddyType; /* Remembers the buddy type BUDDY_TYPE_* */
64 INT Flags; /* Internal Flags FLAG_* */
65 BOOL UnicodeFormat; /* Marks the use of Unicode internally */
66 } UPDOWN_INFO;
67
68 /* Control configuration constants */
69
70 #define INITIAL_DELAY 500 /* initial timer until auto-inc kicks in */
71 #define AUTOPRESS_DELAY 250 /* time to keep arrow pressed on KEY_DOWN */
72 #define REPEAT_DELAY 50 /* delay between auto-increments */
73
74 #define DEFAULT_WIDTH 14 /* default width of the ctrl */
75 #define DEFAULT_XSEP 0 /* default separation between buddy and ctrl */
76 #define DEFAULT_ADDTOP 0 /* amount to extend above the buddy window */
77 #define DEFAULT_ADDBOT 0 /* amount to extend below the buddy window */
78 #define DEFAULT_BUDDYBORDER 2 /* Width/height of the buddy border */
79 #define DEFAULT_BUDDYSPACER 2 /* Spacer between the buddy and the ctrl */
80 #define DEFAULT_BUDDYBORDER_THEMED 1 /* buddy border when theming is enabled */
81 #define DEFAULT_BUDDYSPACER_THEMED 0 /* buddy spacer when theming is enabled */
82
83 /* Work constants */
84
85 #define FLAG_INCR 0x01
86 #define FLAG_DECR 0x02
87 #define FLAG_MOUSEIN 0x04
88 #define FLAG_PRESSED 0x08
89 #define FLAG_BUDDYINT 0x10 /* UDS_SETBUDDYINT was set on creation */
90 #define FLAG_ARROW (FLAG_INCR | FLAG_DECR)
91
92 #define BUDDY_TYPE_UNKNOWN 0
93 #define BUDDY_TYPE_LISTBOX 1
94 #define BUDDY_TYPE_EDIT 2
95
96 #define TIMER_AUTOREPEAT 1
97 #define TIMER_ACCEL 2
98 #define TIMER_AUTOPRESS 3
99
100 #define UPDOWN_GetInfoPtr(hwnd) ((UPDOWN_INFO *)GetWindowLongPtrW (hwnd,0))
101 #define COUNT_OF(a) (sizeof(a)/sizeof(a[0]))
102
103 static const WCHAR BUDDY_UPDOWN_HWND[] = { 'b', 'u', 'd', 'd', 'y', 'U', 'p', 'D', 'o', 'w', 'n', 'H', 'W', 'N', 'D', 0 };
104 static const WCHAR BUDDY_SUPERCLASS_WNDPROC[] = { 'b', 'u', 'd', 'd', 'y', 'S', 'u', 'p', 'p', 'e', 'r',
105 'C', 'l', 'a', 's', 's', 'W', 'n', 'd', 'P', 'r', 'o', 'c', 0 };
106 static void UPDOWN_DoAction (UPDOWN_INFO *infoPtr, int delta, int action);
107
108 /***********************************************************************
109 * UPDOWN_IsBuddyEdit
110 * Tests if our buddy is an edit control.
111 */
112 static inline BOOL UPDOWN_IsBuddyEdit(const UPDOWN_INFO *infoPtr)
113 {
114 return infoPtr->BuddyType == BUDDY_TYPE_EDIT;
115 }
116
117 /***********************************************************************
118 * UPDOWN_IsBuddyListbox
119 * Tests if our buddy is a listbox control.
120 */
121 static inline BOOL UPDOWN_IsBuddyListbox(const UPDOWN_INFO *infoPtr)
122 {
123 return infoPtr->BuddyType == BUDDY_TYPE_LISTBOX;
124 }
125
126 /***********************************************************************
127 * UPDOWN_InBounds
128 * Tests if a given value 'val' is between the Min&Max limits
129 */
130 static BOOL UPDOWN_InBounds(const UPDOWN_INFO *infoPtr, int val)
131 {
132 if(infoPtr->MaxVal > infoPtr->MinVal)
133 return (infoPtr->MinVal <= val) && (val <= infoPtr->MaxVal);
134 else
135 return (infoPtr->MaxVal <= val) && (val <= infoPtr->MinVal);
136 }
137
138 /***********************************************************************
139 * UPDOWN_OffsetVal
140 * Change the current value by delta.
141 * It returns TRUE is the value was changed successfully, or FALSE
142 * if the value was not changed, as it would go out of bounds.
143 */
144 static BOOL UPDOWN_OffsetVal(UPDOWN_INFO *infoPtr, int delta)
145 {
146 /* check if we can do the modification first */
147 if(!UPDOWN_InBounds (infoPtr, infoPtr->CurVal+delta)) {
148 if (infoPtr->dwStyle & UDS_WRAP) {
149 delta += (delta < 0 ? -1 : 1) *
150 (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1) *
151 (infoPtr->MinVal - infoPtr->MaxVal) +
152 (delta < 0 ? 1 : -1);
153 } else return FALSE;
154 }
155
156 infoPtr->CurVal += delta;
157 return TRUE;
158 }
159
160 /***********************************************************************
161 * UPDOWN_HasBuddyBorder
162 *
163 * When we have a buddy set and that we are aligned on our buddy, we
164 * want to draw a sunken edge to make like we are part of that control.
165 */
166 static BOOL UPDOWN_HasBuddyBorder(const UPDOWN_INFO *infoPtr)
167 {
168 return ( ((infoPtr->dwStyle & (UDS_ALIGNLEFT | UDS_ALIGNRIGHT)) != 0) &&
169 UPDOWN_IsBuddyEdit(infoPtr) );
170 }
171
172 /***********************************************************************
173 * UPDOWN_GetArrowRect
174 * wndPtr - pointer to the up-down wnd
175 * rect - will hold the rectangle
176 * arrow - FLAG_INCR to get the "increment" rect (up or right)
177 * FLAG_DECR to get the "decrement" rect (down or left)
178 * If both flags are present, the envelope is returned.
179 */
180 static void UPDOWN_GetArrowRect (const UPDOWN_INFO* infoPtr, RECT *rect, int arrow)
181 {
182 HTHEME theme = GetWindowTheme (infoPtr->Self);
183 const int border = theme ? DEFAULT_BUDDYBORDER_THEMED : DEFAULT_BUDDYBORDER;
184 const int spacer = theme ? DEFAULT_BUDDYSPACER_THEMED : DEFAULT_BUDDYSPACER;
185 GetClientRect (infoPtr->Self, rect);
186
187 /*
188 * Make sure we calculate the rectangle to fit even if we draw the
189 * border.
190 */
191 if (UPDOWN_HasBuddyBorder(infoPtr)) {
192 if (infoPtr->dwStyle & UDS_ALIGNLEFT)
193 rect->left += border;
194 else
195 rect->right -= border;
196
197 InflateRect(rect, 0, -border);
198 }
199
200 /* now figure out if we need a space away from the buddy */
201 if (IsWindow(infoPtr->Buddy) ) {
202 if (infoPtr->dwStyle & UDS_ALIGNLEFT) rect->right -= spacer;
203 else rect->left += spacer;
204 }
205
206 /*
207 * We're calculating the midpoint to figure-out where the
208 * separation between the buttons will lay. We make sure that we
209 * round the uneven numbers by adding 1.
210 */
211 if (infoPtr->dwStyle & UDS_HORZ) {
212 int len = rect->right - rect->left + 1; /* compute the width */
213 if (arrow & FLAG_INCR)
214 rect->left = rect->left + len/2;
215 if (arrow & FLAG_DECR)
216 rect->right = rect->left + len/2 - (theme ? 0 : 1);
217 } else {
218 int len = rect->bottom - rect->top + 1; /* compute the height */
219 if (arrow & FLAG_INCR)
220 rect->bottom = rect->top + len/2 - (theme ? 0 : 1);
221 if (arrow & FLAG_DECR)
222 rect->top = rect->top + len/2;
223 }
224 }
225
226 /***********************************************************************
227 * UPDOWN_GetArrowFromPoint
228 * Returns the rectagle (for the up or down arrow) that contains pt.
229 * If it returns the up rect, it returns FLAG_INCR.
230 * If it returns the down rect, it returns FLAG_DECR.
231 */
232 static INT UPDOWN_GetArrowFromPoint (const UPDOWN_INFO *infoPtr, RECT *rect, POINT pt)
233 {
234 UPDOWN_GetArrowRect (infoPtr, rect, FLAG_INCR);
235 if(PtInRect(rect, pt)) return FLAG_INCR;
236
237 UPDOWN_GetArrowRect (infoPtr, rect, FLAG_DECR);
238 if(PtInRect(rect, pt)) return FLAG_DECR;
239
240 return 0;
241 }
242
243
244 /***********************************************************************
245 * UPDOWN_GetThousandSep
246 * Returns the thousand sep. If an error occurs, it returns ','.
247 */
248 static WCHAR UPDOWN_GetThousandSep(void)
249 {
250 WCHAR sep[2];
251
252 if(GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, sep, 2) != 1)
253 sep[0] = ',';
254
255 return sep[0];
256 }
257
258 /***********************************************************************
259 * UPDOWN_GetBuddyInt
260 * Tries to read the pos from the buddy window and if it succeeds,
261 * it stores it in the control's CurVal
262 * returns:
263 * TRUE - if it read the integer from the buddy successfully
264 * FALSE - if an error occurred
265 */
266 static BOOL UPDOWN_GetBuddyInt (UPDOWN_INFO *infoPtr)
267 {
268 WCHAR txt[20], sep, *src, *dst;
269 int newVal;
270
271 if (!((infoPtr->Flags & FLAG_BUDDYINT) && IsWindow(infoPtr->Buddy)))
272 return FALSE;
273
274 /*if the buddy is a list window, we must set curr index */
275 if (UPDOWN_IsBuddyListbox(infoPtr)) {
276 newVal = SendMessageW(infoPtr->Buddy, LB_GETCARETINDEX, 0, 0);
277 if(newVal < 0) return FALSE;
278 } else {
279 /* we have a regular window, so will get the text */
280 /* note that a zero-length string is a legitimate value for 'txt',
281 * and ought to result in a successful conversion to '0'. */
282 if (GetWindowTextW(infoPtr->Buddy, txt, COUNT_OF(txt)) < 0)
283 return FALSE;
284
285 sep = UPDOWN_GetThousandSep();
286
287 /* now get rid of the separators */
288 for(src = dst = txt; *src; src++)
289 if(*src != sep) *dst++ = *src;
290 *dst = 0;
291
292 /* try to convert the number and validate it */
293 newVal = strtolW(txt, &src, infoPtr->Base);
294 if(*src || !UPDOWN_InBounds (infoPtr, newVal)) return FALSE;
295 }
296
297 TRACE("new value(%d) from buddy (old=%d)\n", newVal, infoPtr->CurVal);
298 infoPtr->CurVal = newVal;
299 return TRUE;
300 }
301
302
303 /***********************************************************************
304 * UPDOWN_SetBuddyInt
305 * Tries to set the pos to the buddy window based on current pos
306 * returns:
307 * TRUE - if it set the caption of the buddy successfully
308 * FALSE - if an error occurred
309 */
310 static BOOL UPDOWN_SetBuddyInt (const UPDOWN_INFO *infoPtr)
311 {
312 WCHAR fmt[3] = { '%', 'd', '\0' };
313 WCHAR txt[20];
314 int len;
315
316 if (!((infoPtr->Flags & FLAG_BUDDYINT) && IsWindow(infoPtr->Buddy)))
317 return FALSE;
318
319 TRACE("set new value(%d) to buddy.\n", infoPtr->CurVal);
320
321 /*if the buddy is a list window, we must set curr index */
322 if (UPDOWN_IsBuddyListbox(infoPtr)) {
323 return SendMessageW(infoPtr->Buddy, LB_SETCURSEL, infoPtr->CurVal, 0) != LB_ERR;
324 }
325
326 /* Regular window, so set caption to the number */
327 if (infoPtr->Base == 16) fmt[1] = 'X';
328 len = wsprintfW(txt, fmt, infoPtr->CurVal);
329
330
331 /* Do thousands separation if necessary */
332 if ((infoPtr->Base == 10) && !(infoPtr->dwStyle & UDS_NOTHOUSANDS) && (len > 3)) {
333 WCHAR tmp[COUNT_OF(txt)], *src = tmp, *dst = txt;
334 WCHAR sep = UPDOWN_GetThousandSep();
335 int start = len % 3;
336
337 memcpy(tmp, txt, sizeof(txt));
338 if (start == 0) start = 3;
339 dst += start;
340 src += start;
341 for (len=0; *src; len++) {
342 if (len % 3 == 0) *dst++ = sep;
343 *dst++ = *src++;
344 }
345 *dst = 0;
346 }
347
348 return SetWindowTextW(infoPtr->Buddy, txt);
349 }
350
351 /***********************************************************************
352 * UPDOWN_DrawBuddyBackground
353 *
354 * Draw buddy background for visual integration.
355 */
356 static BOOL UPDOWN_DrawBuddyBackground (const UPDOWN_INFO *infoPtr, HDC hdc)
357 {
358 RECT br;
359 HTHEME buddyTheme = GetWindowTheme (infoPtr->Buddy);
360 if (!buddyTheme) return FALSE;
361
362 GetClientRect (infoPtr->Buddy, &br);
363 MapWindowPoints (infoPtr->Buddy, infoPtr->Self, (POINT*)&br, 2);
364 /* FIXME: take disabled etc. into account */
365 DrawThemeBackground (buddyTheme, hdc, 0, 0, &br, NULL);
366 return TRUE;
367 }
368
369 /***********************************************************************
370 * UPDOWN_Draw
371 *
372 * Draw the arrows. The background need not be erased.
373 */
374 static LRESULT UPDOWN_Draw (const UPDOWN_INFO *infoPtr, HDC hdc)
375 {
376 BOOL uPressed, uHot, dPressed, dHot;
377 RECT rect;
378 HTHEME theme = GetWindowTheme (infoPtr->Self);
379 int uPart = 0, uState = 0, dPart = 0, dState = 0;
380 BOOL needBuddyBg = FALSE;
381
382 uPressed = (infoPtr->Flags & FLAG_PRESSED) && (infoPtr->Flags & FLAG_INCR);
383 uHot = (infoPtr->Flags & FLAG_INCR) && (infoPtr->Flags & FLAG_MOUSEIN);
384 dPressed = (infoPtr->Flags & FLAG_PRESSED) && (infoPtr->Flags & FLAG_DECR);
385 dHot = (infoPtr->Flags & FLAG_DECR) && (infoPtr->Flags & FLAG_MOUSEIN);
386 if (theme) {
387 uPart = (infoPtr->dwStyle & UDS_HORZ) ? SPNP_UPHORZ : SPNP_UP;
388 uState = (infoPtr->dwStyle & WS_DISABLED) ? DNS_DISABLED
389 : (uPressed ? DNS_PRESSED : (uHot ? DNS_HOT : DNS_NORMAL));
390 dPart = (infoPtr->dwStyle & UDS_HORZ) ? SPNP_DOWNHORZ : SPNP_DOWN;
391 dState = (infoPtr->dwStyle & WS_DISABLED) ? DNS_DISABLED
392 : (dPressed ? DNS_PRESSED : (dHot ? DNS_HOT : DNS_NORMAL));
393 needBuddyBg = IsWindow (infoPtr->Buddy)
394 && (IsThemeBackgroundPartiallyTransparent (theme, uPart, uState)
395 || IsThemeBackgroundPartiallyTransparent (theme, dPart, dState));
396 }
397
398 /* Draw the common border between ourselves and our buddy */
399 if (UPDOWN_HasBuddyBorder(infoPtr) || needBuddyBg) {
400 if (!theme || !UPDOWN_DrawBuddyBackground (infoPtr, hdc)) {
401 GetClientRect(infoPtr->Self, &rect);
402 DrawEdge(hdc, &rect, EDGE_SUNKEN,
403 BF_BOTTOM | BF_TOP |
404 (infoPtr->dwStyle & UDS_ALIGNLEFT ? BF_LEFT : BF_RIGHT));
405 }
406 }
407
408 /* Draw the incr button */
409 UPDOWN_GetArrowRect (infoPtr, &rect, FLAG_INCR);
410 if (theme) {
411 DrawThemeBackground(theme, hdc, uPart, uState, &rect, NULL);
412 } else {
413 DrawFrameControl(hdc, &rect, DFC_SCROLL,
414 (infoPtr->dwStyle & UDS_HORZ ? DFCS_SCROLLRIGHT : DFCS_SCROLLUP) |
415 ((infoPtr->dwStyle & UDS_HOTTRACK) && uHot ? DFCS_HOT : 0) |
416 (uPressed ? DFCS_PUSHED : 0) |
417 (infoPtr->dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
418 }
419
420 /* Draw the decr button */
421 UPDOWN_GetArrowRect(infoPtr, &rect, FLAG_DECR);
422 if (theme) {
423 DrawThemeBackground(theme, hdc, dPart, dState, &rect, NULL);
424 } else {
425 DrawFrameControl(hdc, &rect, DFC_SCROLL,
426 (infoPtr->dwStyle & UDS_HORZ ? DFCS_SCROLLLEFT : DFCS_SCROLLDOWN) |
427 ((infoPtr->dwStyle & UDS_HOTTRACK) && dHot ? DFCS_HOT : 0) |
428 (dPressed ? DFCS_PUSHED : 0) |
429 (infoPtr->dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
430 }
431
432 return 0;
433 }
434
435 /***********************************************************************
436 * UPDOWN_Paint
437 *
438 * Asynchronous drawing (must ONLY be used in WM_PAINT).
439 * Calls UPDOWN_Draw.
440 */
441 static LRESULT UPDOWN_Paint (const UPDOWN_INFO *infoPtr, HDC hdc)
442 {
443 PAINTSTRUCT ps;
444 if (hdc) return UPDOWN_Draw (infoPtr, hdc);
445 hdc = BeginPaint (infoPtr->Self, &ps);
446 UPDOWN_Draw (infoPtr, hdc);
447 EndPaint (infoPtr->Self, &ps);
448 return 0;
449 }
450
451 /***********************************************************************
452 * UPDOWN_KeyPressed
453 *
454 * Handle key presses (up & down) when we have to do so
455 */
456 static LRESULT UPDOWN_KeyPressed(UPDOWN_INFO *infoPtr, int key)
457 {
458 int arrow;
459
460 if (key == VK_UP) arrow = FLAG_INCR;
461 else if (key == VK_DOWN) arrow = FLAG_DECR;
462 else return 1;
463
464 UPDOWN_GetBuddyInt (infoPtr);
465 infoPtr->Flags &= ~FLAG_ARROW;
466 infoPtr->Flags |= FLAG_PRESSED | arrow;
467 InvalidateRect (infoPtr->Self, NULL, FALSE);
468 SetTimer(infoPtr->Self, TIMER_AUTOPRESS, AUTOPRESS_DELAY, 0);
469 UPDOWN_DoAction (infoPtr, 1, arrow);
470 return 0;
471 }
472
473 /***********************************************************************
474 * UPDOWN_SetRange
475 *
476 * Handle UDM_SETRANGE, UDM_SETRANGE32
477 *
478 * FIXME: handle Max == Min properly:
479 * - arrows should be disabled (without WS_DISABLED set),
480 * visually they can't be pressed and don't respond;
481 * - all input messages should still pass in.
482 */
483 static LRESULT UPDOWN_SetRange(UPDOWN_INFO *infoPtr, INT Max, INT Min)
484 {
485 infoPtr->MaxVal = Max;
486 infoPtr->MinVal = Min;
487
488 TRACE("UpDown Ctrl new range(%d to %d), hwnd=%p\n",
489 infoPtr->MinVal, infoPtr->MaxVal, infoPtr->Self);
490
491 return 0;
492 }
493
494 /***********************************************************************
495 * UPDOWN_MouseWheel
496 *
497 * Handle mouse wheel scrolling
498 */
499 static LRESULT UPDOWN_MouseWheel(UPDOWN_INFO *infoPtr, WPARAM wParam)
500 {
501 int iWheelDelta = GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA;
502
503 if (wParam & (MK_SHIFT | MK_CONTROL))
504 return 0;
505
506 if (iWheelDelta != 0)
507 {
508 UPDOWN_GetBuddyInt(infoPtr);
509 UPDOWN_DoAction(infoPtr, abs(iWheelDelta), iWheelDelta > 0 ? FLAG_INCR : FLAG_DECR);
510 }
511
512 return 1;
513 }
514
515
516 /***********************************************************************
517 * UPDOWN_Buddy_SubclassProc used to handle messages sent to the buddy
518 * control.
519 */
520 static LRESULT CALLBACK
521 UPDOWN_Buddy_SubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
522 {
523 WNDPROC superClassWndProc = (WNDPROC)GetPropW(hwnd, BUDDY_SUPERCLASS_WNDPROC);
524 HWND upDownHwnd = GetPropW(hwnd, BUDDY_UPDOWN_HWND);
525 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(upDownHwnd);
526
527 TRACE("hwnd=%p, wndProc=%p, uMsg=%04x, wParam=%08lx, lParam=%08lx\n",
528 hwnd, superClassWndProc, uMsg, wParam, lParam);
529
530 switch(uMsg)
531 {
532 case WM_KEYDOWN:
533 UPDOWN_KeyPressed(infoPtr, (int)wParam);
534 if ((wParam == VK_UP) || (wParam == VK_DOWN)) return 0;
535 break;
536
537 case WM_MOUSEWHEEL:
538 UPDOWN_MouseWheel(infoPtr, (int)wParam);
539 break;
540
541 default:
542 break;
543 }
544
545 return CallWindowProcW( superClassWndProc, hwnd, uMsg, wParam, lParam);
546 }
547
548 /***********************************************************************
549 * UPDOWN_SetBuddy
550 *
551 * Sets bud as a new Buddy.
552 * Then, it should subclass the buddy
553 * If window has the UDS_ARROWKEYS, it subcalsses the buddy window to
554 * process the UP/DOWN arrow keys.
555 * If window has the UDS_ALIGNLEFT or UDS_ALIGNRIGHT style
556 * the size/pos of the buddy and the control are adjusted accordingly.
557 */
558 static HWND UPDOWN_SetBuddy (UPDOWN_INFO* infoPtr, HWND bud)
559 {
560 static const WCHAR editW[] = { 'E', 'd', 'i', 't', 0 };
561 static const WCHAR listboxW[] = { 'L', 'i', 's', 't', 'b', 'o', 'x', 0 };
562 RECT budRect; /* new coord for the buddy */
563 int x, width; /* new x position and width for the up-down */
564 WNDPROC baseWndProc;
565 WCHAR buddyClass[40];
566 HWND ret;
567
568 TRACE("(hwnd=%p, bud=%p)\n", infoPtr->Self, bud);
569
570 ret = infoPtr->Buddy;
571
572 /* there is already a body assigned */
573 if (infoPtr->Buddy) RemovePropW(infoPtr->Buddy, BUDDY_UPDOWN_HWND);
574
575 if(!IsWindow(bud))
576 bud = 0;
577
578 /* Store buddy window handle */
579 infoPtr->Buddy = bud;
580
581 if(bud) {
582
583 /* keep upDown ctrl hwnd in a buddy property */
584 SetPropW( bud, BUDDY_UPDOWN_HWND, infoPtr->Self);
585
586 /* Store buddy window class type */
587 infoPtr->BuddyType = BUDDY_TYPE_UNKNOWN;
588 if (GetClassNameW(bud, buddyClass, COUNT_OF(buddyClass))) {
589 if (lstrcmpiW(buddyClass, editW) == 0)
590 infoPtr->BuddyType = BUDDY_TYPE_EDIT;
591 else if (lstrcmpiW(buddyClass, listboxW) == 0)
592 infoPtr->BuddyType = BUDDY_TYPE_LISTBOX;
593 }
594
595 if (infoPtr->dwStyle & UDS_ARROWKEYS) {
596 /* Note that I don't clear the BUDDY_SUPERCLASS_WNDPROC property
597 when we reset the upDown ctrl buddy to another buddy because it is not
598 good to break the window proc chain. */
599 if (!GetPropW(bud, BUDDY_SUPERCLASS_WNDPROC)) {
600 baseWndProc = (WNDPROC)SetWindowLongPtrW(bud, GWLP_WNDPROC, (LPARAM)UPDOWN_Buddy_SubclassProc);
601 SetPropW(bud, BUDDY_SUPERCLASS_WNDPROC, baseWndProc);
602 }
603 }
604
605 /* Get the rect of the buddy relative to its parent */
606 GetWindowRect(infoPtr->Buddy, &budRect);
607 MapWindowPoints(HWND_DESKTOP, GetParent(infoPtr->Buddy), (POINT *)(&budRect.left), 2);
608
609 /* now do the positioning */
610 if (infoPtr->dwStyle & UDS_ALIGNLEFT) {
611 x = budRect.left;
612 budRect.left += DEFAULT_WIDTH + DEFAULT_XSEP;
613 } else if (infoPtr->dwStyle & UDS_ALIGNRIGHT) {
614 budRect.right -= DEFAULT_WIDTH + DEFAULT_XSEP;
615 x = budRect.right+DEFAULT_XSEP;
616 } else {
617 /* nothing to do */
618 return ret;
619 }
620
621 /* first adjust the buddy to accommodate the up/down */
622 SetWindowPos(infoPtr->Buddy, 0, budRect.left, budRect.top,
623 budRect.right - budRect.left, budRect.bottom - budRect.top,
624 SWP_NOACTIVATE|SWP_NOZORDER);
625
626 /* now position the up/down */
627 /* Since the UDS_ALIGN* flags were used, */
628 /* we will pick the position and size of the window. */
629 width = DEFAULT_WIDTH;
630
631 /*
632 * If the updown has a buddy border, it has to overlap with the buddy
633 * to look as if it is integrated with the buddy control.
634 * We nudge the control or change its size to overlap.
635 */
636 if (UPDOWN_HasBuddyBorder(infoPtr)) {
637 if(infoPtr->dwStyle & UDS_ALIGNLEFT)
638 width += DEFAULT_BUDDYBORDER;
639 else
640 x -= DEFAULT_BUDDYBORDER;
641 }
642
643 SetWindowPos(infoPtr->Self, 0, x,
644 budRect.top - DEFAULT_ADDTOP, width,
645 budRect.bottom - budRect.top + DEFAULT_ADDTOP + DEFAULT_ADDBOT,
646 SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOZORDER);
647 } else {
648 RECT rect;
649 GetWindowRect(infoPtr->Self, &rect);
650 MapWindowPoints(HWND_DESKTOP, GetParent(infoPtr->Self), (POINT *)&rect, 2);
651 SetWindowPos(infoPtr->Self, 0, rect.left, rect.top, DEFAULT_WIDTH, rect.bottom - rect.top,
652 SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOZORDER);
653 }
654 return ret;
655 }
656
657 /***********************************************************************
658 * UPDOWN_DoAction
659 *
660 * This function increments/decrements the CurVal by the
661 * 'delta' amount according to the 'action' flag which can be a
662 * combination of FLAG_INCR and FLAG_DECR
663 * It notifies the parent as required.
664 * It handles wraping and non-wraping correctly.
665 * It is assumed that delta>0
666 */
667 static void UPDOWN_DoAction (UPDOWN_INFO *infoPtr, int delta, int action)
668 {
669 NM_UPDOWN ni;
670
671 TRACE("%d by %d\n", action, delta);
672
673 /* check if we can do the modification first */
674 delta *= (action & FLAG_INCR ? 1 : -1) * (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1);
675 if ( (action & FLAG_INCR) && (action & FLAG_DECR) ) delta = 0;
676
677 TRACE("current %d, delta: %d\n", infoPtr->CurVal, delta);
678
679 /* We must notify parent now to obtain permission */
680 ni.iPos = infoPtr->CurVal;
681 ni.iDelta = delta;
682 ni.hdr.hwndFrom = infoPtr->Self;
683 ni.hdr.idFrom = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
684 ni.hdr.code = UDN_DELTAPOS;
685 if (!SendMessageW(infoPtr->Notify, WM_NOTIFY, ni.hdr.idFrom, (LPARAM)&ni)) {
686 /* Parent said: OK to adjust */
687
688 /* Now adjust value with (maybe new) delta */
689 if (UPDOWN_OffsetVal (infoPtr, ni.iDelta)) {
690 TRACE("new %d, delta: %d\n", infoPtr->CurVal, ni.iDelta);
691
692 /* Now take care about our buddy */
693 UPDOWN_SetBuddyInt (infoPtr);
694 }
695 }
696
697 /* Also, notify it. This message is sent in any case. */
698 SendMessageW( infoPtr->Notify, (infoPtr->dwStyle & UDS_HORZ) ? WM_HSCROLL : WM_VSCROLL,
699 MAKELONG(SB_THUMBPOSITION, infoPtr->CurVal), (LPARAM)infoPtr->Self);
700 }
701
702 /***********************************************************************
703 * UPDOWN_IsEnabled
704 *
705 * Returns TRUE if it is enabled as well as its buddy (if any)
706 * FALSE otherwise
707 */
708 static BOOL UPDOWN_IsEnabled (const UPDOWN_INFO *infoPtr)
709 {
710 if (!IsWindowEnabled(infoPtr->Self))
711 return FALSE;
712 if(infoPtr->Buddy)
713 return IsWindowEnabled(infoPtr->Buddy);
714 return TRUE;
715 }
716
717 /***********************************************************************
718 * UPDOWN_CancelMode
719 *
720 * Deletes any timers, releases the mouse and does redraw if necessary.
721 * If the control is not in "capture" mode, it does nothing.
722 * If the control was not in cancel mode, it returns FALSE.
723 * If the control was in cancel mode, it returns TRUE.
724 */
725 static BOOL UPDOWN_CancelMode (UPDOWN_INFO *infoPtr)
726 {
727 if (!(infoPtr->Flags & FLAG_PRESSED)) return FALSE;
728
729 KillTimer (infoPtr->Self, TIMER_AUTOREPEAT);
730 KillTimer (infoPtr->Self, TIMER_ACCEL);
731 KillTimer (infoPtr->Self, TIMER_AUTOPRESS);
732
733 if (GetCapture() == infoPtr->Self) {
734 NMHDR hdr;
735 hdr.hwndFrom = infoPtr->Self;
736 hdr.idFrom = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
737 hdr.code = NM_RELEASEDCAPTURE;
738 SendMessageW(infoPtr->Notify, WM_NOTIFY, hdr.idFrom, (LPARAM)&hdr);
739 ReleaseCapture();
740 }
741
742 infoPtr->Flags &= ~FLAG_PRESSED;
743 InvalidateRect (infoPtr->Self, NULL, FALSE);
744
745 return TRUE;
746 }
747
748 /***********************************************************************
749 * UPDOWN_HandleMouseEvent
750 *
751 * Handle a mouse event for the updown.
752 * 'pt' is the location of the mouse event in client or
753 * windows coordinates.
754 */
755 static void UPDOWN_HandleMouseEvent (UPDOWN_INFO *infoPtr, UINT msg, INT x, INT y)
756 {
757 POINT pt = { x, y };
758 RECT rect;
759 int temp, arrow;
760 TRACKMOUSEEVENT tme;
761
762 TRACE("msg %04x point %s\n", msg, wine_dbgstr_point(&pt));
763
764 switch(msg)
765 {
766 case WM_LBUTTONDOWN: /* Initialise mouse tracking */
767
768 /* If the buddy is an edit, will set focus to it */
769 if (UPDOWN_IsBuddyEdit(infoPtr)) SetFocus(infoPtr->Buddy);
770
771 /* Now see which one is the 'active' arrow */
772 arrow = UPDOWN_GetArrowFromPoint (infoPtr, &rect, pt);
773
774 /* Update the flags if we are in/out */
775 infoPtr->Flags &= ~(FLAG_MOUSEIN | FLAG_ARROW);
776 if (arrow)
777 infoPtr->Flags |= FLAG_MOUSEIN | arrow;
778 else
779 if (infoPtr->AccelIndex != -1) infoPtr->AccelIndex = 0;
780
781 if (infoPtr->Flags & FLAG_ARROW) {
782
783 /* Update the CurVal if necessary */
784 UPDOWN_GetBuddyInt (infoPtr);
785
786 /* Set up the correct flags */
787 infoPtr->Flags |= FLAG_PRESSED;
788
789 /* repaint the control */
790 InvalidateRect (infoPtr->Self, NULL, FALSE);
791
792 /* process the click */
793 temp = (infoPtr->AccelCount && infoPtr->AccelVect) ? infoPtr->AccelVect[0].nInc : 1;
794 UPDOWN_DoAction (infoPtr, temp, infoPtr->Flags & FLAG_ARROW);
795
796 /* now capture all mouse messages */
797 SetCapture (infoPtr->Self);
798
799 /* and startup the first timer */
800 SetTimer(infoPtr->Self, TIMER_AUTOREPEAT, INITIAL_DELAY, 0);
801 }
802 break;
803
804 case WM_MOUSEMOVE:
805 /* save the flags to see if any got modified */
806 temp = infoPtr->Flags;
807
808 /* Now see which one is the 'active' arrow */
809 arrow = UPDOWN_GetArrowFromPoint (infoPtr, &rect, pt);
810
811 /* Update the flags if we are in/out */
812 infoPtr->Flags &= ~(FLAG_MOUSEIN | FLAG_ARROW);
813 if(arrow) {
814 infoPtr->Flags |= FLAG_MOUSEIN | arrow;
815 } else {
816 if(infoPtr->AccelIndex != -1) infoPtr->AccelIndex = 0;
817 }
818
819 /* If state changed, redraw the control */
820 if(temp != infoPtr->Flags)
821 InvalidateRect (infoPtr->Self, NULL, FALSE);
822
823 /* Set up tracking so the mousein flags can be reset when the
824 * mouse leaves the control */
825 tme.cbSize = sizeof( tme );
826 tme.dwFlags = TME_LEAVE;
827 tme.hwndTrack = infoPtr->Self;
828 TrackMouseEvent (&tme);
829
830 break;
831 case WM_MOUSELEAVE:
832 infoPtr->Flags &= ~(FLAG_MOUSEIN | FLAG_ARROW);
833 InvalidateRect (infoPtr->Self, NULL, FALSE);
834 break;
835
836 default:
837 ERR("Impossible case (msg=%x)!\n", msg);
838 }
839
840 }
841
842 /***********************************************************************
843 * UpDownWndProc
844 */
845 static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
846 {
847 UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd);
848 static const WCHAR themeClass[] = {'S','p','i','n',0};
849 HTHEME theme;
850
851 TRACE("hwnd=%p msg=%04x wparam=%08lx lparam=%08lx\n", hwnd, message, wParam, lParam);
852
853 if (!infoPtr && (message != WM_CREATE))
854 return DefWindowProcW (hwnd, message, wParam, lParam);
855
856 switch(message)
857 {
858 case WM_CREATE:
859 infoPtr = Alloc (sizeof(UPDOWN_INFO));
860 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
861
862 /* initialize the info struct */
863 infoPtr->Self = hwnd;
864 infoPtr->Notify = ((LPCREATESTRUCTW)lParam)->hwndParent;
865 infoPtr->dwStyle = ((LPCREATESTRUCTW)lParam)->style;
866 infoPtr->AccelCount = 0;
867 infoPtr->AccelVect = 0;
868 infoPtr->AccelIndex = -1;
869 infoPtr->CurVal = 0;
870 infoPtr->MinVal = 100;
871 infoPtr->MaxVal = 0;
872 infoPtr->Base = 10; /* Default to base 10 */
873 infoPtr->Buddy = 0; /* No buddy window yet */
874 infoPtr->Flags = (infoPtr->dwStyle & UDS_SETBUDDYINT) ? FLAG_BUDDYINT : 0;
875
876 SetWindowLongW (hwnd, GWL_STYLE, infoPtr->dwStyle & ~WS_BORDER);
877
878 /* Do we pick the buddy win ourselves? */
879 if (infoPtr->dwStyle & UDS_AUTOBUDDY)
880 UPDOWN_SetBuddy (infoPtr, GetWindow (hwnd, GW_HWNDPREV));
881
882 OpenThemeData (hwnd, themeClass);
883
884 TRACE("UpDown Ctrl creation, hwnd=%p\n", hwnd);
885 break;
886
887 case WM_DESTROY:
888 Free (infoPtr->AccelVect);
889
890 if(infoPtr->Buddy) RemovePropW(infoPtr->Buddy, BUDDY_UPDOWN_HWND);
891
892 Free (infoPtr);
893 SetWindowLongPtrW (hwnd, 0, 0);
894 theme = GetWindowTheme (hwnd);
895 CloseThemeData (theme);
896 TRACE("UpDown Ctrl destruction, hwnd=%p\n", hwnd);
897 break;
898
899 case WM_ENABLE:
900 if (wParam) {
901 infoPtr->dwStyle &= ~WS_DISABLED;
902 } else {
903 infoPtr->dwStyle |= WS_DISABLED;
904 UPDOWN_CancelMode (infoPtr);
905 }
906 InvalidateRect (infoPtr->Self, NULL, FALSE);
907 break;
908
909 case WM_STYLECHANGED:
910 if (wParam == GWL_STYLE) {
911 infoPtr->dwStyle = ((LPSTYLESTRUCT)lParam)->styleNew;
912 InvalidateRect (infoPtr->Self, NULL, FALSE);
913 }
914 break;
915
916 case WM_THEMECHANGED:
917 theme = GetWindowTheme (hwnd);
918 CloseThemeData (theme);
919 OpenThemeData (hwnd, themeClass);
920 InvalidateRect (hwnd, NULL, FALSE);
921 break;
922
923 case WM_TIMER:
924 /* is this the auto-press timer? */
925 if(wParam == TIMER_AUTOPRESS) {
926 KillTimer(hwnd, TIMER_AUTOPRESS);
927 infoPtr->Flags &= ~(FLAG_PRESSED | FLAG_ARROW);
928 InvalidateRect(infoPtr->Self, NULL, FALSE);
929 }
930
931 /* if initial timer, kill it and start the repeat timer */
932 if(wParam == TIMER_AUTOREPEAT) {
933 int temp;
934
935 KillTimer(hwnd, TIMER_AUTOREPEAT);
936 /* if no accel info given, used default timer */
937 if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0) {
938 infoPtr->AccelIndex = -1;
939 temp = REPEAT_DELAY;
940 } else {
941 infoPtr->AccelIndex = 0; /* otherwise, use it */
942 temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1;
943 }
944 SetTimer(hwnd, TIMER_ACCEL, temp, 0);
945 }
946
947 /* now, if the mouse is above us, do the thing...*/
948 if(infoPtr->Flags & FLAG_MOUSEIN) {
949 int temp;
950
951 temp = infoPtr->AccelIndex == -1 ? 1 : infoPtr->AccelVect[infoPtr->AccelIndex].nInc;
952 UPDOWN_DoAction(infoPtr, temp, infoPtr->Flags & FLAG_ARROW);
953
954 if(infoPtr->AccelIndex != -1 && infoPtr->AccelIndex < infoPtr->AccelCount-1) {
955 KillTimer(hwnd, TIMER_ACCEL);
956 infoPtr->AccelIndex++; /* move to the next accel info */
957 temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1;
958 /* make sure we have at least 1ms intervals */
959 SetTimer(hwnd, TIMER_ACCEL, temp, 0);
960 }
961 }
962 break;
963
964 case WM_CANCELMODE:
965 return UPDOWN_CancelMode (infoPtr);
966
967 case WM_LBUTTONUP:
968 if (GetCapture() != infoPtr->Self) break;
969
970 if ( (infoPtr->Flags & FLAG_MOUSEIN) &&
971 (infoPtr->Flags & FLAG_ARROW) ) {
972
973 SendMessageW( infoPtr->Notify,
974 (infoPtr->dwStyle & UDS_HORZ) ? WM_HSCROLL : WM_VSCROLL,
975 MAKELONG(SB_ENDSCROLL, infoPtr->CurVal),
976 (LPARAM)hwnd);
977 if (UPDOWN_IsBuddyEdit(infoPtr))
978 SendMessageW(infoPtr->Buddy, EM_SETSEL, 0, MAKELONG(0, -1));
979 }
980 UPDOWN_CancelMode(infoPtr);
981 break;
982
983 case WM_LBUTTONDOWN:
984 case WM_MOUSEMOVE:
985 case WM_MOUSELEAVE:
986 if(UPDOWN_IsEnabled(infoPtr))
987 UPDOWN_HandleMouseEvent (infoPtr, message, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
988 break;
989
990 case WM_MOUSEWHEEL:
991 UPDOWN_MouseWheel(infoPtr, wParam);
992 break;
993
994 case WM_KEYDOWN:
995 if((infoPtr->dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(infoPtr))
996 return UPDOWN_KeyPressed(infoPtr, (int)wParam);
997 break;
998
999 case WM_PRINTCLIENT:
1000 case WM_PAINT:
1001 return UPDOWN_Paint (infoPtr, (HDC)wParam);
1002
1003 case UDM_GETACCEL:
1004 if (wParam==0 && lParam==0) return infoPtr->AccelCount;
1005 if (wParam && lParam) {
1006 int temp = min(infoPtr->AccelCount, wParam);
1007 memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL));
1008 return temp;
1009 }
1010 return 0;
1011
1012 case UDM_SETACCEL:
1013 {
1014 unsigned temp;
1015
1016 TRACE("UDM_SETACCEL\n");
1017
1018 if(infoPtr->AccelVect) {
1019 Free (infoPtr->AccelVect);
1020 infoPtr->AccelCount = 0;
1021 infoPtr->AccelVect = 0;
1022 }
1023 if(wParam==0) return TRUE;
1024 infoPtr->AccelVect = Alloc (wParam*sizeof(UDACCEL));
1025 if(infoPtr->AccelVect == 0) return FALSE;
1026 memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL));
1027 infoPtr->AccelCount = wParam;
1028
1029 for (temp = 0; temp < wParam; temp++)
1030 TRACE("%d: nSec %u nInc %u\n", temp, infoPtr->AccelVect[temp].nSec, infoPtr->AccelVect[temp].nInc);
1031
1032 return TRUE;
1033 }
1034 case UDM_GETBASE:
1035 return infoPtr->Base;
1036
1037 case UDM_SETBASE:
1038 TRACE("UpDown Ctrl new base(%ld), hwnd=%p\n", wParam, hwnd);
1039 if (wParam==10 || wParam==16) {
1040 WPARAM old_base = infoPtr->Base;
1041 infoPtr->Base = wParam;
1042
1043 if (old_base != infoPtr->Base)
1044 UPDOWN_SetBuddyInt(infoPtr);
1045
1046 return old_base;
1047 }
1048 break;
1049
1050 case UDM_GETBUDDY:
1051 return (LRESULT)infoPtr->Buddy;
1052
1053 case UDM_SETBUDDY:
1054 return (LRESULT)UPDOWN_SetBuddy (infoPtr, (HWND)wParam);
1055
1056 case UDM_GETPOS:
1057 {
1058 BOOL ret = UPDOWN_GetBuddyInt (infoPtr);
1059 return MAKELONG(infoPtr->CurVal, ret ? 0 : 1);
1060 }
1061 case UDM_SETPOS:
1062 {
1063 int temp = (short)LOWORD(lParam);
1064
1065 TRACE("UpDown Ctrl new value(%d), hwnd=%p\n", temp, hwnd);
1066 if(!UPDOWN_InBounds(infoPtr, temp)) {
1067 if(temp < infoPtr->MinVal) temp = infoPtr->MinVal;
1068 if(temp > infoPtr->MaxVal) temp = infoPtr->MaxVal;
1069 }
1070 wParam = infoPtr->CurVal;
1071 infoPtr->CurVal = temp;
1072 UPDOWN_SetBuddyInt (infoPtr);
1073 return wParam; /* return prev value */
1074 }
1075 case UDM_GETRANGE:
1076 return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal);
1077
1078 case UDM_SETRANGE:
1079 /* we must have:
1080 UD_MINVAL <= Max <= UD_MAXVAL
1081 UD_MINVAL <= Min <= UD_MAXVAL
1082 |Max-Min| <= UD_MAXVAL */
1083 UPDOWN_SetRange(infoPtr, (short)lParam, (short)HIWORD(lParam));
1084 break;
1085
1086 case UDM_GETRANGE32:
1087 if (wParam) *(LPINT)wParam = infoPtr->MinVal;
1088 if (lParam) *(LPINT)lParam = infoPtr->MaxVal;
1089 break;
1090
1091 case UDM_SETRANGE32:
1092 UPDOWN_SetRange(infoPtr, (INT)lParam, (INT)wParam);
1093 break;
1094
1095 case UDM_GETPOS32:
1096 {
1097 BOOL ret = UPDOWN_GetBuddyInt (infoPtr);
1098 if ((LPBOOL)lParam) *((LPBOOL)lParam) = !ret;
1099 return infoPtr->CurVal;
1100 }
1101 case UDM_SETPOS32:
1102 {
1103 int temp;
1104
1105 if(!UPDOWN_InBounds(infoPtr, (int)lParam)) {
1106 if((int)lParam < infoPtr->MinVal) lParam = infoPtr->MinVal;
1107 if((int)lParam > infoPtr->MaxVal) lParam = infoPtr->MaxVal;
1108 }
1109 temp = infoPtr->CurVal; /* save prev value */
1110 infoPtr->CurVal = (int)lParam; /* set the new value */
1111 UPDOWN_SetBuddyInt (infoPtr);
1112 return temp; /* return prev value */
1113 }
1114 case UDM_GETUNICODEFORMAT:
1115 /* we lie a bit here, we're always using Unicode internally */
1116 return infoPtr->UnicodeFormat;
1117
1118 case UDM_SETUNICODEFORMAT:
1119 {
1120 /* do we really need to honour this flag? */
1121 int temp = infoPtr->UnicodeFormat;
1122 infoPtr->UnicodeFormat = (BOOL)wParam;
1123 return temp;
1124 }
1125 default:
1126 if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
1127 ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam);
1128 return DefWindowProcW (hwnd, message, wParam, lParam);
1129 }
1130
1131 return 0;
1132 }
1133
1134 /***********************************************************************
1135 * UPDOWN_Register [Internal]
1136 *
1137 * Registers the updown window class.
1138 */
1139 void UPDOWN_Register(void)
1140 {
1141 WNDCLASSW wndClass;
1142
1143 ZeroMemory( &wndClass, sizeof( WNDCLASSW ) );
1144 wndClass.style = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
1145 wndClass.lpfnWndProc = UpDownWindowProc;
1146 wndClass.cbClsExtra = 0;
1147 wndClass.cbWndExtra = sizeof(UPDOWN_INFO*);
1148 wndClass.hCursor = LoadCursorW( 0, (LPWSTR)IDC_ARROW );
1149 wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
1150 wndClass.lpszClassName = UPDOWN_CLASSW;
1151
1152 RegisterClassW( &wndClass );
1153 }
1154
1155
1156 /***********************************************************************
1157 * UPDOWN_Unregister [Internal]
1158 *
1159 * Unregisters the updown window class.
1160 */
1161 void UPDOWN_Unregister (void)
1162 {
1163 UnregisterClassW (UPDOWN_CLASSW, NULL);
1164 }