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

Last change on this file since 9370 was 9370, checked in by sandervl, 23 years ago

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