source: trunk/src/comctl32/trackbar.c@ 21661

Last change on this file since 21661 was 10098, checked in by sandervl, 22 years ago

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