reactos/dll/win32/comctl32/trackbar.c

   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "comctl32.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(trackbar);
  36
  37 typedef struct
  38 {
  39     HWND hwndSelf;
  40     DWORD dwStyle;
  41     LONG lRangeMin;
  42     LONG lRangeMax;
  43     LONG lLineSize;
  44     LONG lPageSize;
  45     LONG lSelMin;
  46     LONG lSelMax;
  47     LONG lPos;
  48     UINT uThumbLen;
  49     UINT uNumTics;
  50     UINT uTicFreq;
  51     HWND hwndNotify;
  52     HWND hwndToolTip;
  53     HWND hwndBuddyLA;
  54     HWND hwndBuddyRB;
  55     INT  fLocation;
  56     INT  flags;
  57     BOOL bUnicode;
  58     BOOL bFocussed;
  59     RECT rcChannel;
  60     RECT rcSelection;
  61     RECT rcThumb;
  62     LPLONG tics;
  63 } TRACKBAR_INFO;
  64
  65 #define TB_REFRESH_TIMER        1
  66 #define TB_REFRESH_DELAY        500
  67
  68 #define TOOLTIP_OFFSET          2     /* distance from ctrl edge to tooltip */
  69
  70 #define TB_DEFAULTPAGESIZE      20
  71
  72 /* Used by TRACKBAR_Refresh to find out which parts of the control
  73    need to be recalculated */
  74
  75 #define TB_THUMBPOSCHANGED      1
  76 #define TB_THUMBSIZECHANGED     2
  77 #define TB_THUMBCHANGED         (TB_THUMBPOSCHANGED | TB_THUMBSIZECHANGED)
  78 #define TB_SELECTIONCHANGED     4
  79 #define TB_DRAG_MODE            8     /* we're dragging the slider */
  80 #define TB_AUTO_PAGE_LEFT       16
  81 #define TB_AUTO_PAGE_RIGHT      32
  82 #define TB_AUTO_PAGE            (TB_AUTO_PAGE_LEFT | TB_AUTO_PAGE_RIGHT)
  83 #define TB_THUMB_HOT            64    /* mouse hovers above thumb */
  84
  85 /* helper defines for TRACKBAR_DrawTic */
  86 #define TIC_EDGE                0x20
  87 #define TIC_SELECTIONMARKMAX    0x80
  88 #define TIC_SELECTIONMARKMIN    0x100
  89 #define TIC_SELECTIONMARK       (TIC_SELECTIONMARKMAX | TIC_SELECTIONMARKMIN)
  90
  91 static const WCHAR themeClass[] = { 'T','r','a','c','k','b','a','r',0 };
  92
  93 static inline int
  94 notify_customdraw (const TRACKBAR_INFO *infoPtr, NMCUSTOMDRAW *pnmcd, int stage)
  95 {
  96     pnmcd->dwDrawStage = stage;
  97     return SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
  98                          pnmcd->hdr.idFrom, (LPARAM)pnmcd);
  99 }
 100
 101 static LRESULT notify_hdr (const TRACKBAR_INFO *infoPtr, INT code, LPNMHDR pnmh)
 102 {
 103     LRESULT result;
 104
 105     TRACE("(code=%d)\n", code);
 106
 107     pnmh->hwndFrom = infoPtr->hwndSelf;
 108     pnmh->idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
 109     pnmh->code = code;
 110     result = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, pnmh->idFrom, (LPARAM)pnmh);
 111
 112     TRACE("  <= %ld\n", result);
 113
 114     return result;
 115 }
 116
 117 static inline int notify (const TRACKBAR_INFO *infoPtr, INT code)
 118 {
 119     NMHDR nmh;
 120     return notify_hdr(infoPtr, code, &nmh);
 121 }
 122
 123 static void notify_with_scroll (const TRACKBAR_INFO *infoPtr, UINT code)
 124 {
 125     UINT scroll = infoPtr->dwStyle & TBS_VERT ? WM_VSCROLL : WM_HSCROLL;
 126
 127     TRACE("%x\n", code);
 128
 129     SendMessageW (infoPtr->hwndNotify, scroll, code, (LPARAM)infoPtr->hwndSelf);
 130 }
 131
 132 static void TRACKBAR_RecalculateTics (TRACKBAR_INFO *infoPtr)
 133 {
 134     int tic;
 135     unsigned nrTics, i;
 136
 137     if (infoPtr->uTicFreq && infoPtr->lRangeMax >= infoPtr->lRangeMin) {
 138         nrTics=(infoPtr->lRangeMax - infoPtr->lRangeMin)/infoPtr->uTicFreq;
 139         /* don't add extra tic if there's no remainder */
 140         if (nrTics && ((infoPtr->lRangeMax - infoPtr->lRangeMin) % infoPtr->uTicFreq == 0))
 141           nrTics--;
 142     }
 143     else {
 144         Free (infoPtr->tics);
 145         infoPtr->tics = NULL;
 146         infoPtr->uNumTics = 0;
 147         return;
 148     }
 149
 150     if (nrTics != infoPtr->uNumTics) {
 151         infoPtr->tics=ReAlloc (infoPtr->tics,
 152                                         (nrTics+1)*sizeof (DWORD));
 153         if (!infoPtr->tics) {
 154             infoPtr->uNumTics = 0;
 155             notify(infoPtr, NM_OUTOFMEMORY);
 156             return;
 157         }
 158         infoPtr->uNumTics = nrTics;
 159     }
 160
 161     tic = infoPtr->lRangeMin + infoPtr->uTicFreq;
 162     for (i = 0; i < nrTics; i++, tic += infoPtr->uTicFreq)
 163         infoPtr->tics[i] = tic;
 164 }
 165
 166 /* converts from physical (mouse) position to logical position
 167    (in range of trackbar) */
 168
 169 static inline LONG
 170 TRACKBAR_ConvertPlaceToPosition (const TRACKBAR_INFO *infoPtr, int place)
 171 {
 172     double range, width, pos, offsetthumb;
 173
 174     range = infoPtr->lRangeMax - infoPtr->lRangeMin;
 175     if (infoPtr->dwStyle & TBS_VERT) {
 176         offsetthumb = (infoPtr->rcThumb.bottom - infoPtr->rcThumb.top)/2;
 177         width = infoPtr->rcChannel.bottom - infoPtr->rcChannel.top - (offsetthumb * 2) - 1;
 178         pos = (range*(place - infoPtr->rcChannel.top - offsetthumb)) / width;
 179     } else {
 180         offsetthumb = (infoPtr->rcThumb.right - infoPtr->rcThumb.left)/2;
 181         width = infoPtr->rcChannel.right - infoPtr->rcChannel.left - (offsetthumb * 2) - 1;
 182         pos = (range*(place - infoPtr->rcChannel.left - offsetthumb)) / width;
 183     }
 184     pos += infoPtr->lRangeMin;
 185     if (pos > infoPtr->lRangeMax)
 186         pos = infoPtr->lRangeMax;
 187     else if (pos < infoPtr->lRangeMin)
 188         pos = infoPtr->lRangeMin;
 189
 190     TRACE("%.2f\n", pos);
 191     return (LONG)(pos + 0.5);
 192 }
 193
 194
 195 /* return: 0> prev, 0 none, >0 next */
 196 static LONG
 197 TRACKBAR_GetAutoPageDirection (const TRACKBAR_INFO *infoPtr, POINT clickPoint)
 198 {
 199     RECT pageRect;
 200
 201     if (infoPtr->dwStyle & TBS_VERT) {
 202         pageRect.top = infoPtr->rcChannel.top;
 203         pageRect.bottom = infoPtr->rcChannel.bottom;
 204         pageRect.left = infoPtr->rcThumb.left;
 205         pageRect.right = infoPtr->rcThumb.right;
 206     } else {
 207         pageRect.top = infoPtr->rcThumb.top;
 208         pageRect.bottom = infoPtr->rcThumb.bottom;
 209         pageRect.left = infoPtr->rcChannel.left;
 210         pageRect.right = infoPtr->rcChannel.right;
 211     }
 212
 213
 214     if (PtInRect(&pageRect, clickPoint))
 215     {
 216         int clickPlace = (infoPtr->dwStyle & TBS_VERT) ? clickPoint.y : clickPoint.x;
 217
 218         LONG clickPos = TRACKBAR_ConvertPlaceToPosition(infoPtr, clickPlace);
 219
 220         return clickPos - infoPtr->lPos;
 221     }
 222
 223     return 0;
 224 }
 225
 226 static inline void
 227 TRACKBAR_PageDown (TRACKBAR_INFO *infoPtr)
 228 {
 229     if (infoPtr->lPos == infoPtr->lRangeMax) return;
 230
 231     infoPtr->lPos += infoPtr->lPageSize;
 232     if (infoPtr->lPos > infoPtr->lRangeMax)
 233         infoPtr->lPos = infoPtr->lRangeMax;
 234     notify_with_scroll (infoPtr, TB_PAGEDOWN);
 235 }
 236
 237
 238 static inline void
 239 TRACKBAR_PageUp (TRACKBAR_INFO *infoPtr)
 240 {
 241     if (infoPtr->lPos == infoPtr->lRangeMin) return;
 242
 243     infoPtr->lPos -= infoPtr->lPageSize;
 244     if (infoPtr->lPos < infoPtr->lRangeMin)
 245         infoPtr->lPos = infoPtr->lRangeMin;
 246     notify_with_scroll (infoPtr, TB_PAGEUP);
 247 }
 248
 249 static inline void TRACKBAR_LineUp(TRACKBAR_INFO *infoPtr)
 250 {
 251     if (infoPtr->lPos == infoPtr->lRangeMin) return;
 252     infoPtr->lPos -= infoPtr->lLineSize;
 253     if (infoPtr->lPos < infoPtr->lRangeMin)
 254         infoPtr->lPos = infoPtr->lRangeMin;
 255     notify_with_scroll (infoPtr, TB_LINEUP);
 256 }
 257
 258 static inline void TRACKBAR_LineDown(TRACKBAR_INFO *infoPtr)
 259 {
 260     if (infoPtr->lPos == infoPtr->lRangeMax) return;
 261     infoPtr->lPos += infoPtr->lLineSize;
 262     if (infoPtr->lPos > infoPtr->lRangeMax)
 263         infoPtr->lPos = infoPtr->lRangeMax;
 264     notify_with_scroll (infoPtr, TB_LINEDOWN);
 265 }
 266
 267 static void
 268 TRACKBAR_CalcChannel (TRACKBAR_INFO *infoPtr)
 269 {
 270     INT cyChannel, offsetthumb, offsetedge;
 271     RECT lpRect, *channel = & infoPtr->rcChannel;
 272
 273     GetClientRect (infoPtr->hwndSelf, &lpRect);
 274
 275     offsetthumb = infoPtr->uThumbLen / 4;
 276     offsetedge  = offsetthumb + 3;
 277     cyChannel   = (infoPtr->dwStyle & TBS_ENABLESELRANGE) ? offsetthumb*3 : 4;
 278     if (infoPtr->dwStyle & TBS_VERT) {
 279         channel->top    = lpRect.top + offsetedge;
 280         channel->bottom = lpRect.bottom - offsetedge;
 281         if (infoPtr->dwStyle & TBS_ENABLESELRANGE)
 282             channel->left = lpRect.left + ((infoPtr->uThumbLen - cyChannel + 2) / 2);
 283         else
 284             channel->left = lpRect.left + (infoPtr->uThumbLen / 2) - 1;
 285         if (infoPtr->dwStyle & TBS_BOTH) {
 286             if (infoPtr->dwStyle & TBS_NOTICKS)
 287                 channel->left += 1;
 288             else
 289                 channel->left += 9;
 290         }
 291         else if (infoPtr->dwStyle & TBS_TOP) {
 292             if (infoPtr->dwStyle & TBS_NOTICKS)
 293                 channel->left += 2;
 294             else
 295                 channel->left += 10;
 296         }
 297         channel->right = channel->left + cyChannel;
 298     } else {
 299         channel->left = lpRect.left + offsetedge;
 300         channel->right = lpRect.right - offsetedge;
 301         if (infoPtr->dwStyle & TBS_ENABLESELRANGE)
 302             channel->top = lpRect.top + ((infoPtr->uThumbLen - cyChannel + 2) / 2);
 303         else
 304             channel->top = lpRect.top + (infoPtr->uThumbLen / 2) - 1;
 305         if (infoPtr->dwStyle & TBS_BOTH) {
 306             if (infoPtr->dwStyle & TBS_NOTICKS)
 307                 channel->top += 1;
 308             else
 309                 channel->top += 9;
 310         }
 311         else if (infoPtr->dwStyle & TBS_TOP) {
 312             if (infoPtr->dwStyle & TBS_NOTICKS)
 313                 channel->top += 2;
 314             else
 315                 channel->top += 10;
 316         }
 317         channel->bottom   = channel->top + cyChannel;
 318     }
 319 }
 320
 321 static void
 322 TRACKBAR_CalcThumb (const TRACKBAR_INFO *infoPtr, LONG lPos, RECT *thumb)
 323 {
 324     int range, width, height, thumbwidth;
 325     RECT lpRect;
 326
 327     range = infoPtr->lRangeMax - infoPtr->lRangeMin;
 328     thumbwidth = (infoPtr->uThumbLen / 2) | 1;
 329
 330     if (!range) range = 1;
 331
 332     GetClientRect(infoPtr->hwndSelf, &lpRect);
 333     if (infoPtr->dwStyle & TBS_VERT)
 334     {
 335         height = infoPtr->rcChannel.bottom - infoPtr->rcChannel.top - thumbwidth;
 336
 337         if ((infoPtr->dwStyle & (TBS_BOTH | TBS_LEFT)) && !(infoPtr->dwStyle & TBS_NOTICKS))
 338             thumb->left = 10;
 339         else
 340             thumb->left = 2;
 341         thumb->right = thumb->left + infoPtr->uThumbLen;
 342         thumb->top = infoPtr->rcChannel.top +
 343                      (height*(lPos - infoPtr->lRangeMin))/range;
 344         thumb->bottom = thumb->top + thumbwidth;
 345     }
 346     else
 347     {
 348         width = infoPtr->rcChannel.right - infoPtr->rcChannel.left - thumbwidth;
 349
 350         thumb->left = infoPtr->rcChannel.left +
 351                       (width*(lPos - infoPtr->lRangeMin))/range;
 352         thumb->right = thumb->left + thumbwidth;
 353         if ((infoPtr->dwStyle & (TBS_BOTH | TBS_TOP)) && !(infoPtr->dwStyle & TBS_NOTICKS))
 354             thumb->top = 10;
 355         else
 356             thumb->top = 2;
 357         thumb->bottom = thumb->top + infoPtr->uThumbLen;
 358     }
 359 }
 360
 361 static inline void
 362 TRACKBAR_UpdateThumb (TRACKBAR_INFO *infoPtr)
 363 {
 364     TRACKBAR_CalcThumb(infoPtr, infoPtr->lPos, &infoPtr->rcThumb);
 365 }
 366
 367 static inline void
 368 TRACKBAR_InvalidateAll (const TRACKBAR_INFO *infoPtr)
 369 {
 370     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
 371 }
 372
 373 static void
 374 TRACKBAR_InvalidateThumb (const TRACKBAR_INFO *infoPtr, LONG thumbPos)
 375 {
 376     RECT rcThumb;
 377
 378     TRACKBAR_CalcThumb(infoPtr, thumbPos, &rcThumb);
 379     InflateRect(&rcThumb, 1, 1);
 380     InvalidateRect(infoPtr->hwndSelf, &rcThumb, FALSE);
 381 }
 382
 383 static inline void
 384 TRACKBAR_InvalidateThumbMove (const TRACKBAR_INFO *infoPtr, LONG oldPos, LONG newPos)
 385 {
 386     TRACKBAR_InvalidateThumb (infoPtr, oldPos);
 387     if (newPos != oldPos)
 388         TRACKBAR_InvalidateThumb (infoPtr, newPos);
 389 }
 390
 391 static inline BOOL
 392 TRACKBAR_HasSelection (const TRACKBAR_INFO *infoPtr)
 393 {
 394     return infoPtr->lSelMin != infoPtr->lSelMax;
 395 }
 396
 397 static void
 398 TRACKBAR_CalcSelection (TRACKBAR_INFO *infoPtr)
 399 {
 400     RECT *selection = &infoPtr->rcSelection;
 401     int range = infoPtr->lRangeMax - infoPtr->lRangeMin;
 402     int offsetthumb, height, width;
 403
 404     if (range <= 0) {
 405         SetRectEmpty (selection);
 406     } else {
 407         if (infoPtr->dwStyle & TBS_VERT) {
 408             offsetthumb = (infoPtr->rcThumb.bottom - infoPtr->rcThumb.top)/2;
 409             height = infoPtr->rcChannel.bottom - infoPtr->rcChannel.top - offsetthumb*2;
 410             selection->top    = infoPtr->rcChannel.top + offsetthumb +
 411                 (height*infoPtr->lSelMin)/range;
 412             selection->bottom = infoPtr->rcChannel.top + offsetthumb +
 413                 (height*infoPtr->lSelMax)/range;
 414             selection->left   = infoPtr->rcChannel.left + 3;
 415             selection->right  = infoPtr->rcChannel.right - 3;
 416         } else {
 417             offsetthumb = (infoPtr->rcThumb.right - infoPtr->rcThumb.left)/2;
 418             width = infoPtr->rcChannel.right - infoPtr->rcChannel.left - offsetthumb*2;
 419             selection->left   = infoPtr->rcChannel.left + offsetthumb +
 420                 (width*infoPtr->lSelMin)/range;
 421             selection->right  = infoPtr->rcChannel.left + offsetthumb +
 422                 (width*infoPtr->lSelMax)/range;
 423             selection->top    = infoPtr->rcChannel.top + 3;
 424             selection->bottom = infoPtr->rcChannel.bottom - 3;
 425         }
 426     }
 427
 428     TRACE("selection[%s]\n", wine_dbgstr_rect(selection));
 429 }
 430
 431 static BOOL
 432 TRACKBAR_AutoPage (TRACKBAR_INFO *infoPtr, POINT clickPoint)
 433 {
 434     LONG dir = TRACKBAR_GetAutoPageDirection(infoPtr, clickPoint);
 435     LONG prevPos = infoPtr->lPos;
 436
 437     TRACE("x=%d, y=%d, dir=%d\n", clickPoint.x, clickPoint.y, dir);
 438
 439     if (dir > 0 && (infoPtr->flags & TB_AUTO_PAGE_RIGHT))
 440         TRACKBAR_PageDown(infoPtr);
 441     else if (dir < 0 && (infoPtr->flags & TB_AUTO_PAGE_LEFT))
 442         TRACKBAR_PageUp(infoPtr);
 443     else return FALSE;
 444
 445     TRACKBAR_UpdateThumb (infoPtr);
 446     TRACKBAR_InvalidateThumbMove (infoPtr, prevPos, infoPtr->lPos);
 447
 448     return TRUE;
 449 }
 450
 451 /* Trackbar drawing code. I like my spaghetti done milanese.  */
 452
 453 static void
 454 TRACKBAR_DrawChannel (const TRACKBAR_INFO *infoPtr, HDC hdc)
 455 {
 456     RECT rcChannel = infoPtr->rcChannel;
 457     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
 458
 459     if (theme)
 460     {
 461         DrawThemeBackground (theme, hdc,
 462             (infoPtr->dwStyle & TBS_VERT) ?
 463                 TKP_TRACKVERT : TKP_TRACK, TKS_NORMAL, &rcChannel, 0);
 464     }
 465     else
 466     {
 467         DrawEdge (hdc, &rcChannel, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
 468         if (infoPtr->dwStyle & TBS_ENABLESELRANGE) {             /* fill the channel */
 469             FillRect (hdc, &rcChannel, GetStockObject(WHITE_BRUSH));
 470             if (TRACKBAR_HasSelection(infoPtr))
 471                 FillRect (hdc, &infoPtr->rcSelection, GetSysColorBrush(COLOR_HIGHLIGHT));
 472         }
 473     }
 474 }
 475
 476 static void
 477 TRACKBAR_DrawOneTic (const TRACKBAR_INFO *infoPtr, HDC hdc, LONG ticPos, int flags)
 478 {
 479     int x, y, ox, oy, range, side, indent = 0, len = 3;
 480     int offsetthumb;
 481     RECT rcTics;
 482
 483     if (flags & TBS_VERT) {
 484         offsetthumb = (infoPtr->rcThumb.bottom - infoPtr->rcThumb.top)/2;
 485         rcTics.left = infoPtr->rcThumb.left - 2;
 486         rcTics.right = infoPtr->rcThumb.right + 2;
 487         rcTics.top    = infoPtr->rcChannel.top + offsetthumb;
 488         rcTics.bottom = infoPtr->rcChannel.bottom - offsetthumb - 1;
 489     } else {
 490         offsetthumb = (infoPtr->rcThumb.right - infoPtr->rcThumb.left)/2;
 491         rcTics.left   = infoPtr->rcChannel.left + offsetthumb;
 492         rcTics.right  = infoPtr->rcChannel.right - offsetthumb - 1;
 493         rcTics.top = infoPtr->rcThumb.top - 2;
 494         rcTics.bottom = infoPtr->rcThumb.bottom + 2;
 495     }
 496
 497     if (flags & (TBS_TOP | TBS_LEFT)) {
 498         x = rcTics.left;
 499         y = rcTics.top;
 500         side = -1;
 501     } else {
 502         x = rcTics.right;
 503         y = rcTics.bottom;
 504         side = 1;
 505     }
 506
 507     range = infoPtr->lRangeMax - infoPtr->lRangeMin;
 508     if (range <= 0)
 509       range = 1; /* to avoid division by zero */
 510
 511     if (flags & TIC_SELECTIONMARK) {
 512         indent = (flags & TIC_SELECTIONMARKMIN) ? -1 : 1;
 513     } else if (flags & TIC_EDGE) {
 514         len++;
 515     }
 516
 517     if (flags & TBS_VERT) {
 518         int height = rcTics.bottom - rcTics.top;
 519         y = rcTics.top + (height*(ticPos - infoPtr->lRangeMin))/range;
 520     } else {
 521         int width = rcTics.right - rcTics.left;
 522         x = rcTics.left + (width*(ticPos - infoPtr->lRangeMin))/range;
 523     }
 524
 525     ox = x;
 526     oy = y;
 527     MoveToEx(hdc, x, y, 0);
 528     if (flags & TBS_VERT) x += len * side;
 529     else y += len * side;
 530     LineTo(hdc, x, y);
 531
 532     if (flags & TIC_SELECTIONMARK) {
 533         if (flags & TBS_VERT) {
 534             x -= side;
 535         } else {
 536             y -= side;
 537         }
 538         MoveToEx(hdc, x, y, 0);
 539         if (flags & TBS_VERT) {
 540             y += 2 * indent;
 541         } else {
 542             x += 2 * indent;
 543         }
 544
 545         LineTo(hdc, x, y);
 546         LineTo(hdc, ox, oy);
 547     }
 548 }
 549
 550
 551 static inline void
 552 TRACKBAR_DrawTic (const TRACKBAR_INFO *infoPtr, HDC hdc, LONG ticPos, int flags)
 553 {
 554     if ((flags & (TBS_LEFT | TBS_TOP)) || (flags & TBS_BOTH))
 555         TRACKBAR_DrawOneTic (infoPtr, hdc, ticPos, flags | TBS_LEFT);
 556
 557     if (!(flags & (TBS_LEFT | TBS_TOP)) || (flags & TBS_BOTH))
 558         TRACKBAR_DrawOneTic (infoPtr, hdc, ticPos, flags & ~TBS_LEFT);
 559 }
 560
 561 static void
 562 TRACKBAR_DrawTics (const TRACKBAR_INFO *infoPtr, HDC hdc)
 563 {
 564     unsigned int i;
 565     int ticFlags = infoPtr->dwStyle & 0x0f;
 566     LOGPEN ticPen = { PS_SOLID, {1, 0}, GetSysColor (COLOR_3DDKSHADOW) };
 567     HPEN hOldPen, hTicPen;
 568     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
 569
 570     if (theme)
 571     {
 572         int part = (infoPtr->dwStyle & TBS_VERT) ? TKP_TICSVERT : TKP_TICS;
 573         GetThemeColor (theme, part, TSS_NORMAL, TMT_COLOR, &ticPen.lopnColor);
 574     }
 575     /* create the pen to draw the tics with */
 576     hTicPen = CreatePenIndirect(&ticPen);
 577     hOldPen = hTicPen ? SelectObject(hdc, hTicPen) : 0;
 578
 579     /* actually draw the tics */
 580     for (i=0; i<infoPtr->uNumTics; i++)
 581         TRACKBAR_DrawTic (infoPtr, hdc, infoPtr->tics[i], ticFlags);
 582
 583     TRACKBAR_DrawTic (infoPtr, hdc, infoPtr->lRangeMin, ticFlags | TIC_EDGE);
 584     TRACKBAR_DrawTic (infoPtr, hdc, infoPtr->lRangeMax, ticFlags | TIC_EDGE);
 585
 586     if ((infoPtr->dwStyle & TBS_ENABLESELRANGE) && TRACKBAR_HasSelection(infoPtr)) {
 587         TRACKBAR_DrawTic (infoPtr, hdc, infoPtr->lSelMin,
 588                           ticFlags | TIC_SELECTIONMARKMIN);
 589         TRACKBAR_DrawTic (infoPtr, hdc, infoPtr->lSelMax,
 590                           ticFlags | TIC_SELECTIONMARKMAX);
 591     }
 592
 593     /* clean up the pen, if we created one */
 594     if (hTicPen) {
 595         SelectObject(hdc, hOldPen);
 596         DeleteObject(hTicPen);
 597     }
 598 }
 599
 600 static int
 601 TRACKBAR_FillThumb (const TRACKBAR_INFO *infoPtr, HDC hdc, HBRUSH hbrush)
 602 {
 603     const RECT *thumb = &infoPtr->rcThumb;
 604     POINT points[6];
 605     int PointDepth;
 606     HBRUSH oldbr;
 607
 608     if (infoPtr->dwStyle & TBS_BOTH)
 609     {
 610         FillRect(hdc, thumb, hbrush);
 611         return 0;
 612     }
 613
 614     if (infoPtr->dwStyle & TBS_VERT)
 615     {
 616         PointDepth = (thumb->bottom - thumb->top) / 2;
 617         if (infoPtr->dwStyle & TBS_LEFT)
 618         {
 619             points[0].x = thumb->right-1;
 620             points[0].y = thumb->top;
 621             points[1].x = thumb->right-1;
 622             points[1].y = thumb->bottom-1;
 623             points[2].x = thumb->left + PointDepth;
 624             points[2].y = thumb->bottom-1;
 625             points[3].x = thumb->left;
 626             points[3].y = thumb->top + PointDepth;
 627             points[4].x = thumb->left + PointDepth;
 628             points[4].y = thumb->top;
 629             points[5].x = points[0].x;
 630             points[5].y = points[0].y;
 631         }
 632         else
 633         {
 634             points[0].x = thumb->right;
 635             points[0].y = thumb->top + PointDepth;
 636             points[1].x = thumb->right - PointDepth;
 637             points[1].y = thumb->bottom-1;
 638             points[2].x = thumb->left;
 639             points[2].y = thumb->bottom-1;
 640             points[3].x = thumb->left;
 641             points[3].y = thumb->top;
 642             points[4].x = thumb->right - PointDepth;
 643             points[4].y = thumb->top;
 644             points[5].x = points[0].x;
 645             points[5].y = points[0].y;
 646         }
 647     }
 648     else
 649     {
 650         PointDepth = (thumb->right - thumb->left) / 2;
 651         if (infoPtr->dwStyle & TBS_TOP)
 652         {
 653             points[0].x = thumb->left + PointDepth;
 654             points[0].y = thumb->top+1;
 655             points[1].x = thumb->right-1;
 656             points[1].y = thumb->top + PointDepth + 1;
 657             points[2].x = thumb->right-1;
 658             points[2].y = thumb->bottom-1;
 659             points[3].x = thumb->left;
 660             points[3].y = thumb->bottom-1;
 661             points[4].x = thumb->left;
 662             points[4].y = thumb->top + PointDepth + 1;
 663             points[5].x = points[0].x;
 664             points[5].y = points[0].y;
 665         }
 666         else
 667         {
 668             points[0].x = thumb->right-1;
 669             points[0].y = thumb->top;
 670             points[1].x = thumb->right-1;
 671             points[1].y = thumb->bottom - PointDepth - 1;
 672             points[2].x = thumb->left + PointDepth;
 673             points[2].y = thumb->bottom-1;
 674             points[3].x = thumb->left;
 675             points[3].y = thumb->bottom - PointDepth - 1;
 676             points[4].x = thumb->left;
 677             points[4].y = thumb->top;
 678             points[5].x = points[0].x;
 679             points[5].y = points[0].y;
 680         }
 681     }
 682
 683     oldbr = SelectObject(hdc, hbrush);
 684     SetPolyFillMode(hdc, WINDING);
 685     Polygon(hdc, points, sizeof(points) / sizeof(points[0]));
 686     SelectObject(hdc, oldbr);
 687
 688     return PointDepth;
 689 }
 690
 691 static void
 692 TRACKBAR_DrawThumb (TRACKBAR_INFO *infoPtr, HDC hdc)
 693 {
 694     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
 695     int PointDepth;
 696     HBRUSH brush;
 697
 698     if (theme)
 699     {
 700         int partId;
 701         int stateId;
 702         if (infoPtr->dwStyle & TBS_BOTH)
 703             partId = (infoPtr->dwStyle & TBS_VERT) ? TKP_THUMBVERT : TKP_THUMB;
 704         else if (infoPtr->dwStyle & TBS_LEFT)
 705             partId = (infoPtr->dwStyle & TBS_VERT) ? TKP_THUMBLEFT : TKP_THUMBTOP;
 706         else
 707             partId = (infoPtr->dwStyle & TBS_VERT) ? TKP_THUMBRIGHT : TKP_THUMBBOTTOM;
 708
 709         if (infoPtr->dwStyle & WS_DISABLED)
 710             stateId = TUS_DISABLED;
 711         else if (infoPtr->flags & TB_DRAG_MODE)
 712             stateId = TUS_PRESSED;
 713         else if (infoPtr->flags & TB_THUMB_HOT)
 714             stateId = TUS_HOT;
 715         else
 716             stateId = TUS_NORMAL;
 717
 718         DrawThemeBackground (theme, hdc, partId, stateId, &infoPtr->rcThumb, NULL);
 719
 720         return;
 721     }
 722
 723     if (infoPtr->dwStyle & WS_DISABLED || infoPtr->flags & TB_DRAG_MODE)
 724     {
 725         if (comctl32_color.clr3dHilight == comctl32_color.clrWindow)
 726             brush = COMCTL32_hPattern55AABrush;
 727         else
 728             brush = GetSysColorBrush(COLOR_SCROLLBAR);
 729
 730         SetTextColor(hdc, comctl32_color.clr3dFace);
 731         SetBkColor(hdc, comctl32_color.clr3dHilight);
 732     }
 733     else
 734         brush = GetSysColorBrush(COLOR_BTNFACE);
 735
 736     PointDepth = TRACKBAR_FillThumb(infoPtr, hdc, brush);
 737
 738     if (infoPtr->dwStyle & TBS_BOTH)
 739     {
 740        DrawEdge(hdc, &infoPtr->rcThumb, EDGE_RAISED, BF_RECT | BF_SOFT);
 741        return;
 742     }
 743     else
 744     {
 745         RECT thumb = infoPtr->rcThumb;
 746
 747         if (infoPtr->dwStyle & TBS_VERT)
 748         {
 749           if (infoPtr->dwStyle & TBS_LEFT)
 750           {
 751             /* rectangular part */
 752             thumb.left += PointDepth;
 753             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_TOP | BF_RIGHT | BF_BOTTOM | BF_SOFT);
 754
 755             /* light edge */
 756             thumb.left -= PointDepth;
 757             thumb.right = thumb.left + PointDepth;
 758             thumb.bottom = infoPtr->rcThumb.top + PointDepth + 1;
 759             thumb.top = infoPtr->rcThumb.top;
 760             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDTOPRIGHT | BF_SOFT);
 761
 762             /* shadowed edge */
 763             thumb.top += PointDepth;
 764             thumb.bottom += PointDepth;
 765             DrawEdge(hdc, &thumb, EDGE_SUNKEN, BF_DIAGONAL_ENDTOPLEFT | BF_SOFT);
 766             return;
 767           }
 768           else
 769           {
 770             /* rectangular part */
 771             thumb.right -= PointDepth;
 772             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_TOP | BF_LEFT | BF_BOTTOM | BF_SOFT);
 773
 774             /* light edge */
 775             thumb.left = thumb.right;
 776             thumb.right += PointDepth + 1;
 777             thumb.bottom = infoPtr->rcThumb.top + PointDepth + 1;
 778             thumb.top = infoPtr->rcThumb.top;
 779             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDTOPLEFT | BF_SOFT);
 780
 781             /* shadowed edge */
 782             thumb.top += PointDepth;
 783             thumb.bottom += PointDepth;
 784             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT);
 785           }
 786         }
 787         else
 788         {
 789           if (infoPtr->dwStyle & TBS_TOP)
 790           {
 791             /* rectangular part */
 792             thumb.top += PointDepth;
 793             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_LEFT | BF_BOTTOM | BF_RIGHT | BF_SOFT);
 794
 795             /* light edge */
 796             thumb.left = infoPtr->rcThumb.left;
 797             thumb.right = thumb.left + PointDepth;
 798             thumb.bottom = infoPtr->rcThumb.top + PointDepth + 1;
 799             thumb.top -= PointDepth;
 800             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDTOPRIGHT | BF_SOFT);
 801
 802             /* shadowed edge */
 803             thumb.left += PointDepth;
 804             thumb.right += PointDepth;
 805             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDBOTTOMRIGHT | BF_SOFT);
 806           }
 807           else
 808           {
 809             /* rectangular part */
 810             thumb.bottom -= PointDepth;
 811             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_LEFT | BF_TOP | BF_RIGHT | BF_SOFT);
 812
 813             /* light edge */
 814             thumb.left = infoPtr->rcThumb.left;
 815             thumb.right = thumb.left + PointDepth;
 816             thumb.top = infoPtr->rcThumb.bottom - PointDepth - 1;
 817             thumb.bottom += PointDepth;
 818             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDTOPLEFT | BF_SOFT);
 819
 820             /* shadowed edge */
 821             thumb.left += PointDepth;
 822             thumb.right += PointDepth;
 823             DrawEdge(hdc, &thumb, EDGE_RAISED, BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT);
 824           }
 825         }
 826     }
 827 }
 828
 829
 830 static inline void
 831 TRACKBAR_ActivateToolTip (const TRACKBAR_INFO *infoPtr, BOOL fShow)
 832 {
 833     TTTOOLINFOW ti;
 834
 835     if (!infoPtr->hwndToolTip) return;
 836
 837     ZeroMemory(&ti, sizeof(ti));
 838     ti.cbSize = sizeof(ti);
 839     ti.hwnd   = infoPtr->hwndSelf;
 840
 841     SendMessageW (infoPtr->hwndToolTip, TTM_TRACKACTIVATE, fShow, (LPARAM)&ti);
 842 }
 843
 844
 845 static void
 846 TRACKBAR_UpdateToolTip (const TRACKBAR_INFO *infoPtr)
 847 {
 848     WCHAR buf[80];
 849     static const WCHAR fmt[] = { '%', 'l', 'd', 0 };
 850     TTTOOLINFOW ti;
 851     POINT pt;
 852     RECT rcClient;
 853     LRESULT size;
 854
 855     if (!infoPtr->hwndToolTip) return;
 856
 857     ZeroMemory(&ti, sizeof(ti));
 858     ti.cbSize = sizeof(ti);
 859     ti.hwnd   = infoPtr->hwndSelf;
 860     ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_ABSOLUTE;
 861
 862     wsprintfW (buf, fmt, infoPtr->lPos);
 863     ti.lpszText = buf;
 864     SendMessageW (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTW, 0, (LPARAM)&ti);
 865
 866     GetClientRect (infoPtr->hwndSelf, &rcClient);
 867     size = SendMessageW (infoPtr->hwndToolTip, TTM_GETBUBBLESIZE, 0, (LPARAM)&ti);
 868     if (infoPtr->dwStyle & TBS_VERT) {
 869         if (infoPtr->fLocation == TBTS_LEFT)
 870             pt.x = 0 - LOWORD(size) - TOOLTIP_OFFSET;
 871         else
 872             pt.x = rcClient.right + TOOLTIP_OFFSET;
 873         pt.y = (infoPtr->rcThumb.top + infoPtr->rcThumb.bottom - HIWORD(size))/2;
 874     } else {
 875         if (infoPtr->fLocation == TBTS_TOP)
 876             pt.y = 0 - HIWORD(size) - TOOLTIP_OFFSET;
 877         else
 878             pt.y = rcClient.bottom + TOOLTIP_OFFSET;
 879         pt.x = (infoPtr->rcThumb.left + infoPtr->rcThumb.right - LOWORD(size))/2;
 880     }
 881     ClientToScreen(infoPtr->hwndSelf, &pt);
 882
 883     SendMessageW (infoPtr->hwndToolTip, TTM_TRACKPOSITION,
 884                   0, MAKELPARAM(pt.x, pt.y));
 885 }
 886
 887
 888 static void
 889 TRACKBAR_Refresh (TRACKBAR_INFO *infoPtr, HDC hdcDst)
 890 {
 891     RECT rcClient;
 892     HDC hdc;
 893     HBITMAP hOldBmp = 0, hOffScreenBmp = 0;
 894     NMCUSTOMDRAW nmcd;
 895     int gcdrf, icdrf;
 896
 897     if (infoPtr->flags & TB_THUMBCHANGED) {
 898         TRACKBAR_UpdateThumb (infoPtr);
 899         if (infoPtr->flags & TB_THUMBSIZECHANGED)
 900             TRACKBAR_CalcChannel (infoPtr);
 901     }
 902     if (infoPtr->flags & TB_SELECTIONCHANGED)
 903         TRACKBAR_CalcSelection (infoPtr);
 904
 905     if (infoPtr->flags & TB_DRAG_MODE)
 906         TRACKBAR_UpdateToolTip (infoPtr);
 907
 908     infoPtr->flags &= ~ (TB_THUMBCHANGED | TB_SELECTIONCHANGED);
 909
 910     GetClientRect (infoPtr->hwndSelf, &rcClient);
 911
 912     /* try to render offscreen, if we fail, carrry onscreen */
 913     hdc = CreateCompatibleDC(hdcDst);
 914     if (hdc) {
 915         hOffScreenBmp = CreateCompatibleBitmap(hdcDst, rcClient.right, rcClient.bottom);
 916         if (hOffScreenBmp) {
 917             hOldBmp = SelectObject(hdc, hOffScreenBmp);
 918         } else {
 919             DeleteObject(hdc);
 920             hdc = hdcDst;
 921         }
 922     } else {
 923         hdc = hdcDst;
 924     }
 925
 926     ZeroMemory(&nmcd, sizeof(nmcd));
 927     nmcd.hdr.hwndFrom = infoPtr->hwndSelf;
 928     nmcd.hdr.idFrom = GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_ID);
 929     nmcd.hdr.code = NM_CUSTOMDRAW;
 930     nmcd.hdc = hdc;
 931
 932     /* start the paint cycle */
 933     nmcd.rc = rcClient;
 934     gcdrf = notify_customdraw(infoPtr, &nmcd, CDDS_PREPAINT);
 935     if (gcdrf & CDRF_SKIPDEFAULT) goto cleanup;
 936
 937     /* Erase background */
 938     if (gcdrf == CDRF_DODEFAULT ||
 939         notify_customdraw(infoPtr, &nmcd, CDDS_PREERASE) != CDRF_SKIPDEFAULT) {
 940         if (GetWindowTheme (infoPtr->hwndSelf)) {
 941             DrawThemeParentBackground (infoPtr->hwndSelf, hdc, 0);
 942         }
 943         else
 944             FillRect (hdc, &rcClient, GetSysColorBrush(COLOR_BTNFACE));
 945         if (gcdrf != CDRF_DODEFAULT)
 946             notify_customdraw(infoPtr, &nmcd, CDDS_POSTERASE);
 947     }
 948
 949     /* draw channel */
 950     if (gcdrf & CDRF_NOTIFYITEMDRAW) {
 951         nmcd.dwItemSpec = TBCD_CHANNEL;
 952         nmcd.uItemState = CDIS_DEFAULT;
 953         nmcd.rc = infoPtr->rcChannel;
 954         icdrf = notify_customdraw(infoPtr, &nmcd, CDDS_ITEMPREPAINT);
 955     } else icdrf = CDRF_DODEFAULT;
 956     if ( !(icdrf & CDRF_SKIPDEFAULT) ) {
 957         TRACKBAR_DrawChannel (infoPtr, hdc);
 958         if (icdrf & CDRF_NOTIFYPOSTPAINT)
 959             notify_customdraw(infoPtr, &nmcd, CDDS_ITEMPOSTPAINT);
 960     }
 961
 962
 963     /* draw tics */
 964     if (!(infoPtr->dwStyle & TBS_NOTICKS)) {
 965         if (gcdrf & CDRF_NOTIFYITEMDRAW) {
 966             nmcd.dwItemSpec = TBCD_TICS;
 967             nmcd.uItemState = CDIS_DEFAULT;
 968             nmcd.rc = rcClient;
 969             icdrf = notify_customdraw(infoPtr, &nmcd, CDDS_ITEMPREPAINT);
 970         } else icdrf = CDRF_DODEFAULT;
 971         if ( !(icdrf & CDRF_SKIPDEFAULT) ) {
 972             TRACKBAR_DrawTics (infoPtr, hdc);
 973             if (icdrf & CDRF_NOTIFYPOSTPAINT)
 974                 notify_customdraw(infoPtr, &nmcd, CDDS_ITEMPOSTPAINT);
 975         }
 976     }
 977
 978     /* draw thumb */
 979     if (!(infoPtr->dwStyle & TBS_NOTHUMB)) {
 980         if (gcdrf & CDRF_NOTIFYITEMDRAW) {
 981             nmcd.dwItemSpec = TBCD_THUMB;
 982             nmcd.uItemState = infoPtr->flags & TB_DRAG_MODE ? CDIS_HOT : CDIS_DEFAULT;
 983             nmcd.rc = infoPtr->rcThumb;
 984             icdrf = notify_customdraw(infoPtr, &nmcd, CDDS_ITEMPREPAINT);
 985         } else icdrf = CDRF_DODEFAULT;
 986         if ( !(icdrf & CDRF_SKIPDEFAULT) ) {
 987             TRACKBAR_DrawThumb(infoPtr, hdc);
 988             if (icdrf & CDRF_NOTIFYPOSTPAINT)
 989                 notify_customdraw(infoPtr, &nmcd, CDDS_ITEMPOSTPAINT);
 990         }
 991     }
 992
 993     /* draw focus rectangle */
 994     if (infoPtr->bFocussed) {
 995         DrawFocusRect(hdc, &rcClient);
 996     }
 997
 998     /* finish up the painting */
 999     if (gcdrf & CDRF_NOTIFYPOSTPAINT)
