dlls/uxtheme/scrollbar.c

   1 /*
   2  * Theming - Scrollbar control
   3  *
   4  * Copyright (c) 2015 Mark Harmstone
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "uxtheme.h"
  29 #include "uxthemedll.h"
  30 #include "vssym32.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(theme_scroll);
  34
  35 void WINAPI UXTHEME_ScrollBarDraw(HWND hwnd, HDC dc, INT bar, enum SCROLL_HITTEST hit_test,
  36                                   const struct SCROLL_TRACKING_INFO *tracking_info,
  37                                   BOOL draw_arrows, BOOL draw_interior, RECT *rect, UINT enable_flags,
  38                                   INT arrowsize, INT thumbpos, INT thumbsize, BOOL vertical)
  39 {
  40     BOOL disabled = !IsWindowEnabled(hwnd);
  41     HTHEME theme;
  42     DWORD style;
  43
  44     if (bar == SB_CTL)
  45         theme = GetWindowTheme(hwnd);
  46     else
  47         theme = OpenThemeDataForDpi(NULL, WC_SCROLLBARW, GetDpiForWindow(hwnd));
  48
  49     if (!theme)
  50     {
  51         user_api.pScrollBarDraw(hwnd, dc, bar, hit_test, tracking_info, draw_arrows, draw_interior,
  52                                 rect, enable_flags, arrowsize, thumbpos, thumbsize, vertical);
  53         return;
  54     }
  55
  56     style = GetWindowLongW(hwnd, GWL_STYLE);
  57     if (bar == SB_CTL && (style & SBS_SIZEBOX || style & SBS_SIZEGRIP)) {
  58         int state;
  59
  60         if (style & SBS_SIZEBOXTOPLEFTALIGN)
  61             state = SZB_TOPLEFTALIGN;
  62         else
  63             state = SZB_RIGHTALIGN;
  64
  65         /* Tests show that COLOR_BTNFACE is used instead of DrawThemeParentBackground() for drawing
  66          * background */
  67         FillRect(dc, rect, GetSysColorBrush(COLOR_BTNFACE));
  68         DrawThemeBackground(theme, dc, SBP_SIZEBOX, state, rect, NULL);
  69     } else {
  70         int uppertrackstate, lowertrackstate, thumbstate;
  71         HBRUSH track_brush = NULL;
  72         RECT partrect;
  73         SIZE grippersize;
  74
  75         if (bar == SB_CTL)
  76             track_brush = (HBRUSH)SendMessageW(GetParent(hwnd), WM_CTLCOLORSCROLLBAR, (WPARAM)dc, (LPARAM)hwnd);
  77
  78         if (disabled) {
  79             uppertrackstate = SCRBS_DISABLED;
  80             lowertrackstate = SCRBS_DISABLED;
  81             thumbstate = SCRBS_DISABLED;
  82         } else {
  83             uppertrackstate = SCRBS_NORMAL;
  84             lowertrackstate = SCRBS_NORMAL;
  85             thumbstate = SCRBS_NORMAL;
  86
  87             if (vertical == tracking_info->vertical && hit_test == tracking_info->hit_test
  88                 && GetCapture() == hwnd)
  89             {
  90                 if (hit_test == SCROLL_TOP_RECT)
  91                     uppertrackstate = SCRBS_PRESSED;
  92                 else if (hit_test == SCROLL_BOTTOM_RECT)
  93                     lowertrackstate = SCRBS_PRESSED;
  94                 else if (hit_test == SCROLL_THUMB)
  95                     thumbstate = SCRBS_PRESSED;
  96             }
  97             else
  98             {
  99                 if (hit_test == SCROLL_TOP_RECT)
 100                     uppertrackstate = SCRBS_HOT;
 101                 else if (hit_test == SCROLL_BOTTOM_RECT)
 102                     lowertrackstate = SCRBS_HOT;
 103                 else if (hit_test == SCROLL_THUMB)
 104                     thumbstate = SCRBS_HOT;
 105             }
 106
 107             /* Thumb is also shown as pressed when tracking */
 108             if (tracking_info->win == hwnd && tracking_info->bar == bar)
 109                 thumbstate = SCRBS_PRESSED;
 110         }
 111
 112         if (vertical) {
 113             int uparrowstate, downarrowstate;
 114
 115             if (disabled) {
 116                 uparrowstate = ABS_UPDISABLED;
 117                 downarrowstate = ABS_DOWNDISABLED;
 118             } else {
 119                 uparrowstate = ABS_UPNORMAL;
 120                 downarrowstate = ABS_DOWNNORMAL;
 121
 122                 if (vertical == tracking_info->vertical && hit_test == tracking_info->hit_test
 123                     && GetCapture() == hwnd)
 124                 {
 125                     if (hit_test == SCROLL_TOP_ARROW)
 126                         uparrowstate = ABS_UPPRESSED;
 127                     else if (hit_test == SCROLL_BOTTOM_ARROW)
 128                         downarrowstate = ABS_DOWNPRESSED;
 129                 }
 130                 else
 131                 {
 132                     if (hit_test == SCROLL_TOP_ARROW)
 133                         uparrowstate = ABS_UPHOT;
 134                     else if (hit_test == SCROLL_BOTTOM_ARROW)
 135                         downarrowstate = ABS_DOWNHOT;
 136                 }
 137             }
 138
 139             partrect = *rect;
 140             partrect.bottom = partrect.top + arrowsize;
 141             DrawThemeBackground(theme, dc, SBP_ARROWBTN, uparrowstate, &partrect, NULL);
 142
 143             partrect.bottom = rect->bottom;
 144             partrect.top = partrect.bottom - arrowsize;
 145             DrawThemeBackground(theme, dc, SBP_ARROWBTN, downarrowstate, &partrect, NULL);
 146
 147             if (thumbpos > 0) {
 148                 partrect.top = rect->top + arrowsize;
 149                 partrect.bottom = rect->top + thumbpos;
 150
 151                 if (bar == SB_CTL && track_brush)
 152                     FillRect(dc, &partrect, track_brush);
 153                 else
 154                     DrawThemeBackground(theme, dc, SBP_UPPERTRACKVERT, uppertrackstate, &partrect, NULL);
 155             }
 156
 157             if (thumbsize > 0) {
 158                 partrect.top = rect->top + thumbpos;
 159                 partrect.bottom = partrect.top + thumbsize;
 160                 DrawThemeBackground(theme, dc, SBP_THUMBBTNVERT, thumbstate, &partrect, NULL);
 161
 162                 if (SUCCEEDED(GetThemePartSize(theme, dc, SBP_GRIPPERVERT, thumbstate, NULL, TS_DRAW, &grippersize))) {
 163                     MARGINS margins;
 164
 165                     if (SUCCEEDED(GetThemeMargins(theme, dc, SBP_THUMBBTNVERT, thumbstate, TMT_CONTENTMARGINS, &partrect, &margins))) {
 166                         if (grippersize.cy <= (thumbsize - margins.cyTopHeight - margins.cyBottomHeight))
 167                             DrawThemeBackground(theme, dc, SBP_GRIPPERVERT, thumbstate, &partrect, NULL);
 168                     }
 169                 }
 170             }
 171
 172             partrect.bottom = rect->bottom - arrowsize;
 173             if (thumbsize > 0)
 174                 partrect.top = rect->top + thumbpos + thumbsize;
 175             else
 176                 partrect.top = rect->top + arrowsize;
 177             if (partrect.bottom > partrect.top)
 178             {
 179                 if (bar == SB_CTL && track_brush)
 180                     FillRect(dc, &partrect, track_brush);
 181                 else
 182                     DrawThemeBackground(theme, dc, SBP_LOWERTRACKVERT, lowertrackstate, &partrect, NULL);
 183             }
 184         } else {
 185             int leftarrowstate, rightarrowstate;
 186
 187             if (disabled) {
 188                 leftarrowstate = ABS_LEFTDISABLED;
 189                 rightarrowstate = ABS_RIGHTDISABLED;
 190             } else {
 191                 leftarrowstate = ABS_LEFTNORMAL;
 192                 rightarrowstate = ABS_RIGHTNORMAL;
 193
 194                 if (vertical == tracking_info->vertical && hit_test == tracking_info->hit_test
 195                     && GetCapture() == hwnd)
 196                 {
 197                     if (hit_test == SCROLL_TOP_ARROW)
 198                         leftarrowstate = ABS_LEFTPRESSED;
 199                     else if (hit_test == SCROLL_BOTTOM_ARROW)
 200                         rightarrowstate = ABS_RIGHTPRESSED;
 201                 }
 202                 else
 203                 {
 204                     if (hit_test == SCROLL_TOP_ARROW)
 205                         leftarrowstate = ABS_LEFTHOT;
 206                     else if (hit_test == SCROLL_BOTTOM_ARROW)
 207                         rightarrowstate = ABS_RIGHTHOT;
 208                 }
 209             }
 210
 211             partrect = *rect;
 212             partrect.right = partrect.left + arrowsize;
 213             DrawThemeBackground(theme, dc, SBP_ARROWBTN, leftarrowstate, &partrect, NULL);
 214
 215             partrect.right = rect->right;
 216             partrect.left = partrect.right - arrowsize;
 217             DrawThemeBackground(theme, dc, SBP_ARROWBTN, rightarrowstate, &partrect, NULL);
 218
 219             if (thumbpos > 0) {
 220                 partrect.left = rect->left + arrowsize;
 221                 partrect.right = rect->left + thumbpos;
 222
 223                 if (bar == SB_CTL && track_brush)
 224                     FillRect(dc, &partrect, track_brush);
 225                 else
 226                     DrawThemeBackground(theme, dc, SBP_UPPERTRACKHORZ, uppertrackstate, &partrect, NULL);
 227             }
 228
 229             if (thumbsize > 0) {
 230                 partrect.left = rect->left + thumbpos;
 231                 partrect.right = partrect.left + thumbsize;
 232                 DrawThemeBackground(theme, dc, SBP_THUMBBTNHORZ, thumbstate, &partrect, NULL);
 233
 234                 if (SUCCEEDED(GetThemePartSize(theme, dc, SBP_GRIPPERHORZ, thumbstate, NULL, TS_DRAW, &grippersize))) {
 235                     MARGINS margins;
 236
 237                     if (SUCCEEDED(GetThemeMargins(theme, dc, SBP_THUMBBTNHORZ, thumbstate, TMT_CONTENTMARGINS, &partrect, &margins))) {
 238                         if (grippersize.cx <= (thumbsize - margins.cxLeftWidth - margins.cxRightWidth))
 239                             DrawThemeBackground(theme, dc, SBP_GRIPPERHORZ, thumbstate, &partrect, NULL);
 240                     }
 241                 }
 242             }
 243
 244             partrect.right = rect->right - arrowsize;
 245             if (thumbsize > 0)
 246                 partrect.left = rect->left + thumbpos + thumbsize;
 247             else
 248                 partrect.left = rect->left + arrowsize;
 249             if (partrect.right > partrect.left)
 250             {
 251                 if (bar == SB_CTL && track_brush)
 252                     FillRect(dc, &partrect, track_brush);
 253                 else
 254                     DrawThemeBackground(theme, dc, SBP_LOWERTRACKHORZ, lowertrackstate, &partrect, NULL);
 255             }
 256         }
 257     }
 258
 259     if (bar != SB_CTL)
 260         CloseThemeData(theme);
 261 }
 262
 263 LRESULT WINAPI UXTHEME_ScrollbarWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
 264                                         BOOL unicode)
 265 {
 266     const WCHAR* themeClass = WC_SCROLLBARW;
 267     HTHEME theme;
 268     LRESULT result;
 269
 270     TRACE("(%p, 0x%x, %Iu, %Iu, %d)\n", hwnd, msg, wParam, lParam, unicode);
 271
 272     switch (msg) {
 273         case WM_CREATE:
 274             result = user_api.pScrollBarWndProc(hwnd, msg, wParam, lParam, unicode);
 275             OpenThemeData(hwnd, themeClass);
 276             return result;
 277
 278         case WM_DESTROY:
 279             theme = GetWindowTheme(hwnd);
 280             CloseThemeData(theme);
 281             return user_api.pScrollBarWndProc(hwnd, msg, wParam, lParam, unicode);
 282
 283         case WM_THEMECHANGED:
 284             theme = GetWindowTheme(hwnd);
 285             CloseThemeData(theme);
 286             OpenThemeData(hwnd, themeClass);
 287             InvalidateRect(hwnd, NULL, TRUE);
 288             break;
 289
 290         case WM_SYSCOLORCHANGE:
 291             theme = GetWindowTheme(hwnd);
 292             if (!theme) return user_api.pScrollBarWndProc(hwnd, msg, wParam, lParam, unicode);
 293             /* Do nothing. When themed, a WM_THEMECHANGED will be received, too,
 294              * which will do the repaint. */
 295             break;
 296
 297         default:
 298             return user_api.pScrollBarWndProc(hwnd, msg, wParam, lParam, unicode);
 299     }
 300
 301     return 0;
 302 }