?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Prevent crash when nMinRange > nMaxRange.
[wine/hacks.git] / dlls / comctl32 / trackbar.c
blobbeb68898c255b4f89d4631bd38ff0172188158f6
1 /*
2 * Trackbar control
3 *
4 * Copyright 1998, 1999 Eric Kohl <ekohl@abo.rhein-zeitung.de>
5 * Copyright 1998,1999 Alex Priem <alexp@sci.kun.nl>
6 *
7 *
8 * TODO:
9 * - Some messages.
10 * - more display code.
11 * - handle dragging slider better
12 * - better tic handling.
13 * - more notifications.
14 *
15 */
16
17 /* known bugs:
18
19 -TBM_SETRANGEMAX & TBM_SETRANGEMIN should only change the view of the
20 trackbar, not the actual amount of tics in the list.
21 -TBM_GETTIC & TBM_GETTICPOS shouldn't rely on infoPtr->tics being sorted.
22 - Make drawing code exact match of w95 drawing.
23 */
24
25
26
27 #include "winbase.h"
28 #include "commctrl.h"
29 #include "trackbar.h"
30 #include "debug.h"
31
32 DEFAULT_DEBUG_CHANNEL(trackbar)
33
34
35 #define TRACKBAR_GetInfoPtr(wndPtr) ((TRACKBAR_INFO *)GetWindowLongA (hwnd,0))
36
37
38 /* Used by TRACKBAR_Refresh to find out which parts of the control
39 need to be recalculated */
40
41 #define TB_THUMBPOSCHANGED 1
42 #define TB_THUMBSIZECHANGED 2
43 #define TB_THUMBCHANGED (TB_THUMBPOSCHANGED | TB_THUMBPOSCHANGED)
44 #define TB_SELECTIONCHANGED 4
45
46 #define TB_DRAG_MODE 16 /* we're dragging the slider */
47 #define TB_DRAGPOSVALID 32 /* current Position is in dragPos */
48 #define TB_SHOW_TOOLTIP 64 /* tooltip-style enabled and tooltip on */
49 #define TB_REFRESH_TIMER_SET 128 /* is a TRACBKAR_Refresh queued?*/
50
51
52 /* helper defines for TRACKBAR_DrawTic */
53 #define TIC_LEFTEDGE 0x20
54 #define TIC_RIGHTEDGE 0x40
55 #define TIC_EDGE (TIC_LEFTEDGE | TIC_RIGHTEDGE)
56 #define TIC_SELECTIONMARKMAX 0x80
57 #define TIC_SELECTIONMARKMIN 0x100
58 #define TIC_SELECTIONMARK (TIC_SELECTIONMARKMAX | TIC_SELECTIONMARKMIN)
59
60 static BOOL TRACKBAR_SendNotify (HWND hwnd, UINT code);
61
62 void TRACKBAR_RecalculateTics (TRACKBAR_INFO *infoPtr)
63
64 {
65 int i,tic,nrTics;
66
67 if (infoPtr->uTicFreq && infoPtr->nRangeMax >= infoPtr->nRangeMin)
68 nrTics=(infoPtr->nRangeMax - infoPtr->nRangeMin)/infoPtr->uTicFreq;
69 else {
70 nrTics=0;
71 COMCTL32_Free (infoPtr->tics);
72 infoPtr->tics=NULL;
73 infoPtr->uNumTics=0;
74 return;
75 }
76
77 if (nrTics!=infoPtr->uNumTics) {
78 infoPtr->tics=COMCTL32_ReAlloc (infoPtr->tics, (nrTics+1)*sizeof (DWORD));
79 infoPtr->uNumTics=nrTics;
80 }
81 infoPtr->uNumTics=nrTics;
82 tic=infoPtr->nRangeMin+infoPtr->uTicFreq;
83 for (i=0; i<nrTics; i++,tic+=infoPtr->uTicFreq)
84 infoPtr->tics[i]=tic;
85 }
86
87
88 /* converts from physical (mouse) position to logical position
89 (in range of trackbar) */
90
91 static __inline__ INT
92 TRACKBAR_ConvertPlaceToPosition (TRACKBAR_INFO *infoPtr, int place,
93 int vertical)
94 {
95 double range,width,pos;
96
97 range=infoPtr->nRangeMax - infoPtr->nRangeMin;
98 if (vertical) {
99 width=infoPtr->rcChannel.bottom - infoPtr->rcChannel.top;
100 pos=(range*(place - infoPtr->rcChannel.top)) / width;
101 } else {
102 width=infoPtr->rcChannel.right - infoPtr->rcChannel.left;
103 pos=(range*(place - infoPtr->rcChannel.left)) / width;
104 }
105
106 TRACE (trackbar,"%.2f\n",pos);
107 return pos;
108 }
109
110
111
112 static VOID
113 TRACKBAR_CalcChannel (HWND hwnd, TRACKBAR_INFO *infoPtr)
114 {
115 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
116 INT cyChannel;
117 RECT lpRect,*channel = & infoPtr->rcChannel;
118
119 GetClientRect (hwnd, &lpRect);
120
121 if (dwStyle & TBS_ENABLESELRANGE)
122 cyChannel = MAX(infoPtr->uThumbLen - 8, 4);
123 else
124 cyChannel = 4;
125
126 if (dwStyle & TBS_VERT) {
127 channel->top = lpRect.top + 8;
128 channel->bottom = lpRect.bottom - 8;
129
130 if (dwStyle & TBS_BOTH) {
131 channel->left = (lpRect.right - cyChannel) / 2;
132 channel->right = (lpRect.right + cyChannel) / 2;
133 }
134 else if (dwStyle & TBS_LEFT) {
135 channel->left = lpRect.left + 10;
136 channel->right = channel->left + cyChannel;
137 }
138 else { /* TBS_RIGHT */
139 channel->right = lpRect.right - 10;
140 channel->left = channel->right - cyChannel;
141 }
142 }
143 else {
144 channel->left = lpRect.left + 8;
145 channel->right = lpRect.right - 8;
146 if (dwStyle & TBS_BOTH) {
147 channel->top = (lpRect.bottom - cyChannel) / 2;
148 channel->bottom = (lpRect.bottom + cyChannel) / 2;
149 }
150 else if (dwStyle & TBS_TOP) {
151 channel->top = lpRect.top + 10;
152 channel->bottom = channel->top + cyChannel;
153 }
154 else { /* TBS_BOTTOM */
155 channel->bottom = lpRect.bottom - 10;
156 channel->top = channel->bottom - cyChannel;
157 }
158 }
159 }
160
161 static VOID
162 TRACKBAR_CalcThumb (HWND hwnd, TRACKBAR_INFO *infoPtr)
163
164 {
165 RECT *thumb;
166 int range, width;
167
168 thumb=&infoPtr->rcThumb;
169 range=infoPtr->nRangeMax - infoPtr->nRangeMin;
170 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_VERT) {
171 width=infoPtr->rcChannel.bottom - infoPtr->rcChannel.top;
172 thumb->left = infoPtr->rcChannel.left - 1;
173 thumb->right = infoPtr->rcChannel.left + infoPtr->uThumbLen - 8;
174 thumb->top = infoPtr->rcChannel.top +
175 (width*infoPtr->nPos)/range - 5;
176 thumb->bottom = thumb->top + infoPtr->uThumbLen/3;
177
178 } else {
179 width=infoPtr->rcChannel.right - infoPtr->rcChannel.left;
180 thumb->left = infoPtr->rcChannel.left +
181 (width*infoPtr->nPos)/range - 5;
182 thumb->right = thumb->left + infoPtr->uThumbLen/3;
183 thumb->top = infoPtr->rcChannel.top - 1;
184 thumb->bottom = infoPtr->rcChannel.top + infoPtr->uThumbLen - 8;
185 }
186 }
187
188 static VOID
189 TRACKBAR_CalcSelection (HWND hwnd, TRACKBAR_INFO *infoPtr)
190 {
191 RECT *selection;
192 int range, width;
193
194 selection= & infoPtr->rcSelection;
195 range=infoPtr->nRangeMax - infoPtr->nRangeMin;
196 width=infoPtr->rcChannel.right - infoPtr->rcChannel.left;
197
198 if (range <= 0)
199 SetRectEmpty (selection);
200 else
201 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_VERT) {
202 selection->left = infoPtr->rcChannel.left +
203 (width*infoPtr->nSelMin)/range;
204 selection->right = infoPtr->rcChannel.left +
205 (width*infoPtr->nSelMax)/range;
206 selection->top = infoPtr->rcChannel.top + 2;
207 selection->bottom = infoPtr->rcChannel.bottom - 2;
208 } else {
209 selection->top = infoPtr->rcChannel.top +
210 (width*infoPtr->nSelMin)/range;
211 selection->bottom = infoPtr->rcChannel.top +
212 (width*infoPtr->nSelMax)/range;
213 selection->left = infoPtr->rcChannel.left + 2;
214 selection->right = infoPtr->rcChannel.right - 2;
215 }
216 }
217
218
219 static void
220 TRACKBAR_QueueRefresh (HWND hwnd)
221 {
222 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
223
224 TRACE (trackbar,"queued\n");
225 if (infoPtr->flags & TB_REFRESH_TIMER_SET) {
226 KillTimer (hwnd, TB_REFRESH_TIMER);
227 }
228
229 SetTimer (hwnd, TB_REFRESH_TIMER, TB_REFRESH_DELAY, 0);
230 infoPtr->flags|=TB_REFRESH_TIMER_SET;
231 }
232
233
234
235
236
237 /* Trackbar drawing code. I like my spaghetti done milanese. */
238
239 /* ticPos is in tic-units, not in pixels */
240
241 static VOID
242 TRACKBAR_DrawHorizTic (TRACKBAR_INFO *infoPtr, HDC hdc, LONG ticPos,
243 int flags, COLORREF clrTic)
244
245 {
246 RECT rcChannel=infoPtr->rcChannel;
247 int x,y,width,range,side;
248
249 range=infoPtr->nRangeMax - infoPtr->nRangeMin;
250 width=rcChannel.right - rcChannel.left;
251
252 if (flags & TBS_TOP) {
253 y=rcChannel.top-2;
254 side=-1;
255 } else {
256 y=rcChannel.bottom+2;
257 side=1;
258 }
259
260 if (flags & TIC_SELECTIONMARK) {
261 if (flags & TIC_SELECTIONMARKMIN)
262 x=rcChannel.left + (width*ticPos)/range - 1;
263 else
264 x=rcChannel.left + (width*ticPos)/range + 1;
265
266 SetPixel (hdc, x,y+6*side, clrTic);
267 SetPixel (hdc, x,y+7*side, clrTic);
268 return;
269 }
270
271 if ((ticPos>infoPtr->nRangeMin) && (ticPos<infoPtr->nRangeMax)) {
272 x=rcChannel.left + (width*ticPos)/range;
273 SetPixel (hdc, x,y+5*side, clrTic);
274 SetPixel (hdc, x,y+6*side, clrTic);
275 SetPixel (hdc, x,y+7*side, clrTic);
276 }
277
278 if (flags & TIC_EDGE) {
279 if (flags & TIC_LEFTEDGE)
280 x=rcChannel.left;
281 else
282 x=rcChannel.right;
283
284 SetPixel (hdc, x,y+5*side, clrTic);
285 SetPixel (hdc, x,y+6*side, clrTic);
286 SetPixel (hdc, x,y+7*side, clrTic);
287 SetPixel (hdc, x,y+8*side, clrTic);
288 }
289
290 }
291
292 static VOID
293 TRACKBAR_DrawVertTic (TRACKBAR_INFO *infoPtr, HDC hdc, LONG ticPos,
294 int flags, COLORREF clrTic)
295
296 {
297 RECT rcChannel=infoPtr->rcChannel;
298 int x,y,width,range,side;
299
300 range=infoPtr->nRangeMax - infoPtr->nRangeMin;
301 width=rcChannel.bottom - rcChannel.top;
302
303 if (flags & TBS_TOP) {
304 x=rcChannel.right-2;
305 side=-1;
306 } else {
307 x=rcChannel.left+2;
308 side=1;
309 }
310
311
312 if (flags & TIC_SELECTIONMARK) {
313 if (flags & TIC_SELECTIONMARKMIN)
314 y=rcChannel.top + (width*ticPos)/range - 1;
315 else
316 y=rcChannel.top + (width*ticPos)/range + 1;
317
318 SetPixel (hdc, x+6*side, y, clrTic);
319 SetPixel (hdc, x+7*side, y, clrTic);
320 return;
321 }
322
323 if ((ticPos>infoPtr->nRangeMin) && (ticPos<infoPtr->nRangeMax)) {
324 y=rcChannel.top + (width*ticPos)/range;
325 SetPixel (hdc, x+5*side, y, clrTic);
326 SetPixel (hdc, x+6*side, y, clrTic);
327 SetPixel (hdc, x+7*side, y, clrTic);
328 }
329
330 if (flags & TIC_EDGE) {
331 if (flags & TIC_LEFTEDGE)
332 y=rcChannel.top;
333 else
334 y=rcChannel.bottom;
335
336 SetPixel (hdc, x+5*side, y, clrTic);
337 SetPixel (hdc, x+6*side, y, clrTic);
338 SetPixel (hdc, x+7*side, y, clrTic);
339 SetPixel (hdc, x+8*side, y, clrTic);
340 }
341
342 }
343
344
345 static VOID
346 TRACKBAR_DrawTics (TRACKBAR_INFO *infoPtr, HDC hdc, LONG ticPos,
347 int flags, COLORREF clrTic)
348
349 {
350
351 if (flags & TBS_VERT) {
352 if ((flags & TBS_TOP) || (flags & TBS_BOTH))
353 TRACKBAR_DrawVertTic (infoPtr, hdc, ticPos,
354 flags | TBS_TOP , clrTic);
355 if (!(flags & TBS_TOP) || (flags & TBS_BOTH))
356 TRACKBAR_DrawVertTic (infoPtr, hdc, ticPos, flags, clrTic);
357 return;
358 }
359
360 if ((flags & TBS_TOP) || (flags & TBS_BOTH))
361 TRACKBAR_DrawHorizTic (infoPtr, hdc, ticPos, flags | TBS_TOP , clrTic);
362
363 if (!(flags & TBS_TOP) || (flags & TBS_BOTH))
364 TRACKBAR_DrawHorizTic (infoPtr, hdc, ticPos, flags, clrTic);
365
366 }
367
368
369 static VOID
370 TRACKBAR_Refresh (HWND hwnd, HDC hdc)
371 {
372 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
373 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
374 RECT rcClient, rcChannel, rcSelection;
375 HBRUSH hBrush = CreateSolidBrush (infoPtr->clrBk);
376 int i;
377
378 GetClientRect (hwnd, &rcClient);
379 hBrush = CreateSolidBrush (infoPtr->clrBk);
380 FillRect (hdc, &rcClient, hBrush);
381 DeleteObject (hBrush);
382
383 if (infoPtr->flags & TB_REFRESH_TIMER_SET) {
384 KillTimer (hwnd, TB_REFRESH_TIMER);
385 infoPtr->flags &= ~TB_REFRESH_TIMER_SET;
386 }
387
388 if (infoPtr->flags & TB_DRAGPOSVALID) {
389 infoPtr->nPos=infoPtr->dragPos;
390 infoPtr->flags |= TB_THUMBPOSCHANGED;
391 }
392
393 if (infoPtr->flags & TB_THUMBCHANGED) {
394 TRACKBAR_CalcThumb (hwnd, infoPtr);
395 if (infoPtr->flags & TB_THUMBSIZECHANGED)
396 TRACKBAR_CalcChannel (hwnd, infoPtr);
397 }
398 if (infoPtr->flags & TB_SELECTIONCHANGED)
399 TRACKBAR_CalcSelection (hwnd, infoPtr);
400 infoPtr->flags &= ~ (TB_THUMBCHANGED | TB_SELECTIONCHANGED | TB_DRAGPOSVALID);
401
402 /* draw channel */
403
404 rcChannel = infoPtr->rcChannel;
405 rcSelection= infoPtr->rcSelection;
406 DrawEdge (hdc, &rcChannel, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
407
408 if (dwStyle & TBS_ENABLESELRANGE) { /* fill the channel */
409 HBRUSH hbr = CreateSolidBrush (RGB(255,255,255));
410 FillRect (hdc, &rcChannel, hbr);
411 if (((dwStyle & TBS_VERT) &&
412 (rcSelection.left!=rcSelection.right)) ||
413 ((!(dwStyle & TBS_VERT)) &&
414 (rcSelection.left!=rcSelection.right))) {
415 hbr=CreateSolidBrush (COLOR_HIGHLIGHT);
416 FillRect (hdc, &rcSelection, hbr);
417 }
418 DeleteObject (hbr);
419 }
420
421
422 /* draw tics */
423
424 if (!(dwStyle & TBS_NOTICKS)) {
425 int ticFlags = dwStyle & 0x0f;
426 COLORREF clrTic=GetSysColor (COLOR_3DDKSHADOW);
427
428 for (i=0; i<infoPtr->uNumTics; i++)
429 TRACKBAR_DrawTics (infoPtr, hdc, infoPtr->tics[i],
430 ticFlags, clrTic);
431
432 TRACKBAR_DrawTics (infoPtr, hdc, 0, ticFlags | TIC_LEFTEDGE, clrTic);
433 TRACKBAR_DrawTics (infoPtr, hdc, 0, ticFlags | TIC_RIGHTEDGE, clrTic);
434
435 if ((dwStyle & TBS_ENABLESELRANGE) &&
436 (rcSelection.left!=rcSelection.right)) {
437 TRACKBAR_DrawTics (infoPtr, hdc, infoPtr->nSelMin,
438 ticFlags | TIC_SELECTIONMARKMIN, clrTic);
439 TRACKBAR_DrawTics (infoPtr, hdc, infoPtr->nSelMax,
440 ticFlags | TIC_SELECTIONMARKMAX, clrTic);
441 }
442 }
443
444 /* draw thumb */
445
446 if (!(dwStyle & TBS_NOTHUMB)) {
447
448 HBRUSH hbr = CreateSolidBrush (COLOR_BACKGROUND);
449 RECT thumb = infoPtr->rcThumb;
450
451 SelectObject (hdc, hbr);
452
453 if (dwStyle & TBS_BOTH) {
454 FillRect (hdc, &thumb, hbr);
455 DrawEdge (hdc, &thumb, EDGE_RAISED, BF_TOPLEFT);
456 } else {
457
458 POINT points[6];
459
460 /* first, fill the thumb */
461 /* FIXME: revamp. check for TBS_VERT */
462
463 SetPolyFillMode (hdc,WINDING);
464 points[0].x=thumb.left;
465 points[0].y=thumb.top;
466 points[1].x=thumb.right - 1;
467 points[1].y=thumb.top;
468 points[2].x=thumb.right - 1;
469 points[2].y=thumb.bottom -2;
470 points[3].x=(thumb.right + thumb.left-1)/2;
471 points[3].y=thumb.bottom+4;
472 points[4].x=thumb.left;
473 points[4].y=thumb.bottom -2;
474 points[5].x=points[0].x;
475 points[5].y=points[0].y;
476 Polygon (hdc, points, 6);
477
478 if (dwStyle & TBS_VERT) {
479 /* draw edge */
480 } else {
481 RECT triangle; /* for correct shadows of thumb */
482 DrawEdge (hdc, &thumb, EDGE_RAISED, BF_TOPLEFT);
483
484 /* draw notch */
485
486 triangle.right = thumb.right+5;
487 triangle.left = points[3].x+5;
488 triangle.top = thumb.bottom +5;
489 triangle.bottom= thumb.bottom +1;
490 DrawEdge (hdc, &triangle, EDGE_SUNKEN,
491 BF_DIAGONAL | BF_TOP | BF_RIGHT);
492 triangle.left = thumb.left+6;
493 triangle.right = points[3].x+6;
494 DrawEdge (hdc, &triangle, EDGE_RAISED,
495 BF_DIAGONAL | BF_TOP | BF_LEFT);
496 }
497 }
498 DeleteObject (hbr);
499 }
500
501 if (infoPtr->bFocus)
502 DrawFocusRect (hdc, &rcClient);
503 }
504
505
506
507
508 static VOID
509 TRACKBAR_AlignBuddies (HWND hwnd, TRACKBAR_INFO *infoPtr)
510 {
511 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
512 HWND hwndParent = GetParent (hwnd);
513 RECT rcSelf, rcBuddy;
514 INT x, y;
515
516 GetWindowRect (hwnd, &rcSelf);
517 MapWindowPoints (HWND_DESKTOP, hwndParent, (LPPOINT)&rcSelf, 2);
518
519 /* align buddy left or above */
520 if (infoPtr->hwndBuddyLA) {
521 GetWindowRect (infoPtr->hwndBuddyLA, &rcBuddy);
522 MapWindowPoints (HWND_DESKTOP, hwndParent, (LPPOINT)&rcBuddy, 2);
523
524 if (dwStyle & TBS_VERT) {
525 x = (infoPtr->rcChannel.right + infoPtr->rcChannel.left) / 2 -
526 (rcBuddy.right - rcBuddy.left) / 2 + rcSelf.left;
527 y = rcSelf.top - (rcBuddy.bottom - rcBuddy.top);
528 }
529 else {
530 x = rcSelf.left - (rcBuddy.right - rcBuddy.left);
531 y = (infoPtr->rcChannel.bottom + infoPtr->rcChannel.top) / 2 -
532 (rcBuddy.bottom - rcBuddy.top) / 2 + rcSelf.top;
533 }
534
535 SetWindowPos (infoPtr->hwndBuddyLA, 0, x, y, 0, 0,
536 SWP_NOZORDER | SWP_NOSIZE);
537 }
538
539
540 /* align buddy right or below */
541 if (infoPtr->hwndBuddyRB) {
542 GetWindowRect (infoPtr->hwndBuddyRB, &rcBuddy);
543 MapWindowPoints (HWND_DESKTOP, hwndParent, (LPPOINT)&rcBuddy, 2);
544
545 if (dwStyle & TBS_VERT) {
546 x = (infoPtr->rcChannel.right + infoPtr->rcChannel.left) / 2 -
547 (rcBuddy.right - rcBuddy.left) / 2 + rcSelf.left;
548 y = rcSelf.bottom;
549 }
550 else {
551 x = rcSelf.right;
552 y = (infoPtr->rcChannel.bottom + infoPtr->rcChannel.top) / 2 -
553 (rcBuddy.bottom - rcBuddy.top) / 2 + rcSelf.top;
554 }
555 SetWindowPos (infoPtr->hwndBuddyRB, 0, x, y, 0, 0,
556 SWP_NOZORDER | SWP_NOSIZE);
557 }
558 }
559
560
561 static LRESULT
562 TRACKBAR_ClearSel (HWND hwnd, WPARAM wParam, LPARAM lParam)
563 {
564 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
565
566 infoPtr->nSelMin = 0;
567 infoPtr->nSelMax = 0;
568 infoPtr->flags |=TB_SELECTIONCHANGED;
569
570 if ((BOOL)wParam) {
571 HDC hdc = GetDC (hwnd);
572 TRACKBAR_Refresh (hwnd, hdc);
573 ReleaseDC (hwnd, hdc);
574 }
575
576 return 0;
577 }
578
579
580 static LRESULT
581 TRACKBAR_ClearTics (HWND hwnd, WPARAM wParam, LPARAM lParam)
582 {
583 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
584
585 if (infoPtr->tics) {
586 COMCTL32_Free (infoPtr->tics);
587 infoPtr->tics = NULL;
588 infoPtr->uNumTics = 0;
589 }
590
591 if (wParam) {
592 HDC hdc = GetDC (hwnd);
593 TRACKBAR_Refresh (hwnd, hdc);
594 ReleaseDC (hwnd, hdc);
595 }
596
597 return 0;
598 }
599
600
601 static LRESULT
602 TRACKBAR_GetBuddy (HWND hwnd, WPARAM wParam, LPARAM lParam)
603 {
604 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
605
606 if (wParam) /* buddy is left or above */
607 return (LRESULT)infoPtr->hwndBuddyLA;
608
609 /* buddy is right or below */
610 return (LRESULT) infoPtr->hwndBuddyRB;
611 }
612
613
614 static LRESULT
615 TRACKBAR_GetChannelRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
616 {
617 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
618 LPRECT lprc = (LPRECT)lParam;
619
620 if (lprc == NULL)
621 return 0;
622
623 lprc->left = infoPtr->rcChannel.left;
624 lprc->right = infoPtr->rcChannel.right;
625 lprc->bottom = infoPtr->rcChannel.bottom;
626 lprc->top = infoPtr->rcChannel.top;
627
628 return 0;
629 }
630
631
632 static LRESULT
633 TRACKBAR_GetLineSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
634 {
635 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
636
637 return infoPtr->nLineSize;
638 }
639
640
641 static LRESULT
642 TRACKBAR_GetNumTics (HWND hwnd, WPARAM wParam, LPARAM lParam)
643 {
644 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
645
646 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_NOTICKS)
647 return 0;
648
649 return infoPtr->uNumTics+2;
650 }
651
652
653 static LRESULT
654 TRACKBAR_GetPageSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
655 {
656 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
657
658 return infoPtr->nPageSize;
659 }
660
661
662 static LRESULT
663 TRACKBAR_GetPos (HWND hwnd, WPARAM wParam, LPARAM lParam)
664 {
665 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
666
667 return infoPtr->nPos;
668 }
669
670
671
672
673 static LRESULT
674 TRACKBAR_GetRangeMax (HWND hwnd, WPARAM wParam, LPARAM lParam)
675 {
676 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
677
678 return infoPtr->nRangeMax;
679 }
680
681
682 static LRESULT
683 TRACKBAR_GetRangeMin (HWND hwnd, WPARAM wParam, LPARAM lParam)
684 {
685 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
686
687 return infoPtr->nRangeMin;
688 }
689
690
691 static LRESULT
692 TRACKBAR_GetSelEnd (HWND hwnd, WPARAM wParam, LPARAM lParam)
693 {
694 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
695
696 return infoPtr->nSelMax;
697 }
698
699
700 static LRESULT
701 TRACKBAR_GetSelStart (HWND hwnd, WPARAM wParam, LPARAM lParam)
702 {
703 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
704
705 return infoPtr->nSelMin;
706 }
707
708
709 static LRESULT
710 TRACKBAR_GetThumbLength (HWND hwnd, WPARAM wParam, LPARAM lParam)
711 {
712 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
713
714 return infoPtr->uThumbLen;
715 }
716
717 static LRESULT
718 TRACKBAR_GetPTics (HWND hwnd)
719 {
720 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
721
722 return (LRESULT) infoPtr->tics;
723 }
724
725 static LRESULT
726 TRACKBAR_GetThumbRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
727 {
728 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
729 LPRECT lprc = (LPRECT)lParam;
730
731 if (lprc == NULL)
732 return 0;
733
734 lprc->left = infoPtr->rcThumb.left;
735 lprc->right = infoPtr->rcThumb.right;
736 lprc->bottom = infoPtr->rcThumb.bottom;
737 lprc->top = infoPtr->rcThumb.top;
738
739 return 0;
740 }
741
742
743
744
745
746 static LRESULT
747 TRACKBAR_GetTic (HWND hwnd, WPARAM wParam, LPARAM lParam)
748
749 {
750 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
751 INT iTic;
752
753 iTic=(INT) wParam;
754 if ((iTic<0) || (iTic>infoPtr->uNumTics))
755 return -1;
756
757 return (LRESULT) infoPtr->tics[iTic];
758
759 }
760
761
762 static LRESULT
763 TRACKBAR_GetTicPos (HWND hwnd, WPARAM wParam, LPARAM lParam)
764 {
765 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
766 INT iTic, range, width, pos;
767
768
769 iTic=(INT ) wParam;
770 if ((iTic<0) || (iTic>infoPtr->uNumTics))
771 return -1;
772
773 range=infoPtr->nRangeMax - infoPtr->nRangeMin;
774 width=infoPtr->rcChannel.right - infoPtr->rcChannel.left;
775 pos=infoPtr->rcChannel.left + (width * infoPtr->tics[iTic]) / range;
776
777
778 return (LRESULT) pos;
779 }
780
781 static LRESULT
782 TRACKBAR_GetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
783 {
784 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
785
786 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_TOOLTIPS)
787 return (LRESULT)infoPtr->hwndToolTip;
788 return 0;
789 }
790
791
792 /* case TBM_GETUNICODEFORMAT: */
793
794
795 static LRESULT
796 TRACKBAR_SetBuddy (HWND hwnd, WPARAM wParam, LPARAM lParam)
797 {
798 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
799 HWND hwndTemp;
800
801 if (wParam) {
802 /* buddy is left or above */
803 hwndTemp = infoPtr->hwndBuddyLA;
804 infoPtr->hwndBuddyLA = (HWND)lParam;
805
806 FIXME (trackbar, "move buddy!\n");
807 }
808 else {
809 /* buddy is right or below */
810 hwndTemp = infoPtr->hwndBuddyRB;
811 infoPtr->hwndBuddyRB = (HWND)lParam;
812
813 FIXME (trackbar, "move buddy!\n");
814 }
815
816 TRACKBAR_AlignBuddies (hwnd, infoPtr);
817
818 return (LRESULT)hwndTemp;
819 }
820
821
822 static LRESULT
823 TRACKBAR_SetLineSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
824 {
825 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
826 INT nTemp = infoPtr->nLineSize;
827
828 infoPtr->nLineSize = (INT)lParam;
829
830 return nTemp;
831 }
832
833
834 static LRESULT
835 TRACKBAR_SetPageSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
836 {
837 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
838 INT nTemp = infoPtr->nPageSize;
839
840 infoPtr->nPageSize = (INT)lParam;
841
842 return nTemp;
843 }
844
845
846 static LRESULT
847 TRACKBAR_SetPos (HWND hwnd, WPARAM wParam, LPARAM lParam)
848 {
849 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
850
851 infoPtr->nPos = (INT)HIWORD(lParam);
852
853 if (infoPtr->nPos < infoPtr->nRangeMin)
854 infoPtr->nPos = infoPtr->nRangeMin;
855
856 if (infoPtr->nPos > infoPtr->nRangeMax)
857 infoPtr->nPos = infoPtr->nRangeMax;
858 infoPtr->flags |=TB_THUMBPOSCHANGED;
859
860 if (wParam) {
861 HDC hdc = GetDC (hwnd);
862 TRACKBAR_Refresh (hwnd, hdc);
863 ReleaseDC (hwnd, hdc);
864 }
865
866 return 0;
867 }
868
869
870 static LRESULT
871 TRACKBAR_SetRange (HWND hwnd, WPARAM wParam, LPARAM lParam)
872 {
873 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
874 infoPtr->nRangeMin = (INT)LOWORD(lParam);
875 infoPtr->nRangeMax = (INT)HIWORD(lParam);
876
877 if (infoPtr->nPos < infoPtr->nRangeMin) {
878 infoPtr->nPos = infoPtr->nRangeMin;
879 infoPtr->flags |=TB_THUMBPOSCHANGED;
880 }
881
882 if (infoPtr->nPos > infoPtr->nRangeMax) {
883 infoPtr->nPos = infoPtr->nRangeMax;
884 infoPtr->flags |=TB_THUMBPOSCHANGED;
885 }
886
887 infoPtr->nPageSize=(infoPtr->nRangeMax - infoPtr->nRangeMin)/5;
888 TRACKBAR_RecalculateTics (infoPtr);
889
890 if (wParam) {
891 HDC hdc = GetDC (hwnd);
892 TRACKBAR_Refresh (hwnd, hdc);
893 ReleaseDC (hwnd, hdc);
894 }
895
896 return 0;
897 }
898
899
900 static LRESULT
901 TRACKBAR_SetRangeMax (HWND hwnd, WPARAM wParam, LPARAM lParam)
902 {
903 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
904
905 infoPtr->nRangeMax = (INT)lParam;
906 if (infoPtr->nPos > infoPtr->nRangeMax) {
907 infoPtr->nPos = infoPtr->nRangeMax;
908 infoPtr->flags |=TB_THUMBPOSCHANGED;
909 }
910
911 infoPtr->nPageSize=(infoPtr->nRangeMax - infoPtr->nRangeMin)/5;
912 TRACKBAR_RecalculateTics (infoPtr);
913
914 if (wParam) {
915 HDC hdc = GetDC (hwnd);
916 TRACKBAR_Refresh (hwnd, hdc);
917 ReleaseDC (hwnd, hdc);
918 }
919
920 return 0;
921 }
922
923
924 static LRESULT
925 TRACKBAR_SetRangeMin (HWND hwnd, WPARAM wParam, LPARAM lParam)
926 {
927 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
928
929 infoPtr->nRangeMin = (INT)lParam;
930 if (infoPtr->nPos < infoPtr->nRangeMin) {
931 infoPtr->nPos = infoPtr->nRangeMin;
932 infoPtr->flags |=TB_THUMBPOSCHANGED;
933 }
934
935 infoPtr->nPageSize=(infoPtr->nRangeMax - infoPtr->nRangeMin)/5;
936 TRACKBAR_RecalculateTics (infoPtr);
937
938 if (wParam) {
939 HDC hdc = GetDC (hwnd);
940 TRACKBAR_Refresh (hwnd, hdc);
941 ReleaseDC (hwnd, hdc);
942 }
943
944 return 0;
945 }
946
947 static LRESULT
948 TRACKBAR_SetTicFreq (HWND hwnd, WPARAM wParam)
949 {
950 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
951 HDC hdc;
952
953 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_AUTOTICKS)
954 infoPtr->uTicFreq=(UINT) wParam;
955
956 TRACKBAR_RecalculateTics (infoPtr);
957
958 hdc = GetDC (hwnd);
959 TRACKBAR_Refresh (hwnd, hdc);
960 ReleaseDC (hwnd, hdc);
961
962 return 0;
963 }
964
965
966 static LRESULT
967 TRACKBAR_SetSel (HWND hwnd, WPARAM wParam, LPARAM lParam)
968 {
969 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
970
971 infoPtr->nSelMin = (INT)LOWORD(lParam);
972 infoPtr->nSelMax = (INT)HIWORD(lParam);
973 infoPtr->flags |=TB_SELECTIONCHANGED;
974
975 if (!GetWindowLongA (hwnd, GWL_STYLE) & TBS_ENABLESELRANGE)
976 return 0;
977
978 if (infoPtr->nSelMin < infoPtr->nRangeMin)
979 infoPtr->nSelMin = infoPtr->nRangeMin;
980 if (infoPtr->nSelMax > infoPtr->nRangeMax)
981 infoPtr->nSelMax = infoPtr->nRangeMax;
982
983 if (wParam) {
984 HDC hdc = GetDC (hwnd);
985 TRACKBAR_Refresh (hwnd, hdc);
986 ReleaseDC (hwnd, hdc);
987 }
988
989 return 0;
990 }
991
992
993 static LRESULT
994 TRACKBAR_SetSelEnd (HWND hwnd, WPARAM wParam, LPARAM lParam)
995 {
996 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
997
998 if (!GetWindowLongA (hwnd, GWL_STYLE) & TBS_ENABLESELRANGE)
999 return 0;
1000
1001 infoPtr->nSelMax = (INT)lParam;
1002 infoPtr->flags |=TB_SELECTIONCHANGED;
1003
1004 if (infoPtr->nSelMax > infoPtr->nRangeMax)
1005 infoPtr->nSelMax = infoPtr->nRangeMax;
1006
1007 if (wParam) {
1008 HDC hdc = GetDC (hwnd);
1009 TRACKBAR_Refresh (hwnd, hdc);
1010 ReleaseDC (hwnd, hdc);
1011 }
1012
1013 return 0;
1014 }
1015
1016
1017 static LRESULT
1018 TRACKBAR_SetSelStart (HWND hwnd, WPARAM wParam, LPARAM lParam)
1019 {
1020 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1021
1022 if (!GetWindowLongA (hwnd, GWL_STYLE) & TBS_ENABLESELRANGE)
1023 return 0;
1024
1025 infoPtr->nSelMin = (INT)lParam;
1026 infoPtr->flags |=TB_SELECTIONCHANGED;
1027
1028 if (infoPtr->nSelMin < infoPtr->nRangeMin)
1029 infoPtr->nSelMin = infoPtr->nRangeMin;
1030
1031 if (wParam) {
1032 HDC hdc = GetDC (hwnd);
1033 TRACKBAR_Refresh (hwnd, hdc);
1034 ReleaseDC (hwnd, hdc);
1035 }
1036
1037 return 0;
1038 }
1039
1040
1041 static LRESULT
1042 TRACKBAR_SetThumbLength (HWND hwnd, WPARAM wParam, LPARAM lParam)
1043 {
1044 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1045 HDC hdc;
1046
1047 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_FIXEDLENGTH)
1048 infoPtr->uThumbLen = (UINT)wParam;
1049
1050 infoPtr->flags |=TB_THUMBSIZECHANGED;
1051
1052 hdc = GetDC (hwnd);
1053 TRACKBAR_Refresh (hwnd, hdc);
1054 ReleaseDC (hwnd, hdc);
1055
1056 return 0;
1057 }
1058
1059
1060 static LRESULT
1061 TRACKBAR_SetTic (HWND hwnd, WPARAM wParam, LPARAM lParam)
1062 {
1063 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1064 INT nPos = (INT)lParam;
1065 HDC hdc;
1066
1067 if ((nPos < infoPtr->nRangeMin) || (nPos> infoPtr->nRangeMax))
1068 return FALSE;
1069
1070 infoPtr->uNumTics++;
1071 infoPtr->tics=COMCTL32_ReAlloc( infoPtr->tics,
1072 (infoPtr->uNumTics)*sizeof (DWORD));
1073 infoPtr->tics[infoPtr->uNumTics-1]=nPos;
1074
1075 hdc = GetDC (hwnd);
1076 TRACKBAR_Refresh (hwnd, hdc);
1077 ReleaseDC (hwnd, hdc);
1078
1079 return TRUE;
1080 }
1081
1082
1083
1084
1085 static LRESULT
1086 TRACKBAR_SetTipSide (HWND hwnd, WPARAM wParam, LPARAM lParam)
1087 {
1088 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1089 INT fTemp = infoPtr->fLocation;
1090
1091 infoPtr->fLocation = (INT)wParam;
1092
1093 return fTemp;
1094 }
1095
1096
1097 static LRESULT
1098 TRACKBAR_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
1099 {
1100 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1101
1102 infoPtr->hwndToolTip = (HWND)wParam;
1103
1104 return 0;
1105 }
1106
1107
1108 /* case TBM_SETUNICODEFORMAT: */
1109
1110
1111 static LRESULT
1112 TRACKBAR_InitializeThumb (HWND hwnd)
1113 {
1114 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1115
1116 infoPtr->uThumbLen = 23; /* initial thumb length */
1117
1118 TRACKBAR_CalcChannel (hwnd,infoPtr);
1119 TRACKBAR_CalcThumb (hwnd, infoPtr);
1120 infoPtr->flags &= ~TB_SELECTIONCHANGED;
1121
1122 return 0;
1123 }
1124
1125
1126 static LRESULT
1127 TRACKBAR_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1128 {
1129 TRACKBAR_INFO *infoPtr;
1130
1131 infoPtr = (TRACKBAR_INFO *)COMCTL32_Alloc (sizeof(TRACKBAR_INFO));
1132 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1133
1134 /* set default values */
1135 infoPtr->nRangeMin = 0;
1136 infoPtr->nRangeMax = 100;
1137 infoPtr->nLineSize = 1;
1138 infoPtr->nPageSize = 20;
1139 infoPtr->nSelMin = 0;
1140 infoPtr->nSelMax = 0;
1141 infoPtr->nPos = 0;
1142
1143 infoPtr->uNumTics = 0; /* start and end tic are not included in count*/
1144 infoPtr->uTicFreq = 1;
1145 infoPtr->tics = NULL;
1146 infoPtr->clrBk = GetSysColor (COLOR_BACKGROUND);
1147 infoPtr->hwndNotify = GetParent (hwnd);
1148
1149 TRACKBAR_InitializeThumb (hwnd);
1150
1151 /* Create tooltip control */
1152 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_TOOLTIPS) {
1153 TTTOOLINFOA ti;
1154
1155 infoPtr->hwndToolTip =
1156 CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
1157 CW_USEDEFAULT, CW_USEDEFAULT,
1158 CW_USEDEFAULT, CW_USEDEFAULT,
1159 hwnd, 0, 0, 0);
1160
1161 /* Send NM_TOOLTIPSCREATED notification */
1162 if (infoPtr->hwndToolTip) {
1163 NMTOOLTIPSCREATED nmttc;
1164
1165 nmttc.hdr.hwndFrom = hwnd;
1166 nmttc.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
1167 nmttc.hdr.code = NM_TOOLTIPSCREATED;
1168 nmttc.hwndToolTips = infoPtr->hwndToolTip;
1169
1170 SendMessageA (GetParent (hwnd), WM_NOTIFY,
1171 (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
1172 }
1173
1174 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
1175 ti.cbSize = sizeof(TTTOOLINFOA);
1176 ti.uFlags = TTF_IDISHWND | TTF_TRACK;
1177 ti.hwnd = hwnd;
1178 ti.uId = 0;
1179 ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK */
1180 SetRectEmpty (&ti.rect);
1181
1182 SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA, 0, (LPARAM)&ti);
1183 }
1184
1185 return 0;
1186 }
1187
1188
1189 static LRESULT
1190 TRACKBAR_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1191 {
1192 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1193
1194 if (infoPtr->flags & TB_REFRESH_TIMER_SET)
1195 KillTimer (hwnd, TB_REFRESH_TIMER);
1196
1197 /* delete tooltip control */
1198 if (infoPtr->hwndToolTip)
1199 DestroyWindow (infoPtr->hwndToolTip);
1200
1201 COMCTL32_Free (infoPtr);
1202 return 0;
1203 }
1204
1205
1206 static LRESULT
1207 TRACKBAR_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
1208 {
1209 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1210
1211 TRACE (trackbar,"\n");
1212
1213 infoPtr->bFocus = FALSE;
1214 infoPtr->flags &= ~TB_DRAG_MODE;
1215
1216 TRACKBAR_QueueRefresh (hwnd);
1217 InvalidateRect (hwnd, NULL, TRUE);
1218
1219 return 0;
1220 }
1221
1222
1223 static LRESULT
1224 TRACKBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
1225 {
1226 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1227 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1228 int clickPlace,prevPos,clickPos,vertical;
1229
1230 SetFocus (hwnd);
1231
1232 vertical = dwStyle & TBS_VERT;
1233 if (vertical)
1234 clickPlace=(INT)HIWORD(lParam);
1235 else
1236 clickPlace=(INT)LOWORD(lParam);
1237
1238 if ((vertical &&
1239 (clickPlace>infoPtr->rcThumb.top) &&
1240 (clickPlace<infoPtr->rcThumb.bottom)) ||
1241 (!vertical &&
1242 (clickPlace>infoPtr->rcThumb.left) &&
1243 (clickPlace<infoPtr->rcThumb.right))) {
1244 infoPtr->flags |= TB_DRAG_MODE;
1245 if (dwStyle & TBS_TOOLTIPS) { /* enable tooltip */
1246 TTTOOLINFOA ti;
1247 POINT pt;
1248
1249 GetCursorPos (&pt);
1250 SendMessageA (infoPtr->hwndToolTip, TTM_TRACKPOSITION, 0,
1251 (LPARAM)MAKELPARAM(pt.x, pt.y));
1252
1253 ti.cbSize = sizeof(TTTOOLINFOA);
1254 ti.uId = 0;
1255 ti.hwnd = (UINT)hwnd;
1256
1257 infoPtr->flags |= TB_SHOW_TOOLTIP;
1258 SetCapture (hwnd);
1259 SendMessageA (infoPtr->hwndToolTip, TTM_TRACKACTIVATE,
1260 (WPARAM)TRUE, (LPARAM)&ti);
1261 }
1262 return 0;
1263 }
1264
1265 clickPos=TRACKBAR_ConvertPlaceToPosition (infoPtr, clickPlace, vertical);
1266 prevPos = infoPtr->nPos;
1267
1268 if (clickPos > prevPos) { /* similar to VK_NEXT */
1269 infoPtr->nPos += infoPtr->nPageSize;
1270 if (infoPtr->nPos > infoPtr->nRangeMax)
1271 infoPtr->nPos = infoPtr->nRangeMax;
1272 TRACKBAR_SendNotify (hwnd, TB_PAGEUP);
1273 } else {
1274 infoPtr->nPos -= infoPtr->nPageSize; /* similar to VK_PRIOR */
1275 if (infoPtr->nPos < infoPtr->nRangeMin)
1276 infoPtr->nPos = infoPtr->nRangeMin;
1277 TRACKBAR_SendNotify (hwnd, TB_PAGEDOWN);
1278 }
1279
1280 if (prevPos!=infoPtr->nPos) {
1281 infoPtr->flags |=TB_THUMBPOSCHANGED;
1282 TRACKBAR_QueueRefresh (hwnd);
1283 }
1284
1285 return 0;
1286 }
1287
1288 static LRESULT
1289 TRACKBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
1290 {
1291 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1292
1293 TRACKBAR_QueueRefresh (hwnd);
1294 TRACKBAR_SendNotify (hwnd, TB_ENDTRACK);
1295
1296 infoPtr->flags &= ~TB_DRAG_MODE;
1297
1298 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_TOOLTIPS) { /* disable tooltip */
1299 TTTOOLINFOA ti;
1300
1301 ti.cbSize = sizeof(TTTOOLINFOA);
1302 ti.uId = 0;
1303 ti.hwnd = (UINT)hwnd;
1304
1305 infoPtr->flags &= ~TB_SHOW_TOOLTIP;
1306 ReleaseCapture ();
1307 SendMessageA (infoPtr->hwndToolTip, TTM_TRACKACTIVATE,
1308 (WPARAM)FALSE, (LPARAM)&ti);
1309 }
1310
1311 return 0;
1312 }
1313
1314 static LRESULT
1315 TRACKBAR_CaptureChanged (HWND hwnd, WPARAM wParam, LPARAM lParam)
1316 {
1317 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1318
1319 if (infoPtr->flags & TB_DRAGPOSVALID) {
1320 infoPtr->nPos=infoPtr->dragPos;
1321 TRACKBAR_QueueRefresh (hwnd);
1322 }
1323
1324 infoPtr->flags &= ~ TB_DRAGPOSVALID;
1325
1326 TRACKBAR_SendNotify (hwnd, TB_ENDTRACK);
1327 return 0;
1328 }
1329
1330 static LRESULT
1331 TRACKBAR_Paint (HWND hwnd, WPARAM wParam)
1332 {
1333 HDC hdc;
1334 PAINTSTRUCT ps;
1335
1336 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
1337 TRACKBAR_Refresh (hwnd, hdc);
1338 if(!wParam)
1339 EndPaint (hwnd, &ps);
1340 return 0;
1341 }
1342
1343
1344 static LRESULT
1345 TRACKBAR_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
1346 {
1347 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1348 HDC hdc;
1349
1350 TRACE (trackbar,"\n");
1351 infoPtr->bFocus = TRUE;
1352
1353 hdc = GetDC (hwnd);
1354 TRACKBAR_Refresh (hwnd, hdc);
1355 ReleaseDC (hwnd, hdc);
1356
1357 return 0;
1358 }
1359
1360
1361 static LRESULT
1362 TRACKBAR_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1363 {
1364 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1365
1366 TRACKBAR_CalcChannel (hwnd, infoPtr);
1367 TRACKBAR_AlignBuddies (hwnd, infoPtr);
1368
1369 return 0;
1370 }
1371
1372
1373
1374 static BOOL
1375 TRACKBAR_SendNotify (HWND hwnd, UINT code)
1376
1377 {
1378 TRACE (trackbar, "%x\n",code);
1379
1380 if (GetWindowLongA (hwnd, GWL_STYLE) & TBS_VERT)
1381 return (BOOL) SendMessageA (GetParent (hwnd),
1382 WM_VSCROLL, (WPARAM)code, (LPARAM)hwnd);
1383
1384 return (BOOL) SendMessageA (GetParent (hwnd),
1385 WM_HSCROLL, (WPARAM)code, (LPARAM)hwnd);
1386 }
1387
1388 static LRESULT
1389 TRACKBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
1390 {
1391 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1392 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1393 INT clickPlace;
1394 HDC hdc;
1395 char buf[80];
1396
1397 TRACE (trackbar, "%x\n",wParam);
1398
1399 if (dwStyle & TBS_VERT)
1400 clickPlace=(INT)HIWORD(lParam);
1401 else
1402 clickPlace=(INT)LOWORD(lParam);
1403
1404 if (!(infoPtr->flags & TB_DRAG_MODE))
1405 return TRUE;
1406
1407 infoPtr->dragPos = TRACKBAR_ConvertPlaceToPosition (infoPtr, clickPlace, dwStyle & TBS_VERT);
1408 infoPtr->flags|= TB_DRAGPOSVALID;
1409 TRACKBAR_SendNotify (hwnd, TB_THUMBTRACK | (infoPtr->nPos>>16));
1410
1411 if (infoPtr->flags & TB_SHOW_TOOLTIP) {
1412 POINT pt;
1413 TTTOOLINFOA ti;
1414
1415 ti.cbSize = sizeof(TTTOOLINFOA);
1416 ti.hwnd = hwnd;
1417 ti.uId = 0;
1418 ti.hinst=0;
1419 sprintf (buf,"%d",infoPtr->nPos);
1420 ti.lpszText = (LPSTR) buf;
1421 GetCursorPos (&pt);
1422
1423 if (dwStyle & TBS_VERT) {
1424 SendMessageA (infoPtr->hwndToolTip, TTM_TRACKPOSITION,
1425 0, (LPARAM)MAKELPARAM(pt.x+5, pt.y+15));
1426 } else {
1427 SendMessageA (infoPtr->hwndToolTip, TTM_TRACKPOSITION,
1428 0, (LPARAM)MAKELPARAM(pt.x+15, pt.y+5));
1429 }
1430 SendMessageA (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTA,
1431 0, (LPARAM)&ti);
1432 }
1433
1434 hdc = GetDC (hwnd);
1435 TRACKBAR_Refresh (hwnd, hdc);
1436 ReleaseDC (hwnd, hdc);
1437
1438 return TRUE;
1439 }
1440
1441
1442 static LRESULT
1443 TRACKBAR_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
1444 {
1445 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1446 INT pos;
1447
1448 TRACE (trackbar, "%x\n",wParam);
1449
1450 pos=infoPtr->nPos;
1451 switch (wParam) {
1452 case VK_LEFT:
1453 case VK_UP:
1454 if (infoPtr->nPos == infoPtr->nRangeMin) return FALSE;
1455 infoPtr->nPos -= infoPtr->nLineSize;
1456 if (infoPtr->nPos < infoPtr->nRangeMin)
1457 infoPtr->nPos = infoPtr->nRangeMin;
1458 TRACKBAR_SendNotify (hwnd, TB_LINEUP);
1459 break;
1460 case VK_RIGHT:
1461 case VK_DOWN:
1462 if (infoPtr->nPos == infoPtr->nRangeMax) return FALSE;
1463 infoPtr->nPos += infoPtr->nLineSize;
1464 if (infoPtr->nPos > infoPtr->nRangeMax)
1465 infoPtr->nPos = infoPtr->nRangeMax;
1466 TRACKBAR_SendNotify (hwnd, TB_LINEDOWN);
1467 break;
1468 case VK_NEXT:
1469 if (infoPtr->nPos == infoPtr->nRangeMax) return FALSE;
1470 infoPtr->nPos += infoPtr->nPageSize;
1471 if (infoPtr->nPos > infoPtr->nRangeMax)
1472 infoPtr->nPos = infoPtr->nRangeMax;
1473 TRACKBAR_SendNotify (hwnd, TB_PAGEUP);
1474 break;
1475 case VK_PRIOR:
1476 if (infoPtr->nPos == infoPtr->nRangeMin) return FALSE;
1477 infoPtr->nPos -= infoPtr->nPageSize;
1478 if (infoPtr->nPos < infoPtr->nRangeMin)
1479 infoPtr->nPos = infoPtr->nRangeMin;
1480 TRACKBAR_SendNotify (hwnd, TB_PAGEDOWN);
1481 break;
1482 case VK_HOME:
1483 if (infoPtr->nPos == infoPtr->nRangeMin) return FALSE;
1484 infoPtr->nPos = infoPtr->nRangeMin;
1485 TRACKBAR_SendNotify (hwnd, TB_TOP);
1486 break;
1487 case VK_END:
1488 if (infoPtr->nPos == infoPtr->nRangeMax) return FALSE;
1489 infoPtr->nPos = infoPtr->nRangeMax;
1490 TRACKBAR_SendNotify (hwnd, TB_BOTTOM);
1491 break;
1492 }
1493
1494 if (pos!=infoPtr->nPos) {
1495 infoPtr->flags |=TB_THUMBPOSCHANGED;
1496 TRACKBAR_QueueRefresh (hwnd);
1497 }
1498
1499 return TRUE;
1500 }
1501
1502 static LRESULT
1503 TRACKBAR_KeyUp (HWND hwnd, WPARAM wParam)
1504 {
1505 switch (wParam) {
1506 case VK_LEFT:
1507 case VK_UP:
1508 case VK_RIGHT:
1509 case VK_DOWN:
1510 case VK_NEXT:
1511 case VK_PRIOR:
1512 case VK_HOME:
1513 case VK_END:
1514 TRACKBAR_SendNotify (hwnd, TB_ENDTRACK);
1515 }
1516 return TRUE;
1517 }
1518
1519
1520 static LRESULT
1521 TRACKBAR_HandleTimer (HWND hwnd, WPARAM wParam, LPARAM lParam)
1522 {
1523 TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr (hwnd);
1524 HDC hdc;
1525
1526 TRACE (trackbar,"timer\n");
1527
1528 switch (wParam) {
1529 case TB_REFRESH_TIMER:
1530 KillTimer (hwnd, TB_REFRESH_TIMER );
1531 if (infoPtr->flags & TB_DRAGPOSVALID) {
1532 infoPtr->nPos=infoPtr->dragPos;
1533 infoPtr->flags |= TB_THUMBPOSCHANGED;
1534 }
1535 infoPtr->flags &= ~ (TB_REFRESH_TIMER_SET | TB_DRAGPOSVALID);
1536 hdc=GetDC (hwnd);
1537 TRACKBAR_Refresh (hwnd, hdc);
1538 ReleaseDC (hwnd, hdc);
1539 return 0;
1540 }
1541 return 1;
1542 }
1543
1544
1545 LRESULT WINAPI
1546 TRACKBAR_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1547 {
1548 switch (uMsg)
1549 {
1550 case TBM_CLEARSEL:
1551 return TRACKBAR_ClearSel (hwnd, wParam, lParam);
1552
1553 case TBM_CLEARTICS:
1554 return TRACKBAR_ClearTics (hwnd, wParam, lParam);
1555
1556 case TBM_GETBUDDY:
1557 return TRACKBAR_GetBuddy (hwnd, wParam, lParam);
1558
1559 case TBM_GETCHANNELRECT:
1560 return TRACKBAR_GetChannelRect (hwnd, wParam, lParam);
1561
1562 case TBM_GETLINESIZE:
1563 return TRACKBAR_GetLineSize (hwnd, wParam, lParam);
1564
1565 case TBM_GETNUMTICS:
1566 return TRACKBAR_GetNumTics (hwnd, wParam, lParam);
1567
1568 case TBM_GETPAGESIZE:
1569 return TRACKBAR_GetPageSize (hwnd, wParam, lParam);
1570
1571 case TBM_GETPOS:
1572 return TRACKBAR_GetPos (hwnd, wParam, lParam);
1573
1574 case TBM_GETPTICS:
1575 return TRACKBAR_GetPTics (hwnd);
1576
1577 case TBM_GETRANGEMAX:
1578 return TRACKBAR_GetRangeMax (hwnd, wParam, lParam);
1579
1580 case TBM_GETRANGEMIN:
1581 return TRACKBAR_GetRangeMin (hwnd, wParam, lParam);
1582
1583 case TBM_GETSELEND:
1584 return TRACKBAR_GetSelEnd (hwnd, wParam, lParam);
1585
1586 case TBM_GETSELSTART:
1587 return TRACKBAR_GetSelStart (hwnd, wParam, lParam);
1588
1589 case TBM_GETTHUMBLENGTH:
1590 return TRACKBAR_GetThumbLength (hwnd, wParam, lParam);
1591
1592 case TBM_GETTHUMBRECT:
1593 return TRACKBAR_GetThumbRect (hwnd, wParam, lParam);
1594
1595 case TBM_GETTIC:
1596 return TRACKBAR_GetTic (hwnd, wParam, lParam);
1597
1598 case TBM_GETTICPOS:
1599 return TRACKBAR_GetTicPos (hwnd, wParam, lParam);
1600
1601 case TBM_GETTOOLTIPS:
1602 return TRACKBAR_GetToolTips (hwnd, wParam, lParam);
1603
1604 /* case TBM_GETUNICODEFORMAT: */
1605
1606 case TBM_SETBUDDY:
1607 return TRACKBAR_SetBuddy (hwnd, wParam, lParam);
1608
1609 case TBM_SETLINESIZE:
1610 return TRACKBAR_SetLineSize (hwnd, wParam, lParam);
1611
1612 case TBM_SETPAGESIZE:
1613 return TRACKBAR_SetPageSize (hwnd, wParam, lParam);
1614
1615 case TBM_SETPOS:
1616 return TRACKBAR_SetPos (hwnd, wParam, lParam);
1617
1618 case TBM_SETRANGE:
1619 return TRACKBAR_SetRange (hwnd, wParam, lParam);
1620
1621 case TBM_SETRANGEMAX:
1622 return TRACKBAR_SetRangeMax (hwnd, wParam, lParam);
1623
1624 case TBM_SETRANGEMIN:
1625 return TRACKBAR_SetRangeMin (hwnd, wParam, lParam);
1626
1627 case TBM_SETSEL:
1628 return TRACKBAR_SetSel (hwnd, wParam, lParam);
1629
1630 case TBM_SETSELEND:
1631 return TRACKBAR_SetSelEnd (hwnd, wParam, lParam);
1632
1633 case TBM_SETSELSTART:
1634 return TRACKBAR_SetSelStart (hwnd, wParam, lParam);
1635
1636 case TBM_SETTHUMBLENGTH:
1637 return TRACKBAR_SetThumbLength (hwnd, wParam, lParam);
1638
1639 case TBM_SETTIC:
1640 return TRACKBAR_SetTic (hwnd, wParam, lParam);
1641
1642 case TBM_SETTICFREQ:
1643 return TRACKBAR_SetTicFreq (hwnd, wParam);
1644
1645 case TBM_SETTIPSIDE:
1646 return TRACKBAR_SetTipSide (hwnd, wParam, lParam);
1647
1648 case TBM_SETTOOLTIPS:
1649 return TRACKBAR_SetToolTips (hwnd, wParam, lParam);
1650
1651 /* case TBM_SETUNICODEFORMAT: */
1652
1653
1654 case WM_CAPTURECHANGED:
1655 return TRACKBAR_CaptureChanged (hwnd, wParam, lParam);
1656
1657 case WM_CREATE:
1658 return TRACKBAR_Create (hwnd, wParam, lParam);
1659
1660 case WM_DESTROY:
1661 return TRACKBAR_Destroy (hwnd, wParam, lParam);
1662
1663 /* case WM_ENABLE: */
1664
1665 /* case WM_ERASEBKGND: */
1666 /* return 0; */
1667
1668 case WM_GETDLGCODE:
1669 return DLGC_WANTARROWS;
1670
1671 case WM_KEYDOWN:
1672 return TRACKBAR_KeyDown (hwnd, wParam, lParam);
1673
1674 case WM_KEYUP:
1675 return TRACKBAR_KeyUp (hwnd, wParam);
1676
1677 case WM_KILLFOCUS:
1678 return TRACKBAR_KillFocus (hwnd, wParam, lParam);
1679
1680 case WM_LBUTTONDOWN:
1681 return TRACKBAR_LButtonDown (hwnd, wParam, lParam);
1682
1683 case WM_LBUTTONUP:
1684 return TRACKBAR_LButtonUp (hwnd, wParam, lParam);
1685
1686 case WM_MOUSEMOVE:
1687 return TRACKBAR_MouseMove (hwnd, wParam, lParam);
1688
1689 case WM_PAINT:
1690 return TRACKBAR_Paint (hwnd, wParam);
1691
1692 case WM_SETFOCUS:
1693 return TRACKBAR_SetFocus (hwnd, wParam, lParam);
1694
1695 case WM_SIZE:
1696 return TRACKBAR_Size (hwnd, wParam, lParam);
1697
1698 case WM_TIMER:
1699 return TRACKBAR_HandleTimer (hwnd, wParam, lParam);
1700
1701 case WM_WININICHANGE:
1702 return TRACKBAR_InitializeThumb (hwnd);
1703
1704 default:
1705 if (uMsg >= WM_USER)
1706 ERR (trackbar, "unknown msg %04x wp=%08x lp=%08lx\n",
1707 uMsg, wParam, lParam);
1708 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1709 }
1710 return 0;
1711 }
1712
1713
1714 VOID
1715 TRACKBAR_Register (VOID)
1716 {
1717 WNDCLASSA wndClass;
1718
1719 if (GlobalFindAtomA (TRACKBAR_CLASSA)) return;
1720
1721 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1722 wndClass.style = CS_GLOBALCLASS;
1723 wndClass.lpfnWndProc = (WNDPROC)TRACKBAR_WindowProc;
1724 wndClass.cbClsExtra = 0;
1725 wndClass.cbWndExtra = sizeof(TRACKBAR_INFO *);
1726 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
1727 wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
1728 wndClass.lpszClassName = TRACKBAR_CLASSA;
1729
1730 RegisterClassA (&wndClass);
1731 }
1732
1733
1734 VOID
1735 TRACKBAR_Unregister (VOID)
1736 {
1737 if (GlobalFindAtomA (TRACKBAR_CLASSA))
1738 UnregisterClassA (TRACKBAR_CLASSA, (HINSTANCE)NULL);
1739 }
1740
useful hacks and other patches not (yet) suitable for mainline