1000         notify_customdraw(infoPtr, &nmcd, CDDS_POSTPAINT);
1001
1002 cleanup:
1003     /* cleanup, if we rendered offscreen */
1004     if (hdc != hdcDst) {
1005         BitBlt(hdcDst, 0, 0, rcClient.right, rcClient.bottom, hdc, 0, 0, SRCCOPY);
1006         SelectObject(hdc, hOldBmp);
1007         DeleteObject(hOffScreenBmp);
1008         DeleteObject(hdc);
1009     }
1010 }
1011
1012
1013 static void
1014 TRACKBAR_AlignBuddies (const TRACKBAR_INFO *infoPtr)
1015 {
1016     HWND hwndParent = GetParent (infoPtr->hwndSelf);
1017     RECT rcSelf, rcBuddy;
1018     INT x, y;
1019
1020     GetWindowRect (infoPtr->hwndSelf, &rcSelf);
1021     MapWindowPoints (HWND_DESKTOP, hwndParent, (LPPOINT)&rcSelf, 2);
1022
1023     /* align buddy left or above */
1024     if (infoPtr->hwndBuddyLA) {
1025         GetWindowRect (infoPtr->hwndBuddyLA, &rcBuddy);
1026         MapWindowPoints (HWND_DESKTOP, hwndParent, (LPPOINT)&rcBuddy, 2);
1027
1028         if (infoPtr->dwStyle & TBS_VERT) {
1029             x = (infoPtr->rcChannel.right + infoPtr->rcChannel.left) / 2 -
1030                 (rcBuddy.right - rcBuddy.left) / 2 + rcSelf.left;
1031             y = rcSelf.top - (rcBuddy.bottom - rcBuddy.top);
1032         }
1033         else {
1034             x = rcSelf.left - (rcBuddy.right - rcBuddy.left);
1035             y = (infoPtr->rcChannel.bottom + infoPtr->rcChannel.top) / 2 -
1036                 (rcBuddy.bottom - rcBuddy.top) / 2 + rcSelf.top;
1037         }
1038
1039         SetWindowPos (infoPtr->hwndBuddyLA, 0, x, y, 0, 0,
1040                       SWP_NOZORDER | SWP_NOSIZE);
1041     }
1042
1043
1044     /* align buddy right or below */
1045     if (infoPtr->hwndBuddyRB) {
1046         GetWindowRect (infoPtr->hwndBuddyRB, &rcBuddy);
1047         MapWindowPoints (HWND_DESKTOP, hwndParent, (LPPOINT)&rcBuddy, 2);
1048
1049         if (infoPtr->dwStyle & TBS_VERT) {
1050             x = (infoPtr->rcChannel.right + infoPtr->rcChannel.left) / 2 -
1051                 (rcBuddy.right - rcBuddy.left) / 2 + rcSelf.left;
1052             y = rcSelf.bottom;
1053         }
1054         else {
1055             x = rcSelf.right;
1056             y = (infoPtr->rcChannel.bottom + infoPtr->rcChannel.top) / 2 -
1057                 (rcBuddy.bottom - rcBuddy.top) / 2 + rcSelf.top;
1058         }
1059         SetWindowPos (infoPtr->hwndBuddyRB, 0, x, y, 0, 0,
1060                       SWP_NOZORDER | SWP_NOSIZE);
1061     }
1062 }
1063
1064
1065 static LRESULT
1066 TRACKBAR_ClearSel (TRACKBAR_INFO *infoPtr, BOOL fRedraw)
1067 {
1068     infoPtr->lSelMin = 0;
1069     infoPtr->lSelMax = 0;
1070     infoPtr->flags |= TB_SELECTIONCHANGED;
1071
1072     if (fRedraw) TRACKBAR_InvalidateAll(infoPtr);
1073
1074     return 0;
1075 }
1076
1077
1078 static LRESULT
1079 TRACKBAR_ClearTics (TRACKBAR_INFO *infoPtr, BOOL fRedraw)
1080 {
1081     if (infoPtr->tics) {
1082         Free (infoPtr->tics);
1083         infoPtr->tics = NULL;
1084         infoPtr->uNumTics = 0;
1085     }
1086
1087     if (fRedraw) TRACKBAR_InvalidateAll(infoPtr);
1088
1089     return 0;
1090 }
1091
1092
1093 static inline LRESULT
1094 TRACKBAR_GetChannelRect (const TRACKBAR_INFO *infoPtr, LPRECT lprc)
1095 {
1096     if (lprc == NULL) return 0;
1097
1098     lprc->left   = infoPtr->rcChannel.left;
1099     lprc->right  = infoPtr->rcChannel.right;
1100     lprc->bottom = infoPtr->rcChannel.bottom;
1101     lprc->top    = infoPtr->rcChannel.top;
1102
1103     return 0;
1104 }
1105
1106
1107 static inline LONG
1108 TRACKBAR_GetNumTics (const TRACKBAR_INFO *infoPtr)
1109 {
1110     if (infoPtr->dwStyle & TBS_NOTICKS) return 0;
1111
1112     return infoPtr->uNumTics + 2;
1113 }
1114
1115
1116 static int comp_tics (const void *ap, const void *bp)
1117 {
1118     const DWORD a = *(const DWORD *)ap;
1119     const DWORD b = *(const DWORD *)bp;
1120
1121     TRACE("(a=%d, b=%d)\n", a, b);
1122     if (a < b) return -1;
1123     if (a > b) return 1;
1124     return 0;
1125 }
1126
1127
1128 static inline LONG
1129 TRACKBAR_GetTic (const TRACKBAR_INFO *infoPtr, INT iTic)
1130 {
1131     if ((iTic < 0) || (iTic >= infoPtr->uNumTics) || !infoPtr->tics)
1132         return -1;
1133
1134     qsort(infoPtr->tics, infoPtr->uNumTics, sizeof(DWORD), comp_tics);
1135     return infoPtr->tics[iTic];
1136 }
1137
1138
1139 static inline LONG
1140 TRACKBAR_GetTicPos (const TRACKBAR_INFO *infoPtr, INT iTic)
1141 {
1142     LONG range, width, pos, tic;
1143     int offsetthumb;
1144
1145     if ((iTic < 0) || (iTic >= infoPtr->uNumTics) || !infoPtr->tics)
1146         return -1;
1147
1148     tic   = TRACKBAR_GetTic (infoPtr, iTic);
1149     range = infoPtr->lRangeMax - infoPtr->lRangeMin;
1150     if (range <= 0) range = 1;
1151     offsetthumb = (infoPtr->rcThumb.right - infoPtr->rcThumb.left)/2;
1152     width = infoPtr->rcChannel.right - infoPtr->rcChannel.left - offsetthumb*2;
1153     pos   = infoPtr->rcChannel.left + offsetthumb + (width * tic) / range;
1154
1155     return pos;
1156 }
1157
1158
1159 static HWND
1160 TRACKBAR_SetBuddy (TRACKBAR_INFO *infoPtr, BOOL fLocation, HWND hwndBuddy)
1161 {
1162     HWND hwndTemp;
1163
1164     if (fLocation) {
1165         /* buddy is left or above */
1166         hwndTemp = infoPtr->hwndBuddyLA;
1167         infoPtr->hwndBuddyLA = hwndBuddy;
1168     }
1169     else {
1170         /* buddy is right or below */
1171         hwndTemp = infoPtr->hwndBuddyRB;
1172         infoPtr->hwndBuddyRB = hwndBuddy;
1173     }
1174
1175     TRACKBAR_AlignBuddies (infoPtr);
1176
1177     return hwndTemp;
1178 }
1179
1180
1181 static inline LONG
1182 TRACKBAR_SetLineSize (TRACKBAR_INFO *infoPtr, LONG lLineSize)
1183 {
1184     LONG lTemp = infoPtr->lLineSize;
1185
1186     infoPtr->lLineSize = lLineSize;
1187
1188     return lTemp;
1189 }
1190
1191
1192 static inline LONG
1193 TRACKBAR_SetPageSize (TRACKBAR_INFO *infoPtr, LONG lPageSize)
1194 {
1195     LONG lTemp = infoPtr->lPageSize;
1196
1197     if (lPageSize != -1)
1198         infoPtr->lPageSize = lPageSize;
1199     else
1200         infoPtr->lPageSize = TB_DEFAULTPAGESIZE;
1201
1202     return lTemp;
1203 }
1204
1205
1206 static inline LRESULT
1207 TRACKBAR_SetPos (TRACKBAR_INFO *infoPtr, BOOL fPosition, LONG lPosition)
1208 {
1209     LONG oldPos = infoPtr->lPos;
1210     infoPtr->lPos = lPosition;
1211
1212     if (infoPtr->lPos < infoPtr->lRangeMin)
1213         infoPtr->lPos = infoPtr->lRangeMin;
1214
1215     if (infoPtr->lPos > infoPtr->lRangeMax)
1216         infoPtr->lPos = infoPtr->lRangeMax;
1217
1218     if (fPosition && oldPos != lPosition)
1219     {
1220         TRACKBAR_UpdateThumb(infoPtr);
1221         TRACKBAR_InvalidateThumbMove(infoPtr, oldPos, lPosition);
1222     }
1223
1224     return 0;
1225 }
1226
1227
1228 static inline LRESULT
1229 TRACKBAR_SetRange (TRACKBAR_INFO *infoPtr, BOOL redraw, LONG range)
1230 {
1231     BOOL changed = infoPtr->lRangeMin != (SHORT)LOWORD(range) ||
1232                    infoPtr->lRangeMax != (SHORT)HIWORD(range);
1233
1234     infoPtr->lRangeMin = (SHORT)LOWORD(range);
1235     infoPtr->lRangeMax = (SHORT)HIWORD(range);
1236
1237     if (infoPtr->lPos < infoPtr->lRangeMin) {
1238         infoPtr->lPos = infoPtr->lRangeMin;
1239         infoPtr->flags |= TB_THUMBPOSCHANGED;
1240     }
1241
1242     if (infoPtr->lPos > infoPtr->lRangeMax) {
1243         infoPtr->lPos = infoPtr->lRangeMax;
1244         infoPtr->flags |= TB_THUMBPOSCHANGED;
1245     }
1246
1247     infoPtr->lPageSize = (infoPtr->lRangeMax - infoPtr->lRangeMin) / 5;
1248     if (infoPtr->lPageSize == 0) infoPtr->lPageSize = 1;
1249
1250     if (changed && (infoPtr->dwStyle & TBS_AUTOTICKS))
1251         TRACKBAR_RecalculateTics (infoPtr);
1252
1253     if (redraw) TRACKBAR_InvalidateAll(infoPtr);
1254
1255     return 0;
1256 }
1257
1258
1259 static inline LRESULT
1260 TRACKBAR_SetRangeMax (TRACKBAR_INFO *infoPtr, BOOL redraw, LONG lMax)
1261 {
1262     BOOL changed = infoPtr->lRangeMax != lMax;
1263
1264     infoPtr->lRangeMax = lMax;
1265     if (infoPtr->lPos > infoPtr->lRangeMax) {
1266         infoPtr->lPos = infoPtr->lRangeMax;
1267         infoPtr->flags |= TB_THUMBPOSCHANGED;
1268     }
1269
1270     infoPtr->lPageSize = (infoPtr->lRangeMax - infoPtr->lRangeMin) / 5;
1271     if (infoPtr->lPageSize == 0) infoPtr->lPageSize = 1;
1272
1273     if (changed && (infoPtr->dwStyle & TBS_AUTOTICKS))
1274         TRACKBAR_RecalculateTics (infoPtr);
1275
1276     if (redraw) TRACKBAR_InvalidateAll(infoPtr);
1277
1278     return 0;
1279 }
1280
1281
1282 static inline LRESULT
1283 TRACKBAR_SetRangeMin (TRACKBAR_INFO *infoPtr, BOOL redraw, LONG lMin)
1284 {
1285     BOOL changed = infoPtr->lRangeMin != lMin;
1286
1287     infoPtr->lRangeMin = lMin;
1288     if (infoPtr->lPos < infoPtr->lRangeMin) {
1289         infoPtr->lPos = infoPtr->lRangeMin;
1290         infoPtr->flags |= TB_THUMBPOSCHANGED;
1291     }
1292
1293     infoPtr->lPageSize = (infoPtr->lRangeMax - infoPtr->lRangeMin) / 5;
1294     if (infoPtr->lPageSize == 0) infoPtr->lPageSize = 1;
1295
1296     if (changed && (infoPtr->dwStyle & TBS_AUTOTICKS))
1297         TRACKBAR_RecalculateTics (infoPtr);
1298
1299     if (redraw) TRACKBAR_InvalidateAll(infoPtr);
1300
1301     return 0;
1302 }
1303
1304
1305 static inline LRESULT
1306 TRACKBAR_SetSel (TRACKBAR_INFO *infoPtr, BOOL fRedraw, LONG lSel)
1307 {
1308     if (!(infoPtr->dwStyle & TBS_ENABLESELRANGE)){
1309         infoPtr->lSelMin = 0;
1310         infoPtr->lSelMax = 0;
1311         return 0;
1312     }
1313
1314     infoPtr->lSelMin = (SHORT)LOWORD(lSel);
1315     infoPtr->lSelMax = (SHORT)HIWORD(lSel);
1316     infoPtr->flags |= TB_SELECTIONCHANGED;
1317
1318     if (infoPtr->lSelMin < infoPtr->lRangeMin)
1319         infoPtr->lSelMin = infoPtr->lRangeMin;
1320     if (infoPtr->lSelMax > infoPtr->lRangeMax)
1321         infoPtr->lSelMax = infoPtr->lRangeMax;
1322
1323     if (fRedraw) TRACKBAR_InvalidateAll(infoPtr);
1324
1325     return 0;
1326 }
1327
1328
1329 static inline LRESULT
1330 TRACKBAR_SetSelEnd (TRACKBAR_INFO *infoPtr, BOOL fRedraw, LONG lEnd)
1331 {
1332     if (!(infoPtr->dwStyle & TBS_ENABLESELRANGE)){
1333         infoPtr->lSelMax = 0;
1334         return 0;
1335     }
1336
1337     infoPtr->lSelMax = lEnd;
1338     infoPtr->flags |= TB_SELECTIONCHANGED;
1339
1340     if (infoPtr->lSelMax > infoPtr->lRangeMax)
1341         infoPtr->lSelMax = infoPtr->lRangeMax;
1342
1343     if (fRedraw) TRACKBAR_InvalidateAll(infoPtr);
1344
1345     return 0;
1346 }
1347
1348
1349 static inline LRESULT
1350 TRACKBAR_SetSelStart (TRACKBAR_INFO *infoPtr, BOOL fRedraw, LONG lStart)
1351 {
1352     if (!(infoPtr->dwStyle & TBS_ENABLESELRANGE)){
1353         infoPtr->lSelMin = 0;
1354         return 0;
1355     }
1356
1357     infoPtr->lSelMin = lStart;
1358     infoPtr->flags  |=TB_SELECTIONCHANGED;
1359
1360     if (infoPtr->lSelMin < infoPtr->lRangeMin)
1361         infoPtr->lSelMin = infoPtr->lRangeMin;
1362
1363     if (fRedraw) TRACKBAR_InvalidateAll(infoPtr);
1364
1365     return 0;
1366 }
1367
1368
1369 static inline LRESULT
1370 TRACKBAR_SetThumbLength (TRACKBAR_INFO *infoPtr, UINT iLength)
1371 {
1372     if (infoPtr->dwStyle & TBS_FIXEDLENGTH) {
1373         /* We're not supposed to check if it's really changed or not,
1374            just repaint in any case. */
1375         infoPtr->uThumbLen = iLength;
1376         infoPtr->flags |= TB_THUMBSIZECHANGED;
1377         TRACKBAR_InvalidateAll(infoPtr);
1378     }
1379
1380     return 0;
1381 }
1382
1383
1384 static inline LRESULT
1385 TRACKBAR_SetTic (TRACKBAR_INFO *infoPtr, LONG lPos)
1386 {
1387     if ((lPos < infoPtr->lRangeMin) || (lPos> infoPtr->lRangeMax))
1388         return FALSE;
1389
1390     TRACE("lPos=%d\n", lPos);
1391
1392     infoPtr->uNumTics++;
1393     infoPtr->tics=ReAlloc( infoPtr->tics,
1394                                     (infoPtr->uNumTics)*sizeof (DWORD));
1395     if (!infoPtr->tics) {
1396         infoPtr->uNumTics = 0;
1397         notify(infoPtr, NM_OUTOFMEMORY);
1398         return FALSE;
1399     }
1400     infoPtr->tics[infoPtr->uNumTics-1] = lPos;
1401
1402     TRACKBAR_InvalidateAll(infoPtr);
1403
1404     return TRUE;
1405 }
1406
1407
1408 static inline LRESULT
1409 TRACKBAR_SetTicFreq (TRACKBAR_INFO *infoPtr, WORD wFreq)
1410 {
1411     if (infoPtr->dwStyle & TBS_AUTOTICKS) {
1412         infoPtr->uTicFreq = wFreq;
1413         TRACKBAR_RecalculateTics (infoPtr);
1414         TRACKBAR_InvalidateAll(infoPtr);
1415     }
1416
1417     return 0;
1418 }
1419
1420
1421 static inline INT
1422 TRACKBAR_SetTipSide (TRACKBAR_INFO *infoPtr, INT fLocation)
1423 {
1424     INT fTemp = infoPtr->fLocation;
1425
1426     infoPtr->fLocation = fLocation;
1427
1428     return fTemp;
1429 }
1430
1431
1432 static inline LRESULT
1433 TRACKBAR_SetToolTips (TRACKBAR_INFO *infoPtr, HWND hwndTT)
1434 {
1435     infoPtr->hwndToolTip = hwndTT;
1436
1437     return 0;
1438 }
1439
1440
1441 static inline BOOL
1442 TRACKBAR_SetUnicodeFormat (TRACKBAR_INFO *infoPtr, BOOL fUnicode)
1443 {
1444     BOOL bTemp = infoPtr->bUnicode;
1445
1446     infoPtr->bUnicode = fUnicode;
1447
1448     return bTemp;
1449 }
1450
1451
1452 static LRESULT
1453 TRACKBAR_InitializeThumb (TRACKBAR_INFO *infoPtr)
1454 {
1455     RECT rect;
1456     int clientWidth, clientMetric;
1457
1458     /* initial thumb length */
1459     clientMetric = (infoPtr->dwStyle & TBS_ENABLESELRANGE) ? 23 : 21;
1460     GetClientRect(infoPtr->hwndSelf,&rect);
1461     if (infoPtr->dwStyle & TBS_VERT) {
1462         clientWidth = rect.right - rect.left;
1463     } else {
1464         clientWidth = rect.bottom - rect.top;
1465     }
1466     if (clientWidth >= clientMetric)
1467         infoPtr->uThumbLen = clientMetric;
1468     else
1469         infoPtr->uThumbLen = clientWidth > 9 ? clientWidth - 6 : 4;
1470
1471     TRACKBAR_CalcChannel (infoPtr);
1472     TRACKBAR_UpdateThumb (infoPtr);
1473     infoPtr->flags &= ~TB_SELECTIONCHANGED;
1474
1475     return 0;
1476 }
1477
1478
1479 static LRESULT
1480 TRACKBAR_Create (HWND hwnd, const CREATESTRUCTW *lpcs)
1481 {
1482     TRACKBAR_INFO *infoPtr;
1483
1484     infoPtr = Alloc (sizeof(TRACKBAR_INFO));
1485     if (!infoPtr) return -1;
1486     SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1487
1488     /* set default values */
1489     infoPtr->hwndSelf  = hwnd;
1490     infoPtr->dwStyle   = lpcs->style;
1491     infoPtr->lRangeMin = 0;
1492     infoPtr->lRangeMax = 100;
1493     infoPtr->lLineSize = 1;
1494     infoPtr->lPageSize = TB_DEFAULTPAGESIZE;
1495     infoPtr->lSelMin   = 0;
1496     infoPtr->lSelMax   = 0;
1497     infoPtr->lPos      = 0;
1498     infoPtr->fLocation = TBTS_TOP;
1499     infoPtr->uNumTics  = 0;    /* start and end tic are not included in count*/
1500     infoPtr->uTicFreq  = 1;
1501     infoPtr->tics      = NULL;
1502     infoPtr->hwndNotify= lpcs->hwndParent;
1503
1504     TRACKBAR_InitializeThumb (infoPtr);
1505
1506     /* Create tooltip control */
1507     if (infoPtr->dwStyle & TBS_TOOLTIPS) {
1508
1509         infoPtr->hwndToolTip =
1510             CreateWindowExW (0, TOOLTIPS_CLASSW, NULL, WS_POPUP,
1511                              CW_USEDEFAULT, CW_USEDEFAULT,
1512                              CW_USEDEFAULT, CW_USEDEFAULT,
1513                              hwnd, 0, 0, 0);
1514
1515         if (infoPtr->hwndToolTip) {
1516             TTTOOLINFOW ti;
1517             WCHAR wEmpty = 0;
1518             ZeroMemory (&ti, sizeof(ti));
1519             ti.cbSize   = sizeof(ti);
1520             ti.uFlags   = TTF_IDISHWND | TTF_TRACK | TTF_ABSOLUTE;
1521             ti.hwnd     = hwnd;
1522             ti.lpszText = &wEmpty;
1523
1524             SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW, 0, (LPARAM)&ti);
1525          }
1526     }
1527
1528     OpenThemeData (hwnd, themeClass);
1529
1530     return 0;
1531 }
1532
1533
1534 static LRESULT
1535 TRACKBAR_Destroy (TRACKBAR_INFO *infoPtr)
1536 {
1537     /* delete tooltip control */
1538     if (infoPtr->hwndToolTip)
1539         DestroyWindow (infoPtr->hwndToolTip);
1540
1541     Free (infoPtr->tics);
1542     infoPtr->tics = NULL;
1543
1544     SetWindowLongPtrW (infoPtr->hwndSelf, 0, 0);
1545     CloseThemeData (GetWindowTheme (infoPtr->hwndSelf));
1546     Free (infoPtr);
1547
1548     return 0;
1549 }
1550
1551
1552 static LRESULT
1553 TRACKBAR_KillFocus (TRACKBAR_INFO *infoPtr)
1554 {
1555     TRACE("\n");
1556     infoPtr->bFocussed = FALSE;
1557     TRACKBAR_InvalidateAll(infoPtr);
1558
1559     return 0;
1560 }
1561
1562 static LRESULT
1563 TRACKBAR_LButtonDown (TRACKBAR_INFO *infoPtr, INT x, INT y)
1564 {
1565     POINT clickPoint;
1566
1567     clickPoint.x = x;
1568     clickPoint.y = y;
1569
1570     SetFocus(infoPtr->hwndSelf);
1571
1572     if (PtInRect(&infoPtr->rcThumb, clickPoint)) {
1573         infoPtr->flags |= TB_DRAG_MODE;
1574         SetCapture (infoPtr->hwndSelf);
1575         TRACKBAR_UpdateToolTip (infoPtr);
1576         TRACKBAR_ActivateToolTip (infoPtr, TRUE);
1577         TRACKBAR_InvalidateThumb(infoPtr, infoPtr->lPos);
1578     } else {
1579         LONG dir = TRACKBAR_GetAutoPageDirection(infoPtr, clickPoint);
1580         if (dir == 0) return 0;
1581         infoPtr->flags |= (dir < 0) ? TB_AUTO_PAGE_LEFT : TB_AUTO_PAGE_RIGHT;
1582         TRACKBAR_AutoPage (infoPtr, clickPoint);
1583         SetCapture (infoPtr->hwndSelf);
1584         SetTimer(infoPtr->hwndSelf, TB_REFRESH_TIMER, TB_REFRESH_DELAY, 0);
1585     }
1586
1587     return 0;
1588 }
1589
1590
1591 static LRESULT
1592 TRACKBAR_LButtonUp (TRACKBAR_INFO *infoPtr)
1593 {
1594     if (infoPtr->flags & TB_DRAG_MODE) {
1595         notify_with_scroll (infoPtr, TB_THUMBPOSITION | (infoPtr->lPos<<16));
1596         notify_with_scroll (infoPtr, TB_ENDTRACK);
1597         infoPtr->flags &= ~TB_DRAG_MODE;
1598         ReleaseCapture ();
1599         notify(infoPtr, NM_RELEASEDCAPTURE);
1600         TRACKBAR_ActivateToolTip(infoPtr, FALSE);
1601         TRACKBAR_InvalidateThumb(infoPtr, infoPtr->lPos);
1602     }
1603     if (infoPtr->flags & TB_AUTO_PAGE) {
1604         KillTimer (infoPtr->hwndSelf, TB_REFRESH_TIMER);
1605         infoPtr->flags &= ~TB_AUTO_PAGE;
1606         notify_with_scroll (infoPtr, TB_ENDTRACK);
1607         ReleaseCapture ();
1608         notify(infoPtr, NM_RELEASEDCAPTURE);
1609     }
1610
1611     return 0;
1612 }
1613
1614
1615 static LRESULT
1616 TRACKBAR_CaptureChanged (const TRACKBAR_INFO *infoPtr)
1617 {
1618     notify_with_scroll (infoPtr, TB_ENDTRACK);
1619     return 0;
1620 }
1621
1622
1623 static LRESULT
1624 TRACKBAR_Paint (TRACKBAR_INFO *infoPtr, HDC hdc)
1625 {
1626     if (hdc) {
1627         TRACKBAR_Refresh(infoPtr, hdc);
1628     } else {
1629         PAINTSTRUCT ps;
1630         hdc = BeginPaint (infoPtr->hwndSelf, &ps);
1631         TRACKBAR_Refresh (infoPtr, hdc);
1632         EndPaint (infoPtr->hwndSelf, &ps);
1633     }
1634
1635     return 0;
1636 }
1637
1638
1639 static LRESULT
1640 TRACKBAR_SetFocus (TRACKBAR_INFO *infoPtr)
1641 {
1642     TRACE("\n");
1643     infoPtr->bFocussed = TRUE;
1644     TRACKBAR_InvalidateAll(infoPtr);
1645
1646     return 0;
1647 }
1648
1649
1650 static LRESULT
1651 TRACKBAR_Size (TRACKBAR_INFO *infoPtr)
1652 {
1653     if (infoPtr->dwStyle & TBS_FIXEDLENGTH)
1654     {
1655         TRACKBAR_CalcChannel(infoPtr);
1656         TRACKBAR_UpdateThumb(infoPtr);
1657     }
1658     else
1659         TRACKBAR_InitializeThumb(infoPtr);
1660     TRACKBAR_AlignBuddies (infoPtr);
1661     TRACKBAR_InvalidateAll(infoPtr);
1662
1663     return 0;
1664 }
1665
1666 static LRESULT
1667 TRACKBAR_StyleChanged (TRACKBAR_INFO *infoPtr, WPARAM wStyleType,
1668                        const STYLESTRUCT *lpss)
1669 {
1670     if (wStyleType != GWL_STYLE) return 0;
1671
1672     infoPtr->dwStyle = lpss->styleNew;
1673
1674     return 0;
1675 }
1676
1677 static LRESULT
1678 TRACKBAR_Timer (TRACKBAR_INFO *infoPtr)
1679 {
1680     if (infoPtr->flags & TB_AUTO_PAGE) {
1681         POINT pt;
1682         if (GetCursorPos(&pt))
1683             if (ScreenToClient(infoPtr->hwndSelf, &pt))
1684                 TRACKBAR_AutoPage(infoPtr, pt);
1685     }
1686     return 0;
1687 }
1688
1689
1690 /* update theme after a WM_THEMECHANGED message */
1691 static LRESULT theme_changed (const TRACKBAR_INFO* infoPtr)
1692 {
1693     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
1694     CloseThemeData (theme);
1695     OpenThemeData (infoPtr->hwndSelf, themeClass);
1696     return 0;
1697 }
1698
1699
1700 static LRESULT
1701 TRACKBAR_MouseMove (TRACKBAR_INFO *infoPtr, INT x, INT y)
1702 {
1703     INT clickPlace = (infoPtr->dwStyle & TBS_VERT) ? y : x;
1704     LONG dragPos, oldPos = infoPtr->lPos;
1705
1706     TRACE("(x=%d. y=%d)\n", x, y);
1707
1708     if (infoPtr->flags & TB_AUTO_PAGE) {
1709         POINT pt;
1710         pt.x = x;
1711         pt.y = y;
1712         TRACKBAR_AutoPage (infoPtr, pt);
1713         return TRUE;
1714     }
1715
1716     if (!(infoPtr->flags & TB_DRAG_MODE))
1717     {
1718         if (GetWindowTheme (infoPtr->hwndSelf))
1719         {
1720             DWORD oldFlags = infoPtr->flags;
1721             POINT pt;
1722             pt.x = x;
1723             pt.y = y;
1724             if (PtInRect (&infoPtr->rcThumb, pt))
1725             {
1726                 TRACKMOUSEEVENT tme;
1727                 tme.cbSize = sizeof( tme );
1728                 tme.dwFlags = TME_LEAVE;
1729                 tme.hwndTrack = infoPtr->hwndSelf;
1730                 TrackMouseEvent( &tme );
1731                 infoPtr->flags |= TB_THUMB_HOT;
1732             }
1733             else
1734             {
1735                 TRACKMOUSEEVENT tme;
1736                 tme.cbSize = sizeof( tme );
1737                 tme.dwFlags = TME_CANCEL;
1738                 tme.hwndTrack = infoPtr->hwndSelf;
1739                 TrackMouseEvent( &tme );
1740                 infoPtr->flags &= ~TB_THUMB_HOT;
1741             }
1742             if (oldFlags != infoPtr->flags) InvalidateRect (infoPtr->hwndSelf, &infoPtr->rcThumb, FALSE);
1743         }
1744         return TRUE;
1745     }
1746
1747     dragPos = TRACKBAR_ConvertPlaceToPosition (infoPtr, clickPlace);
1748
1749     if (dragPos == oldPos) return TRUE;
1750
1751     infoPtr->lPos = dragPos;
1752     TRACKBAR_UpdateThumb (infoPtr);
1753
1754     notify_with_scroll (infoPtr, TB_THUMBTRACK | (infoPtr->lPos<<16));
1755
1756     TRACKBAR_InvalidateThumbMove(infoPtr, oldPos, dragPos);
1757     UpdateWindow (infoPtr->hwndSelf);
1758
1759     return TRUE;
1760 }
1761
1762 static BOOL
1763 TRACKBAR_KeyDown (TRACKBAR_INFO *infoPtr, INT nVirtKey)
1764 {
1765     BOOL downIsLeft = infoPtr->dwStyle & TBS_DOWNISLEFT;
1766     BOOL vert = infoPtr->dwStyle & TBS_VERT;
1767     LONG pos = infoPtr->lPos;
1768
1769     TRACE("%x\n", nVirtKey);
1770
1771     switch (nVirtKey) {
1772     case VK_UP:
1773         if (!vert && downIsLeft) TRACKBAR_LineDown(infoPtr);
1774         else TRACKBAR_LineUp(infoPtr);
1775         break;
1776     case VK_LEFT:
1777         if (vert && downIsLeft) TRACKBAR_LineDown(infoPtr);
1778         else TRACKBAR_LineUp(infoPtr);
1779         break;
1780     case VK_DOWN:
1781         if (!vert && downIsLeft) TRACKBAR_LineUp(infoPtr);
1782         else TRACKBAR_LineDown(infoPtr);
1783         break;
1784     case VK_RIGHT:
1785         if (vert && downIsLeft) TRACKBAR_LineUp(infoPtr);
1786         else TRACKBAR_LineDown(infoPtr);
1787         break;
1788     case VK_NEXT:
1789         if (!vert && downIsLeft) TRACKBAR_PageUp(infoPtr);
1790         else TRACKBAR_PageDown(infoPtr);
1791         break;
1792     case VK_PRIOR:
1793         if (!vert && downIsLeft) TRACKBAR_PageDown(infoPtr);
1794         else TRACKBAR_PageUp(infoPtr);
1795         break;
1796     case VK_HOME:
1797         if (infoPtr->lPos == infoPtr->lRangeMin) return FALSE;
1798         infoPtr->lPos = infoPtr->lRangeMin;
1799         notify_with_scroll (infoPtr, TB_TOP);
1800         break;
1801     case VK_END:
1802         if (infoPtr->lPos == infoPtr->lRangeMax) return FALSE;
1803         infoPtr->lPos = infoPtr->lRangeMax;
1804         notify_with_scroll (infoPtr, TB_BOTTOM);
1805         break;
1806     }
1807
1808     if (pos != infoPtr->lPos) {
1809         TRACKBAR_UpdateThumb (infoPtr);
1810         TRACKBAR_InvalidateThumbMove (infoPtr, pos, infoPtr->lPos);
1811     }
1812
1813     return TRUE;
1814 }
1815
1816
1817 static inline BOOL
1818 TRACKBAR_KeyUp (const TRACKBAR_INFO *infoPtr, INT nVirtKey)
1819 {
1820     switch (nVirtKey) {
1821     case VK_LEFT:
1822     case VK_UP:
1823     case VK_RIGHT:
1824     case VK_DOWN:
1825     case VK_NEXT:
1826     case VK_PRIOR:
1827     case VK_HOME:
1828     case VK_END:
1829         notify_with_scroll (infoPtr, TB_ENDTRACK);
1830     }
1831     return TRUE;
1832 }
1833
1834
1835 static LRESULT
1836 TRACKBAR_Enable (TRACKBAR_INFO *infoPtr, BOOL enable)
1837 {
1838     if (enable)
1839         infoPtr->dwStyle &= ~WS_DISABLED;
1840     else
1841         infoPtr->dwStyle |= WS_DISABLED;
1842
1843     InvalidateRect(infoPtr->hwndSelf, &infoPtr->rcThumb, TRUE);
1844
1845     return 1;
1846 }
1847
1848 static LRESULT WINAPI
1849 TRACKBAR_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1850 {
1851     TRACKBAR_INFO *infoPtr = (TRACKBAR_INFO *)GetWindowLongPtrW (hwnd, 0);
1852
1853     TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hwnd, uMsg, wParam, lParam);
1854
1855     if (!infoPtr && (uMsg != WM_CREATE))
1856         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
1857
1858     switch (uMsg)
1859     {
1860     case TBM_CLEARSEL:
1861         return TRACKBAR_ClearSel (infoPtr, (BOOL)wParam);
1862
1863     case TBM_CLEARTICS:
1864         return TRACKBAR_ClearTics (infoPtr, (BOOL)wParam);
1865
1866     case TBM_GETBUDDY:
1867         return (LRESULT)(wParam ? infoPtr->hwndBuddyLA : infoPtr->hwndBuddyRB);
1868
1869     case TBM_GETCHANNELRECT:
1870         return TRACKBAR_GetChannelRect (infoPtr, (LPRECT)lParam);
1871
1872     case TBM_GETLINESIZE:
1873         return infoPtr->lLineSize;
1874
1875     case TBM_GETNUMTICS:
1876         return TRACKBAR_GetNumTics (infoPtr);
1877
1878     case TBM_GETPAGESIZE:
1879         return infoPtr->lPageSize;
1880
1881     case TBM_GETPOS:
1882         return infoPtr->lPos;
1883
1884     case TBM_GETPTICS:
1885         return (LRESULT)infoPtr->tics;
1886
1887     case TBM_GETRANGEMAX:
1888         return infoPtr->lRangeMax;
1889
1890     case TBM_GETRANGEMIN:
1891         return infoPtr->lRangeMin;
1892
1893     case TBM_GETSELEND:
1894         return infoPtr->lSelMax;
1895
1896     case TBM_GETSELSTART:
1897         return infoPtr->lSelMin;
1898
1899     case TBM_GETTHUMBLENGTH:
1900         return infoPtr->uThumbLen;
1901
1902     case TBM_GETTHUMBRECT:
1903         return CopyRect((LPRECT)lParam, &infoPtr->rcThumb);
1904
1905     case TBM_GETTIC:
1906         return TRACKBAR_GetTic (infoPtr, (INT)wParam);
1907
1908     case TBM_GETTICPOS:
1909         return TRACKBAR_GetTicPos (infoPtr, (INT)wParam);
1910
1911     case TBM_GETTOOLTIPS:
1912         return (LRESULT)infoPtr->hwndToolTip;
1913
1914     case TBM_GETUNICODEFORMAT:
1915         return infoPtr->bUnicode;
1916
1917     case TBM_SETBUDDY:
1918         return (LRESULT) TRACKBAR_SetBuddy(infoPtr, (BOOL)wParam, (HWND)lParam);
1919
1920     case TBM_SETLINESIZE:
1921         return TRACKBAR_SetLineSize (infoPtr, (LONG)lParam);
1922
1923     case TBM_SETPAGESIZE:
1924         return TRACKBAR_SetPageSize (infoPtr, (LONG)lParam);
1925
1926     case TBM_SETPOS:
1927         return TRACKBAR_SetPos (infoPtr, (BOOL)wParam, (LONG)lParam);
1928
1929     case TBM_SETRANGE:
1930         return TRACKBAR_SetRange (infoPtr, (BOOL)wParam, (LONG)lParam);
1931
1932     case TBM_SETRANGEMAX:
1933         return TRACKBAR_SetRangeMax (infoPtr, (BOOL)wParam, (LONG)lParam);
1934
1935     case TBM_SETRANGEMIN:
1936         return TRACKBAR_SetRangeMin (infoPtr, (BOOL)wParam, (LONG)lParam);
1937
1938     case TBM_SETSEL:
1939         return TRACKBAR_SetSel (infoPtr, (BOOL)wParam, (LONG)lParam);
1940
1941     case TBM_SETSELEND:
1942         return TRACKBAR_SetSelEnd (infoPtr, (BOOL)wParam, (LONG)lParam);
1943
1944     case TBM_SETSELSTART:
1945         return TRACKBAR_SetSelStart (infoPtr, (BOOL)wParam, (LONG)lParam);
1946
1947     case TBM_SETTHUMBLENGTH:
1948         return TRACKBAR_SetThumbLength (infoPtr, (UINT)wParam);
1949
1950     case TBM_SETTIC:
1951         return TRACKBAR_SetTic (infoPtr, (LONG)lParam);
1952
1953     case TBM_SETTICFREQ:
1954         return TRACKBAR_SetTicFreq (infoPtr, (WORD)wParam);
1955
1956     case TBM_SETTIPSIDE:
1957         return TRACKBAR_SetTipSide (infoPtr, (INT)wParam);
1958
1959     case TBM_SETTOOLTIPS:
1960         return TRACKBAR_SetToolTips (infoPtr, (HWND)wParam);
1961
1962     case TBM_SETUNICODEFORMAT:
1963         return TRACKBAR_SetUnicodeFormat (infoPtr, (BOOL)wParam);
1964
1965
1966     case WM_CAPTURECHANGED:
1967         if (hwnd == (HWND)lParam) return 0;
1968         return TRACKBAR_CaptureChanged (infoPtr);
1969
1970     case WM_CREATE:
1971         return TRACKBAR_Create (hwnd, (LPCREATESTRUCTW)lParam);
1972
1973     case WM_DESTROY:
1974         return TRACKBAR_Destroy (infoPtr);
1975
1976     case WM_ENABLE:
1977         return TRACKBAR_Enable (infoPtr, (BOOL)wParam);
1978
1979     case WM_ERASEBKGND:
1980         return 0;
1981
1982     case WM_GETDLGCODE:
1983         return DLGC_WANTARROWS;
1984
1985     case WM_KEYDOWN:
1986         return TRACKBAR_KeyDown (infoPtr, (INT)wParam);
1987
1988     case WM_KEYUP:
1989         return TRACKBAR_KeyUp (infoPtr, (INT)wParam);
1990
1991     case WM_KILLFOCUS:
1992         return TRACKBAR_KillFocus (infoPtr);
1993
1994     case WM_LBUTTONDOWN:
1995         return TRACKBAR_LButtonDown (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1996
1997     case WM_LBUTTONUP:
1998         return TRACKBAR_LButtonUp (infoPtr);
1999
2000     case WM_MOUSELEAVE:
2001         infoPtr->flags &= ~TB_THUMB_HOT;
2002         InvalidateRect (infoPtr->hwndSelf, &infoPtr->rcThumb, FALSE);
2003         return 0;
2004
2005     case WM_MOUSEMOVE:
2006         return TRACKBAR_MouseMove (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
2007
2008     case WM_PRINTCLIENT:
2009     case WM_PAINT:
2010         return TRACKBAR_Paint (infoPtr, (HDC)wParam);
2011
2012     case WM_SETFOCUS:
2013         return TRACKBAR_SetFocus (infoPtr);
2014
2015     case WM_SIZE:
2016         return TRACKBAR_Size (infoPtr);
2017
2018     case WM_STYLECHANGED:
2019         return TRACKBAR_StyleChanged (infoPtr, wParam, (LPSTYLESTRUCT)lParam);
2020
2021     case WM_THEMECHANGED:
2022         return theme_changed (infoPtr);
2023
2024     case WM_TIMER:
2025         return TRACKBAR_Timer (infoPtr);
2026
2027     case WM_WININICHANGE:
2028         return TRACKBAR_InitializeThumb (infoPtr);
2029
2030     default:
2031         if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
2032             ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
2033         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
2034     }
2035 }
2036
2037
2038 void TRACKBAR_Register (void)
2039 {
2040     WNDCLASSW wndClass;
2041
2042     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
2043     wndClass.style         = CS_GLOBALCLASS;
2044     wndClass.lpfnWndProc   = TRACKBAR_WindowProc;
2045     wndClass.cbClsExtra    = 0;
2046     wndClass.cbWndExtra    = sizeof(TRACKBAR_INFO *);
2047     wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
2048     wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2049     wndClass.lpszClassName = TRACKBAR_CLASSW;
2050
2051     RegisterClassW (&wndClass);
2052 }
2053
2054
2055 void TRACKBAR_Unregister (void)
2056 {
2057     UnregisterClassW (TRACKBAR_CLASSW, NULL);
2058 }