vcl/win/gdi/salnativewidgets-luna.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 // General info:
  21 //   http://msdn.microsoft.com/en-us/library/windows/desktop/hh270423%28v=vs.85%29.aspx
  22 //   http://msdn.microsoft.com/en-us/library/windows/desktop/bb773178%28v=vs.85%29.aspx
  23
  24 // Useful tool to explore the themes & their rendering:
  25 //   http://privat.rejbrand.se/UxExplore.exe
  26 // (found at http://stackoverflow.com/questions/4009701/windows-visual-themes-gallery-of-parts-and-states/4009712#4009712)
  27
  28 // Theme subclasses:
  29 //   http://msdn.microsoft.com/en-us/library/windows/desktop/bb773218%28v=vs.85%29.aspx
  30
  31 // Drawing in non-client area (general DWM-related info):
  32 //   http://msdn.microsoft.com/en-us/library/windows/desktop/bb688195%28v=vs.85%29.aspx
  33
  34 #include <rtl/ustring.h>
  35
  36 #include <osl/diagnose.h>
  37 #include <osl/module.h>
  38 #include <o3tl/char16_t2wchar_t.hxx>
  39
  40 #include <opengl/win/gdiimpl.hxx>
  41 #include <vcl/svapp.hxx>
  42 #include <vcl/settings.hxx>
  43
  44 #include <win/svsys.h>
  45 #include <win/salgdi.h>
  46 #include <win/saldata.hxx>
  47 #include <win/scoped_gdi.hxx>
  48
  49 #include <uxtheme.h>
  50 #include <vssym32.h>
  51
  52 #include <map>
  53 #include <string>
  54 #include <optional>
  55 #include <ControlCacheKey.hxx>
  56
  57 using namespace std;
  58
  59 typedef map< wstring, HTHEME > ThemeMap;
  60 static ThemeMap aThemeMap;
  61
  62 /****************************************************
  63  wrap visual styles API to avoid linking against it
  64  it is not available on all Windows platforms
  65 *****************************************************/
  66
  67 namespace {
  68
  69 class VisualStylesAPI
  70 {
  71 private:
  72     typedef HTHEME  (WINAPI * OpenThemeData_Proc_T) ( HWND hwnd, LPCWSTR pszClassList );
  73     typedef HRESULT (WINAPI * CloseThemeData_Proc_T) ( HTHEME hTheme );
  74     typedef HRESULT (WINAPI * GetThemeBackgroundContentRect_Proc_T) ( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pBoundingRect, RECT *pContentRect );
  75     typedef HRESULT (WINAPI * DrawThemeBackground_Proc_T) ( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect );
  76     typedef HRESULT (WINAPI * DrawThemeText_Proc_T) ( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, DWORD dwTextFlags2, const RECT *pRect );
  77     typedef HRESULT (WINAPI * GetThemePartSize_Proc_T) ( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *prc, THEMESIZE eSize, SIZE *psz );
  78     typedef BOOL    (WINAPI * IsThemeActive_Proc_T) ( void );
  79
  80     OpenThemeData_Proc_T                    lpfnOpenThemeData;
  81     CloseThemeData_Proc_T                   lpfnCloseThemeData;
  82     GetThemeBackgroundContentRect_Proc_T    lpfnGetThemeBackgroundContentRect;
  83     DrawThemeBackground_Proc_T              lpfnDrawThemeBackground;
  84     DrawThemeText_Proc_T                    lpfnDrawThemeText;
  85     GetThemePartSize_Proc_T                 lpfnGetThemePartSize;
  86     IsThemeActive_Proc_T                    lpfnIsThemeActive;
  87
  88     oslModule mhModule;
  89
  90 public:
  91     VisualStylesAPI();
  92     ~VisualStylesAPI();
  93
  94     HTHEME OpenThemeData( HWND hwnd, LPCWSTR pszClassList );
  95     HRESULT CloseThemeData( HTHEME hTheme );
  96     HRESULT GetThemeBackgroundContentRect( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pBoundingRect, RECT *pContentRect );
  97     HRESULT DrawThemeBackground( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect );
  98     HRESULT DrawThemeText( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, DWORD dwTextFlags2, const RECT *pRect );
  99     HRESULT GetThemePartSize( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *prc, THEMESIZE eSize, SIZE *psz );
 100     bool IsThemeActive();
 101 };
 102
 103 }
 104
 105 static VisualStylesAPI vsAPI;
 106
 107 VisualStylesAPI::VisualStylesAPI()
 108     : lpfnOpenThemeData( nullptr ),
 109       lpfnCloseThemeData( nullptr ),
 110       lpfnGetThemeBackgroundContentRect( nullptr ),
 111       lpfnDrawThemeBackground( nullptr ),
 112       lpfnDrawThemeText( nullptr ),
 113       lpfnGetThemePartSize( nullptr ),
 114       lpfnIsThemeActive( nullptr )
 115 {
 116     OUString aLibraryName( "uxtheme.dll" );
 117     mhModule = osl_loadModule( aLibraryName.pData, SAL_LOADMODULE_DEFAULT );
 118
 119     if ( mhModule )
 120     {
 121         lpfnOpenThemeData = reinterpret_cast<OpenThemeData_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "OpenThemeData" ));
 122         lpfnCloseThemeData = reinterpret_cast<CloseThemeData_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "CloseThemeData" ));
 123         lpfnGetThemeBackgroundContentRect = reinterpret_cast<GetThemeBackgroundContentRect_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "GetThemeBackgroundContentRect" ));
 124         lpfnDrawThemeBackground = reinterpret_cast<DrawThemeBackground_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "DrawThemeBackground" ));
 125         lpfnDrawThemeText = reinterpret_cast<DrawThemeText_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "DrawThemeText" ));
 126         lpfnGetThemePartSize = reinterpret_cast<GetThemePartSize_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "GetThemePartSize" ));
 127         lpfnIsThemeActive = reinterpret_cast<IsThemeActive_Proc_T>(osl_getAsciiFunctionSymbol( mhModule, "IsThemeActive" ));
 128     }
 129 }
 130
 131 VisualStylesAPI::~VisualStylesAPI()
 132 {
 133     if( mhModule )
 134         osl_unloadModule( mhModule );
 135 }
 136
 137 HTHEME VisualStylesAPI::OpenThemeData( HWND hwnd, LPCWSTR pszClassList )
 138 {
 139     if(lpfnOpenThemeData)
 140         return (*lpfnOpenThemeData) (hwnd, pszClassList);
 141     else
 142         return nullptr;
 143 }
 144
 145 HRESULT VisualStylesAPI::CloseThemeData( HTHEME hTheme )
 146 {
 147     if(lpfnCloseThemeData)
 148         return (*lpfnCloseThemeData) (hTheme);
 149     else
 150         return S_FALSE;
 151 }
 152
 153 HRESULT VisualStylesAPI::GetThemeBackgroundContentRect( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pBoundingRect, RECT *pContentRect )
 154 {
 155     if(lpfnGetThemeBackgroundContentRect)
 156         return (*lpfnGetThemeBackgroundContentRect) ( hTheme, hdc, iPartId, iStateId, pBoundingRect, pContentRect );
 157     else
 158         return S_FALSE;
 159 }
 160
 161 HRESULT VisualStylesAPI::DrawThemeBackground( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect )
 162 {
 163     if(lpfnDrawThemeBackground)
 164         return (*lpfnDrawThemeBackground) (hTheme, hdc, iPartId, iStateId, pRect, pClipRect);
 165     else
 166         return S_FALSE;
 167 }
 168
 169 HRESULT VisualStylesAPI::DrawThemeText( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, DWORD dwTextFlags2, const RECT *pRect )
 170 {
 171     if(lpfnDrawThemeText)
 172         return (*lpfnDrawThemeText) (hTheme, hdc, iPartId, iStateId, pszText, iCharCount, dwTextFlags, dwTextFlags2, pRect);
 173     else
 174         return S_FALSE;
 175 }
 176
 177 HRESULT VisualStylesAPI::GetThemePartSize( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *prc, THEMESIZE eSize, SIZE *psz )
 178 {
 179     if(lpfnGetThemePartSize)
 180         return (*lpfnGetThemePartSize) (hTheme, hdc, iPartId, iStateId, prc, eSize, psz);
 181     else
 182         return S_FALSE;
 183 }
 184
 185 bool VisualStylesAPI::IsThemeActive()
 186 {
 187     if(lpfnIsThemeActive)
 188         return (*lpfnIsThemeActive) ();
 189     else
 190         return false;
 191 }
 192
 193 /*********************************************************
 194  * Initialize XP theming and local stuff
 195  *********************************************************/
 196 void SalData::initNWF()
 197 {
 198     ImplSVData* pSVData = ImplGetSVData();
 199
 200     // the menu bar and the top docking area should have a common background (gradient)
 201     pSVData->maNWFData.mbMenuBarDockingAreaCommonBG = true;
 202 }
 203
 204 // *********************************************************
 205 // * Release theming handles
 206 // ********************************************************
 207 void SalData::deInitNWF()
 208 {
 209     for( auto& rEntry : aThemeMap )
 210         vsAPI.CloseThemeData(rEntry.second);
 211     aThemeMap.clear();
 212 }
 213
 214 static HTHEME getThemeHandle( HWND hWnd, LPCWSTR name )
 215 {
 216     if( GetSalData()->mbThemeChanged )
 217     {
 218         // throw away invalid theme handles
 219         SalData::deInitNWF();
 220         GetSalData()->mbThemeChanged = false;
 221     }
 222
 223     ThemeMap::iterator iter;
 224     if( (iter = aThemeMap.find( name )) != aThemeMap.end() )
 225         return iter->second;
 226     // theme not found -> add it to map
 227     HTHEME hTheme = vsAPI.OpenThemeData( hWnd, name );
 228     if( hTheme != nullptr )
 229         aThemeMap[name] = hTheme;
 230     return hTheme;
 231 }
 232
 233 bool WinSalGraphics::isNativeControlSupported( ControlType nType, ControlPart nPart )
 234 {
 235     HTHEME hTheme = nullptr;
 236
 237     switch( nType )
 238     {
 239         case ControlType::Pushbutton:
 240         case ControlType::Radiobutton:
 241         case ControlType::Checkbox:
 242             if( nPart == ControlPart::Entire )
 243                 hTheme = getThemeHandle( mhWnd, L"Button");
 244             break;
 245         case ControlType::Scrollbar:
 246             if( nPart == ControlPart::DrawBackgroundHorz || nPart == ControlPart::DrawBackgroundVert )
 247                 return false;   // no background painting needed
 248             if( nPart == ControlPart::Entire )
 249                 hTheme = getThemeHandle( mhWnd, L"Scrollbar");
 250             break;
 251         case ControlType::Combobox:
 252             if( nPart == ControlPart::HasBackgroundTexture )
 253                 return false;   // we do not paint the inner part (ie the selection background/focus indication)
 254             if( nPart == ControlPart::Entire )
 255                 hTheme = getThemeHandle( mhWnd, L"Edit");
 256             else if( nPart == ControlPart::ButtonDown )
 257                 hTheme = getThemeHandle( mhWnd, L"Combobox");
 258             break;
 259         case ControlType::Spinbox:
 260             if( nPart == ControlPart::Entire )
 261                 hTheme = getThemeHandle( mhWnd, L"Edit");
 262             else if( nPart == ControlPart::AllButtons ||
 263                 nPart == ControlPart::ButtonUp || nPart == ControlPart::ButtonDown ||
 264                 nPart == ControlPart::ButtonLeft|| nPart == ControlPart::ButtonRight )
 265                 hTheme = getThemeHandle( mhWnd, L"Spin");
 266             break;
 267         case ControlType::SpinButtons:
 268             if( nPart == ControlPart::Entire || nPart == ControlPart::AllButtons )
 269                 hTheme = getThemeHandle( mhWnd, L"Spin");
 270             break;
 271         case ControlType::Editbox:
 272         case ControlType::MultilineEditbox:
 273             if( nPart == ControlPart::HasBackgroundTexture )
 274                 return false;   // we do not paint the inner part (ie the selection background/focus indication)
 275                 //return TRUE;
 276             if( nPart == ControlPart::Entire )
 277                 hTheme = getThemeHandle( mhWnd, L"Edit");
 278             break;
 279         case ControlType::Listbox:
 280             if( nPart == ControlPart::HasBackgroundTexture )
 281                 return false;   // we do not paint the inner part (ie the selection background/focus indication)
 282             if( nPart == ControlPart::Entire || nPart == ControlPart::ListboxWindow )
 283                 hTheme = getThemeHandle( mhWnd, L"Listview");
 284             else if( nPart == ControlPart::ButtonDown )
 285                 hTheme = getThemeHandle( mhWnd, L"Combobox");
 286             break;
 287         case ControlType::TabPane:
 288         case ControlType::TabBody:
 289         case ControlType::TabItem:
 290             if( nPart == ControlPart::Entire )
 291                 hTheme = getThemeHandle( mhWnd, L"Tab");
 292             break;
 293         case ControlType::Toolbar:
 294             if( nPart == ControlPart::Entire || nPart == ControlPart::Button )
 295                 hTheme = getThemeHandle( mhWnd, L"Toolbar");
 296             else
 297                 // use rebar theme for grip and background
 298                 hTheme = getThemeHandle( mhWnd, L"Rebar");
 299             break;
 300         case ControlType::Menubar:
 301             if( nPart == ControlPart::Entire )
 302                 hTheme = getThemeHandle( mhWnd, L"Rebar");
 303             else if( GetSalData()->mbThemeMenuSupport )
 304             {
 305                 if( nPart == ControlPart::MenuItem )
 306                     hTheme = getThemeHandle( mhWnd, L"Menu" );
 307             }
 308             break;
 309         case ControlType::MenuPopup:
 310             if( GetSalData()->mbThemeMenuSupport )
 311             {
 312                 if( nPart == ControlPart::Entire ||
 313                     nPart == ControlPart::MenuItem ||
 314                     nPart == ControlPart::MenuItemCheckMark ||
 315                     nPart == ControlPart::MenuItemRadioMark ||
 316                     nPart == ControlPart::Separator )
 317                     hTheme = getThemeHandle( mhWnd, L"Menu" );
 318             }
 319             break;
 320         case ControlType::Progress:
 321             if( nPart == ControlPart::Entire )
 322                 hTheme = getThemeHandle( mhWnd, L"Progress");
 323             break;
 324         case ControlType::Slider:
 325             if( nPart == ControlPart::TrackHorzArea || nPart == ControlPart::TrackVertArea )
 326                 hTheme = getThemeHandle( mhWnd, L"Trackbar" );
 327             break;
 328         case ControlType::ListNode:
 329             if( nPart == ControlPart::Entire )
 330                 hTheme = getThemeHandle( mhWnd, L"TreeView" );
 331             break;
 332         default:
 333             hTheme = nullptr;
 334             break;
 335     }
 336
 337     return (hTheme != nullptr);
 338 }
 339
 340 bool WinSalGraphics::hitTestNativeControl( ControlType,
 341                               ControlPart,
 342                               const tools::Rectangle&,
 343                               const Point&,
 344                               bool& )
 345 {
 346     return false;
 347 }
 348
 349 static bool ImplDrawTheme( HTHEME hTheme, HDC hDC, int iPart, int iState, RECT rc, const OUString& aStr)
 350 {
 351     HRESULT hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 352
 353     if( aStr.getLength() )
 354     {
 355         RECT rcContent;
 356         hr = vsAPI.GetThemeBackgroundContentRect( hTheme, hDC, iPart, iState, &rc, &rcContent);
 357         hr = vsAPI.DrawThemeText( hTheme, hDC, iPart, iState,
 358             o3tl::toW(aStr.getStr()), -1,
 359             DT_CENTER | DT_VCENTER | DT_SINGLELINE,
 360             0, &rcContent);
 361     }
 362     return (hr == S_OK);
 363 }
 364
 365 static tools::Rectangle ImplGetThemeRect( HTHEME hTheme, HDC hDC, int iPart, int iState, const tools::Rectangle& /* aRect */, THEMESIZE eTS = TS_TRUE )
 366 {
 367     SIZE aSz;
 368     HRESULT hr = vsAPI.GetThemePartSize( hTheme, hDC, iPart, iState, nullptr, eTS, &aSz ); // TS_TRUE returns optimal size
 369     if( hr == S_OK )
 370         return tools::Rectangle( 0, 0, aSz.cx, aSz.cy );
 371     else
 372         return tools::Rectangle();
 373 }
 374
 375 // Helper functions
 376
 377 static void ImplConvertSpinbuttonValues( ControlPart nControlPart, const ControlState& rState, const tools::Rectangle& rRect,
 378                                  int* pLunaPart, int *pLunaState, RECT *pRect )
 379 {
 380     if( nControlPart == ControlPart::ButtonDown )
 381     {
 382         *pLunaPart = SPNP_DOWN;
 383         if( rState & ControlState::PRESSED )
 384             *pLunaState = DNS_PRESSED;
 385         else if( !(rState & ControlState::ENABLED) )
 386             *pLunaState = DNS_DISABLED;
 387         else if( rState & ControlState::ROLLOVER )
 388             *pLunaState = DNS_HOT;
 389         else
 390             *pLunaState = DNS_NORMAL;
 391     }
 392     if( nControlPart == ControlPart::ButtonUp )
 393     {
 394         *pLunaPart = SPNP_UP;
 395         if( rState & ControlState::PRESSED )
 396             *pLunaState = UPS_PRESSED;
 397         else if( !(rState & ControlState::ENABLED) )
 398             *pLunaState = UPS_DISABLED;
 399         else if( rState & ControlState::ROLLOVER )
 400             *pLunaState = UPS_HOT;
 401         else
 402             *pLunaState = UPS_NORMAL;
 403     }
 404     if( nControlPart == ControlPart::ButtonRight )
 405     {
 406         *pLunaPart = SPNP_UPHORZ;
 407         if( rState & ControlState::PRESSED )
 408             *pLunaState = DNHZS_PRESSED;
 409         else if( !(rState & ControlState::ENABLED) )
 410             *pLunaState = DNHZS_DISABLED;
 411         else if( rState & ControlState::ROLLOVER )
 412             *pLunaState = DNHZS_HOT;
 413         else
 414             *pLunaState = DNHZS_NORMAL;
 415     }
 416     if( nControlPart == ControlPart::ButtonLeft )
 417     {
 418         *pLunaPart = SPNP_DOWNHORZ;
 419         if( rState & ControlState::PRESSED )
 420             *pLunaState = UPHZS_PRESSED;
 421         else if( !(rState & ControlState::ENABLED) )
 422             *pLunaState = UPHZS_DISABLED;
 423         else if( rState & ControlState::ROLLOVER )
 424             *pLunaState = UPHZS_HOT;
 425         else
 426             *pLunaState = UPHZS_NORMAL;
 427     }
 428
 429     pRect->left   = rRect.Left();
 430     pRect->right  = rRect.Right()+1;
 431     pRect->top    = rRect.Top();
 432     pRect->bottom = rRect.Bottom()+1;
 433 }
 434
 435 /// Draw an own toolbar style on Windows Vista or later, looks better there
 436 static void impl_drawAeroToolbar( HDC hDC, RECT rc, bool bHorizontal )
 437 {
 438     if ( rc.top == 0 && bHorizontal )
 439     {
 440         const long GRADIENT_HEIGHT = 32;
 441
 442         long gradient_break = rc.top;
 443         long gradient_bottom = rc.bottom - 1;
 444         GRADIENT_RECT g_rect[1] = { { 0, 1 } };
 445
 446         // very slow gradient at the top (if we have space for that)
 447         if ( gradient_bottom - rc.top > GRADIENT_HEIGHT )
 448         {
 449             gradient_break = gradient_bottom - GRADIENT_HEIGHT;
 450
 451             TRIVERTEX vert[2] = {
 452                 { rc.left, rc.top,          0xff00, 0xff00, 0xff00, 0xff00 },
 453                 { rc.right, gradient_break, 0xfa00, 0xfa00, 0xfa00, 0xff00 },
 454             };
 455             GdiGradientFill( hDC, vert, 2, g_rect, 1, GRADIENT_FILL_RECT_V );
 456         }
 457
 458         // gradient at the bottom
 459         TRIVERTEX vert[2] = {
 460             { rc.left, gradient_break,   0xfa00, 0xfa00, 0xfa00, 0xff00 },
 461             { rc.right, gradient_bottom, 0xf000, 0xf000, 0xf000, 0xff00 }
 462         };
 463         GdiGradientFill( hDC, vert, 2, g_rect, 1, GRADIENT_FILL_RECT_V );
 464
 465         // and a darker horizontal line under that
 466         ScopedSelectedHPEN hPen(hDC, CreatePen(PS_SOLID, 1, RGB( 0xb0, 0xb0, 0xb0)));
 467
 468         MoveToEx( hDC, rc.left, gradient_bottom, nullptr );
 469         LineTo( hDC, rc.right, gradient_bottom );
 470     }
 471     else
 472     {
 473         ScopedHBRUSH hbrush(CreateSolidBrush(RGB(0xf0, 0xf0, 0xf0)));
 474         FillRect(hDC, &rc, hbrush.get());
 475
 476         // darker line to distinguish the toolbar and viewshell
 477         // it is drawn only for the horizontal toolbars; it did not look well
 478         // when done for the vertical ones too
 479         if ( bHorizontal )
 480         {
 481             long from_x, from_y, to_x, to_y;
 482
 483             from_x = rc.left;
 484             to_x = rc.right;
 485             from_y = to_y = rc.top;
 486
 487             ScopedSelectedHPEN hPen(hDC, CreatePen(PS_SOLID, 1, RGB( 0xb0, 0xb0, 0xb0)));
 488
 489             MoveToEx( hDC, from_x, from_y, nullptr );
 490             LineTo( hDC, to_x, to_y );
 491         }
 492     }
 493 }
 494
 495 /**
 496  * Gives the actual rectangle used for rendering by ControlType::MenuPopup's
 497  * ControlPart::MenuItemCheckMark or ControlPart::MenuItemRadioMark.
 498  */
 499 static tools::Rectangle GetMenuPopupMarkRegion(const ImplControlValue& rValue)
 500 {
 501     tools::Rectangle aRet;
 502
 503     auto pMVal = dynamic_cast<const MenupopupValue*>(&rValue);
 504     if (!pMVal)
 505         return aRet;
 506
 507     aRet.SetTop(pMVal->maItemRect.Top());
 508     aRet.SetBottom(pMVal->maItemRect.Bottom() + 1); // see below in drawNativeControl
 509     if (AllSettings::GetLayoutRTL())
 510     {
 511         aRet.SetRight(pMVal->maItemRect.Right() + 1);
 512         aRet.SetLeft(aRet.Right() - (pMVal->getNumericVal() - pMVal->maItemRect.Left()));
 513     }
 514     else
 515     {
 516         aRet.SetRight(pMVal->getNumericVal());
 517         aRet.SetLeft(pMVal->maItemRect.Left());
 518     }
 519
 520     return aRet;
 521 }
 522
 523 static bool ImplDrawNativeControl( HDC hDC, HTHEME hTheme, RECT rc,
 524                             ControlType nType,
 525                             ControlPart nPart,
 526                             ControlState nState,
 527                             const ImplControlValue& aValue,
 528                             OUString const & aCaption )
 529 {
 530     // a listbox dropdown is actually a combobox dropdown
 531     if( nType == ControlType::Listbox )
 532         if( nPart == ControlPart::ButtonDown )
 533             nType = ControlType::Combobox;
 534
 535     // draw entire combobox as a large edit box
 536     if( nType == ControlType::Combobox )
 537         if( nPart == ControlPart::Entire )
 538             nType = ControlType::Editbox;
 539
 540     // draw entire spinbox as a large edit box
 541     if( nType == ControlType::Spinbox )
 542         if( nPart == ControlPart::Entire )
 543             nType = ControlType::Editbox;
 544
 545     int iPart(0), iState(0);
 546     if( nType == ControlType::Scrollbar )
 547     {
 548         HRESULT hr;
 549         if( nPart == ControlPart::ButtonUp )
 550         {
 551             iPart = SBP_ARROWBTN;
 552             if( nState & ControlState::PRESSED )
 553                 iState = ABS_UPPRESSED;
 554             else if( !(nState & ControlState::ENABLED) )
 555                 iState = ABS_UPDISABLED;
 556             else if( nState & ControlState::ROLLOVER )
 557                 iState = ABS_UPHOT;
 558             else
 559                 iState = ABS_UPNORMAL;
 560             hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 561             return (hr == S_OK);
 562         }
 563         if( nPart == ControlPart::ButtonDown )
 564         {
 565             iPart = SBP_ARROWBTN;
 566             if( nState & ControlState::PRESSED )
 567                 iState = ABS_DOWNPRESSED;
 568             else if( !(nState & ControlState::ENABLED) )
 569                 iState = ABS_DOWNDISABLED;
 570             else if( nState & ControlState::ROLLOVER )
 571                 iState = ABS_DOWNHOT;
 572             else
 573                 iState = ABS_DOWNNORMAL;
 574             hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 575             return (hr == S_OK);
 576         }
 577         if( nPart == ControlPart::ButtonLeft )
 578         {
 579             iPart = SBP_ARROWBTN;
 580             if( nState & ControlState::PRESSED )
 581                 iState = ABS_LEFTPRESSED;
 582             else if( !(nState & ControlState::ENABLED) )
 583                 iState = ABS_LEFTDISABLED;
 584             else if( nState & ControlState::ROLLOVER )
 585                 iState = ABS_LEFTHOT;
 586             else
 587                 iState = ABS_LEFTNORMAL;
 588             hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 589             return (hr == S_OK);
 590         }
 591         if( nPart == ControlPart::ButtonRight )
 592         {
 593             iPart = SBP_ARROWBTN;
 594             if( nState & ControlState::PRESSED )
 595                 iState = ABS_RIGHTPRESSED;
 596             else if( !(nState & ControlState::ENABLED) )
 597                 iState = ABS_RIGHTDISABLED;
 598             else if( nState & ControlState::ROLLOVER )
 599                 iState = ABS_RIGHTHOT;
 600             else
 601                 iState = ABS_RIGHTNORMAL;
 602             hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 603             return (hr == S_OK);
 604         }
 605         if( nPart == ControlPart::ThumbHorz || nPart == ControlPart::ThumbVert )
 606         {
 607             iPart = (nPart == ControlPart::ThumbHorz) ? SBP_THUMBBTNHORZ : SBP_THUMBBTNVERT;
 608             if( nState & ControlState::PRESSED )
 609                 iState = SCRBS_PRESSED;
 610             else if( !(nState & ControlState::ENABLED) )
 611                 iState = SCRBS_DISABLED;
 612             else if( nState & ControlState::ROLLOVER )
 613                 iState = SCRBS_HOT;
 614             else
 615                 iState = SCRBS_NORMAL;
 616
 617             SIZE sz;
 618             vsAPI.GetThemePartSize(hTheme, hDC, iPart, iState, nullptr, TS_MIN, &sz);
 619             vsAPI.GetThemePartSize(hTheme, hDC, iPart, iState, nullptr, TS_TRUE, &sz);
 620             vsAPI.GetThemePartSize(hTheme, hDC, iPart, iState, nullptr, TS_DRAW, &sz);
 621
 622             hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 623             // paint gripper on thumb if enough space
 624             if( ( (nPart == ControlPart::ThumbVert) && (rc.bottom-rc.top > 12) ) ||
 625                 ( (nPart == ControlPart::ThumbHorz) && (rc.right-rc.left > 12) ) )
 626             {
 627                 iPart = (nPart == ControlPart::ThumbHorz) ? SBP_GRIPPERHORZ : SBP_GRIPPERVERT;
 628                 iState = 0;
 629                 vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 630             }
 631             return (hr == S_OK);
 632         }
 633         if( nPart == ControlPart::TrackHorzLeft || nPart == ControlPart::TrackHorzRight || nPart == ControlPart::TrackVertUpper || nPart == ControlPart::TrackVertLower )
 634         {
 635             switch( nPart )
 636             {
 637                 case ControlPart::TrackHorzLeft:  iPart = SBP_UPPERTRACKHORZ; break;
 638                 case ControlPart::TrackHorzRight: iPart = SBP_LOWERTRACKHORZ; break;
 639                 case ControlPart::TrackVertUpper: iPart = SBP_UPPERTRACKVERT; break;
 640                 case ControlPart::TrackVertLower: iPart = SBP_LOWERTRACKVERT; break;
 641                 default: break;
 642             }
 643
 644             if( nState & ControlState::PRESSED )
 645                 iState = SCRBS_PRESSED;
 646             else if( !(nState & ControlState::ENABLED) )
 647                 iState = SCRBS_DISABLED;
 648             else if( nState & ControlState::ROLLOVER )
 649                 iState = SCRBS_HOT;
 650             else
 651                 iState = SCRBS_NORMAL;
 652             hr = vsAPI.DrawThemeBackground( hTheme, hDC, iPart, iState, &rc, nullptr);
 653             return (hr == S_OK);
 654         }
 655     }
 656     if( nType == ControlType::SpinButtons && nPart == ControlPart::AllButtons )
 657     {
 658         if( aValue.getType() == ControlType::SpinButtons )
 659         {
 660             const SpinbuttonValue* pValue = (aValue.getType() == ControlType::SpinButtons) ? static_cast<const SpinbuttonValue*>(&aValue) : nullptr;
 661
 662             RECT rect;
 663             ImplConvertSpinbuttonValues( pValue->mnUpperPart, pValue->mnUpperState, pValue->maUpperRect, &iPart, &iState, &rect );
 664             bool bOk = ImplDrawTheme( hTheme, hDC, iPart, iState, rect, aCaption);
 665
 666             if( bOk )
 667             {
 668                 ImplConvertSpinbuttonValues( pValue->mnLowerPart, pValue->mnLowerState, pValue->maLowerRect, &iPart, &iState, &rect );
 669                 bOk = ImplDrawTheme( hTheme, hDC, iPart, iState, rect, aCaption);
 670             }
 671
 672             return bOk;
 673         }
 674     }
 675     if( nType == ControlType::Spinbox )
 676     {
 677         if( nPart == ControlPart::AllButtons )
 678         {
 679             if( aValue.getType() == ControlType::SpinButtons )
 680             {
 681                 const SpinbuttonValue *pValue = static_cast<const SpinbuttonValue*>(&aValue);
 682
 683                 RECT rect;
 684                 ImplConvertSpinbuttonValues( pValue->mnUpperPart, pValue->mnUpperState, pValue->maUpperRect, &iPart, &iState, &rect );
 685                 bool bOk = ImplDrawTheme( hTheme, hDC, iPart, iState, rect, aCaption);
 686
 687                 if( bOk )
 688                 {
 689                     ImplConvertSpinbuttonValues( pValue->mnLowerPart, pValue->mnLowerState, pValue->maLowerRect, &iPart, &iState, &rect );
 690                     bOk = ImplDrawTheme( hTheme, hDC, iPart, iState, rect, aCaption);
 691                 }
 692
 693                 return bOk;
 694             }
 695         }
 696
 697         if( nPart == ControlPart::ButtonDown )
 698         {
 699             iPart = SPNP_DOWN;
 700             if( nState & ControlState::PRESSED )
 701                 iState = DNS_PRESSED;
 702             else if( !(nState & ControlState::ENABLED) )
 703                 iState = DNS_DISABLED;
 704             else if( nState & ControlState::ROLLOVER )
 705                 iState = DNS_HOT;
 706             else
 707                 iState = DNS_NORMAL;
 708         }
 709         if( nPart == ControlPart::ButtonUp )
 710         {
 711             iPart = SPNP_UP;
 712             if( nState & ControlState::PRESSED )
 713                 iState = UPS_PRESSED;
 714             else if( !(nState & ControlState::ENABLED) )
 715                 iState = UPS_DISABLED;
 716             else if( nState & ControlState::ROLLOVER )
 717                 iState = UPS_HOT;
 718             else
 719                 iState = UPS_NORMAL;
 720         }
 721         if( nPart == ControlPart::ButtonRight )
 722         {
 723             iPart = SPNP_DOWNHORZ;
 724             if( nState & ControlState::PRESSED )
 725                 iState = DNHZS_PRESSED;
 726             else if( !(nState & ControlState::ENABLED) )
 727                 iState = DNHZS_DISABLED;
 728             else if( nState & ControlState::ROLLOVER )
 729                 iState = DNHZS_HOT;
 730             else
 731                 iState = DNHZS_NORMAL;
 732         }
 733         if( nPart == ControlPart::ButtonLeft )
 734         {
 735             iPart = SPNP_UPHORZ;
 736             if( nState & ControlState::PRESSED )
 737                 iState = UPHZS_PRESSED;
 738             else if( !(nState & ControlState::ENABLED) )
 739                 iState = UPHZS_DISABLED;
 740             else if( nState & ControlState::ROLLOVER )
 741                 iState = UPHZS_HOT;
 742             else
 743                 iState = UPHZS_NORMAL;
 744         }
 745         if( nPart == ControlPart::ButtonLeft || nPart == ControlPart::ButtonRight || nPart == ControlPart::ButtonUp || nPart == ControlPart::ButtonDown )
 746             return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 747     }
 748     if( nType == ControlType::Combobox )
 749     {
 750         if( nPart == ControlPart::ButtonDown )
 751         {
 752             iPart = CP_DROPDOWNBUTTON;
 753             if( nState & ControlState::PRESSED )
 754                 iState = CBXS_PRESSED;
 755             else if( !(nState & ControlState::ENABLED) )
 756                 iState = CBXS_DISABLED;
 757             else if( nState & ControlState::ROLLOVER )
 758                 iState = CBXS_HOT;
 759             else
 760                 iState = CBXS_NORMAL;
 761             return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 762         }
 763     }
 764     if( nType == ControlType::Pushbutton )
 765     {
 766         iPart = BP_PUSHBUTTON;
 767         if( nState & ControlState::PRESSED )
 768             iState = PBS_PRESSED;
 769         else if( !(nState & ControlState::ENABLED) )
 770             iState = PBS_DISABLED;
 771         else if( nState & ControlState::ROLLOVER )
 772             iState = PBS_HOT;
 773         else if( nState & ControlState::DEFAULT )
 774             iState = PBS_DEFAULTED;
 775         //else if( nState & ControlState::FOCUSED )
 776         //    iState = PBS_DEFAULTED;    // may need to draw focus rect
 777         else
 778             iState = PBS_NORMAL;
 779
 780         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 781     }
 782
 783     if( nType == ControlType::Radiobutton )
 784     {
 785         iPart = BP_RADIOBUTTON;
 786         bool bChecked = ( aValue.getTristateVal() == ButtonValue::On );
 787
 788         if( nState & ControlState::PRESSED )
 789             iState = bChecked ? RBS_CHECKEDPRESSED : RBS_UNCHECKEDPRESSED;
 790         else if( !(nState & ControlState::ENABLED) )
 791             iState = bChecked ? RBS_CHECKEDDISABLED : RBS_UNCHECKEDDISABLED;
 792         else if( nState & ControlState::ROLLOVER )
 793             iState = bChecked ? RBS_CHECKEDHOT : RBS_UNCHECKEDHOT;
 794         else
 795             iState = bChecked ? RBS_CHECKEDNORMAL : RBS_UNCHECKEDNORMAL;
 796
 797         //if( nState & ControlState::FOCUSED )
 798         //    iState |= PBS_DEFAULTED;    // may need to draw focus rect
 799
 800         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 801     }
 802
 803     if( nType == ControlType::Checkbox )
 804     {
 805         iPart = BP_CHECKBOX;
 806         ButtonValue v = aValue.getTristateVal();
 807
 808         if( nState & ControlState::PRESSED )
 809             iState = (v == ButtonValue::On)  ? CBS_CHECKEDPRESSED :
 810                     ( (v == ButtonValue::Off) ? CBS_UNCHECKEDPRESSED : CBS_MIXEDPRESSED );
 811         else if( !(nState & ControlState::ENABLED) )
 812             iState = (v == ButtonValue::On)  ? CBS_CHECKEDDISABLED :
 813                     ( (v == ButtonValue::Off) ? CBS_UNCHECKEDDISABLED : CBS_MIXEDDISABLED );
 814         else if( nState & ControlState::ROLLOVER )
 815             iState = (v == ButtonValue::On)  ? CBS_CHECKEDHOT :
 816                     ( (v == ButtonValue::Off) ? CBS_UNCHECKEDHOT : CBS_MIXEDHOT );
 817         else
 818             iState = (v == ButtonValue::On)  ? CBS_CHECKEDNORMAL :
 819                     ( (v == ButtonValue::Off) ? CBS_UNCHECKEDNORMAL : CBS_MIXEDNORMAL );
 820
 821         //if( nState & ControlState::FOCUSED )
 822         //    iState |= PBS_DEFAULTED;    // may need to draw focus rect
 823
 824         //SIZE sz;
 825         //THEMESIZE eSize = TS_DRAW; // TS_MIN, TS_TRUE, TS_DRAW
 826         //vsAPI.GetThemePartSize( hTheme, hDC, iPart, iState, &rc, eSize, &sz);
 827
 828         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 829     }
 830
 831     if( ( nType == ControlType::Editbox ) || ( nType == ControlType::MultilineEditbox ) )
 832     {
 833         iPart = EP_EDITTEXT;
 834         if( !(nState & ControlState::ENABLED) )
 835             iState = ETS_DISABLED;
 836         else if( nState & ControlState::FOCUSED )
 837             iState = ETS_FOCUSED;
 838         else if( nState & ControlState::ROLLOVER )
 839             iState = ETS_HOT;
 840         else
 841             iState = ETS_NORMAL;
 842
 843         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 844     }
 845
 846     if( nType == ControlType::Listbox )
 847     {
 848         if( nPart == ControlPart::Entire || nPart == ControlPart::ListboxWindow )
 849         {
 850             iPart = LVP_EMPTYTEXT; // ??? no idea which part to choose here
 851             return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 852         }
 853     }
 854
 855     if( nType == ControlType::TabPane )
 856     {
 857         iPart = TABP_PANE;
 858         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 859     }
 860
 861     if( nType == ControlType::TabBody )
 862     {
 863         iPart = TABP_BODY;
 864         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 865     }
 866
 867     if( nType == ControlType::TabItem )
 868     {
 869         iPart = TABP_TABITEMLEFTEDGE;
 870         rc.bottom--;
 871
 872         OSL_ASSERT( aValue.getType() == ControlType::TabItem );
 873
 874         const TabitemValue& rValue = static_cast<const TabitemValue&>(aValue);
 875         if (rValue.isBothAligned())
 876         {
 877             iPart = TABP_TABITEMLEFTEDGE;
 878             rc.right--;
 879         }
 880         else if (rValue.isLeftAligned())
 881             iPart = TABP_TABITEMLEFTEDGE;
 882         else if (rValue.isRightAligned())
 883             iPart = TABP_TABITEMRIGHTEDGE;
 884         else iPart = TABP_TABITEM;
 885
 886         if( !(nState & ControlState::ENABLED) )
 887             iState = TILES_DISABLED;
 888         else if( nState & ControlState::SELECTED )
 889         {
 890             iState = TILES_SELECTED;
 891             // increase the selected tab
 892             rc.left-=2;
 893             if (rValue.isBothAligned())
 894             {
 895                 if (rValue.isLeftAligned() || rValue.isNotAligned())
 896                     rc.right+=2;
 897                 if (rValue.isRightAligned())
 898                     rc.right+=1;
 899             }
 900             rc.top-=2;
 901             rc.bottom+=2;
 902         }
 903         else if( nState & ControlState::ROLLOVER )
 904             iState = TILES_HOT;
 905         else if( nState & ControlState::FOCUSED )
 906             iState = TILES_FOCUSED;    // may need to draw focus rect
 907         else
 908             iState = TILES_NORMAL;
 909         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 910     }
 911
 912     if( nType == ControlType::Toolbar )
 913     {
 914         if( nPart == ControlPart::Button )
 915         {
 916             iPart = TP_BUTTON;
 917             bool bChecked = ( aValue.getTristateVal() == ButtonValue::On );
 918             if( !(nState & ControlState::ENABLED) )
 919                 //iState = TS_DISABLED;
 920                 // disabled buttons are typically not painted at all but we need visual
 921                 // feedback when travelling by keyboard over disabled entries
 922                 iState = TS_HOT;
 923             else if( nState & ControlState::PRESSED )
 924                 iState = TS_PRESSED;
 925             else if( nState & ControlState::ROLLOVER )
 926                 iState = bChecked ? TS_HOTCHECKED : TS_HOT;
 927             else
 928                 iState = bChecked ? TS_CHECKED : TS_NORMAL;
 929             return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 930         }
 931         else if( nPart == ControlPart::ThumbHorz || nPart == ControlPart::ThumbVert )
 932         {
 933             // the vertical gripper is not supported in most themes and it makes no
 934             // sense to only support horizontal gripper
 935             //iPart = (nPart == ControlPart::ThumbHorz) ? RP_GRIPPERVERT : RP_GRIPPER;
 936             //return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 937         }
 938         else if( nPart == ControlPart::DrawBackgroundHorz || nPart == ControlPart::DrawBackgroundVert )
 939         {
 940             if( aValue.getType() == ControlType::Toolbar )
 941             {
 942                 const ToolbarValue *pValue = static_cast<const ToolbarValue*>(&aValue);
 943                 if( pValue->mbIsTopDockingArea )
 944                     rc.top = 0; // extend potential gradient to cover menu bar as well
 945             }
 946
 947             // make it more compatible with Aero
 948             if( ImplGetSVData()->maNWFData.mbDockingAreaAvoidTBFrames )
 949             {
 950                 impl_drawAeroToolbar( hDC, rc, nPart == ControlPart::DrawBackgroundHorz );
 951                 return true;
 952             }
 953
 954             return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 955         }
 956     }
 957
 958     if( nType == ControlType::Menubar )
 959     {
 960         if( nPart == ControlPart::Entire )
 961         {
 962             if( aValue.getType() == ControlType::Menubar )
 963             {
 964                 const MenubarValue *pValue = static_cast<const MenubarValue*>(&aValue);
 965                 rc.bottom += pValue->maTopDockingAreaHeight;    // extend potential gradient to cover docking area as well
 966
 967                 // make it more compatible with Aero
 968                 if( ImplGetSVData()->maNWFData.mbDockingAreaAvoidTBFrames )
 969                 {
 970                     impl_drawAeroToolbar( hDC, rc, true );
 971                     return true;
 972                 }
 973             }
 974             return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption);
 975         }
 976         else if( nPart == ControlPart::MenuItem )
 977         {
 978             if( nState & ControlState::ENABLED )
 979             {
 980                 if( nState & ControlState::SELECTED )
 981                     iState = MBI_PUSHED;
 982                 else if( nState & ControlState::ROLLOVER )
 983                     iState = MBI_HOT;
 984                 else
 985                     iState = MBI_NORMAL;
 986             }
 987             else
 988             {
 989                 if( nState & ControlState::SELECTED )
 990                     iState = MBI_DISABLEDPUSHED;
 991                 else if( nState & ControlState::ROLLOVER )
 992                     iState = MBI_DISABLEDHOT;
 993                 else
 994                     iState = MBI_DISABLED;
 995             }
 996             return ImplDrawTheme( hTheme, hDC, MENU_BARITEM, iState, rc, aCaption );
 997         }
 998     }
 999
1000     if( nType == ControlType::Progress )
1001     {
1002         if( nPart != ControlPart::Entire )
1003             return false;
1004
1005         if( ! ImplDrawTheme( hTheme, hDC, PP_BAR, iState, rc, aCaption) )
1006             return false;
1007         RECT aProgressRect = rc;
1008         if( vsAPI.GetThemeBackgroundContentRect( hTheme, hDC, PP_BAR, iState, &rc, &aProgressRect) != S_OK )
1009             return false;
1010
1011         long nProgressWidth = aValue.getNumericVal();
1012         nProgressWidth *= (aProgressRect.right - aProgressRect.left);
1013         nProgressWidth /= (rc.right - rc.left);
1014         if( AllSettings::GetLayoutRTL() )
1015             aProgressRect.left = aProgressRect.right - nProgressWidth;
1016         else
1017             aProgressRect.right = aProgressRect.left + nProgressWidth;
1018
1019         return ImplDrawTheme( hTheme, hDC, PP_CHUNK, iState, aProgressRect, aCaption );
1020     }
1021
1022     if( nType == ControlType::Slider )
1023     {
1024         iPart = (nPart == ControlPart::TrackHorzArea) ? TKP_TRACK : TKP_TRACKVERT;
1025         iState = (nPart == ControlPart::TrackHorzArea) ? static_cast<int>(TRS_NORMAL) : static_cast<int>(TRVS_NORMAL);
1026
1027         tools::Rectangle aTrackRect = ImplGetThemeRect( hTheme, hDC, iPart, iState, tools::Rectangle() );
1028         RECT aTRect = rc;
1029         if( nPart == ControlPart::TrackHorzArea )
1030         {
1031             long nH = aTrackRect.GetHeight();
1032             aTRect.top += (rc.bottom - rc.top - nH)/2;
1033             aTRect.bottom = aTRect.top + nH;
1034         }
1035         else
1036         {
1037             long nW = aTrackRect.GetWidth();
1038             aTRect.left += (rc.right - rc.left - nW)/2;
1039             aTRect.right = aTRect.left + nW;
1040         }
1041         ImplDrawTheme( hTheme, hDC, iPart, iState, aTRect, aCaption );
1042
1043         RECT aThumbRect;
1044         OSL_ASSERT( aValue.getType() == ControlType::Slider );
1045         const SliderValue* pVal = static_cast<const SliderValue*>(&aValue);
1046         aThumbRect.left   = pVal->maThumbRect.Left();
1047         aThumbRect.top    = pVal->maThumbRect.Top();
1048         aThumbRect.right  = pVal->maThumbRect.Right();
1049         aThumbRect.bottom = pVal->maThumbRect.Bottom();
1050         iPart = (nPart == ControlPart::TrackHorzArea) ? TKP_THUMB : TKP_THUMBVERT;
1051         iState = (nState & ControlState::ENABLED) ? TUS_NORMAL : TUS_DISABLED;
1052         return ImplDrawTheme( hTheme, hDC, iPart, iState, aThumbRect, aCaption );
1053     }
1054
1055     if( nType == ControlType::ListNode )
1056     {
1057         if( nPart != ControlPart::Entire )
1058             return false;
1059
1060         ButtonValue aButtonValue = aValue.getTristateVal();
1061         iPart = TVP_GLYPH;
1062         switch( aButtonValue )
1063         {
1064         case ButtonValue::On:
1065             iState = GLPS_OPENED;
1066             break;
1067         case ButtonValue::Off:
1068             iState = GLPS_CLOSED;
1069             break;
1070         default:
1071             return false;
1072         }
1073         return ImplDrawTheme( hTheme, hDC, iPart, iState, rc, aCaption );
1074     }
1075
1076     if( GetSalData()->mbThemeMenuSupport )
1077     {
1078         if( nType == ControlType::MenuPopup )
1079         {
1080             if( nPart == ControlPart::Entire )
1081             {
1082                 RECT aGutterRC = rc;
1083                 if( AllSettings::GetLayoutRTL() )
1084                 {
1085                     aGutterRC.right -= aValue.getNumericVal()+1;
1086                     aGutterRC.left = aGutterRC.right-3;
1087                 }
1088                 else
1089                 {
1090                     aGutterRC.left += aValue.getNumericVal();
1091                     aGutterRC.right = aGutterRC.left+3;
1092                 }
1093                 return
1094                 ImplDrawTheme( hTheme, hDC, MENU_POPUPBACKGROUND, 0, rc, aCaption ) &&
1095                 ImplDrawTheme( hTheme, hDC, MENU_POPUPGUTTER, 0, aGutterRC, aCaption )
1096                 ;
1097             }
1098             else if( nPart == ControlPart::MenuItem )
1099             {
1100                 if( nState & ControlState::ENABLED )
1101                     iState = (nState & ControlState::SELECTED) ? MPI_HOT : MPI_NORMAL;
1102                 else
1103                     iState = (nState & ControlState::SELECTED) ? MPI_DISABLEDHOT : MPI_DISABLED;
1104                 return ImplDrawTheme( hTheme, hDC, MENU_POPUPITEM, iState, rc, aCaption );
1105             }
1106             else if( nPart == ControlPart::MenuItemCheckMark || nPart == ControlPart::MenuItemRadioMark )
1107             {
1108                 if( nState & ControlState::PRESSED )
1109                 {
1110                     RECT aBGRect = rc;
1111                     if( aValue.getType() == ControlType::MenuPopup )
1112                     {
1113                         tools::Rectangle aRectangle = GetMenuPopupMarkRegion(aValue);
1114                         aBGRect.top = aRectangle.Top();
1115                         aBGRect.left = aRectangle.Left();
1116                         aBGRect.bottom = aRectangle.Bottom();
1117                         aBGRect.right = aRectangle.Right();
1118                         rc = aBGRect;
1119                     }
1120                     iState = (nState & ControlState::ENABLED) ? MCB_NORMAL : MCB_DISABLED;
1121                     ImplDrawTheme( hTheme, hDC, MENU_POPUPCHECKBACKGROUND, iState, aBGRect, aCaption );
1122                     if( nPart == ControlPart::MenuItemCheckMark )
1123                         iState = (nState & ControlState::ENABLED) ? MC_CHECKMARKNORMAL : MC_CHECKMARKDISABLED;
1124                     else
1125                         iState = (nState & ControlState::ENABLED) ? MC_BULLETNORMAL : MC_BULLETDISABLED;
1126                     return ImplDrawTheme( hTheme, hDC, MENU_POPUPCHECK, iState, rc, aCaption );
1127                 }
1128                 else
1129                     return true; // unchecked: do nothing
1130             }
1131             else if( nPart == ControlPart::Separator )
1132             {
1133                 // adjust for gutter position
1134                 if( AllSettings::GetLayoutRTL() )
1135                     rc.right -= aValue.getNumericVal()+1;
1136                 else
1137                     rc.left += aValue.getNumericVal()+1;
1138                 tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC,
1139                     MENU_POPUPSEPARATOR, 0, tools::Rectangle( rc.left, rc.top, rc.right, rc.bottom ) ) );
1140                 // center the separator inside the passed rectangle
1141                 long nDY = ((rc.bottom - rc.top + 1) - aRect.GetHeight()) / 2;
1142                 rc.top += nDY;
1143                 rc.bottom = rc.top+aRect.GetHeight()-1;
1144                 return ImplDrawTheme( hTheme, hDC, MENU_POPUPSEPARATOR, 0, rc, aCaption );
1145             }
1146         }
1147     }
1148
1149     return false;
1150 }
1151
1152 bool WinSalGraphics::drawNativeControl( ControlType nType,
1153                                         ControlPart nPart,
1154                                         const tools::Rectangle& rControlRegion,
1155                                         ControlState nState,
1156                                         const ImplControlValue& aValue,
1157                                         const OUString& aCaption,
1158                                         const Color& /*rBackgroundColor*/ )
1159 {
1160     bool bOk = false;
1161     HTHEME hTheme = nullptr;
1162
1163     tools::Rectangle buttonRect = rControlRegion;
1164     tools::Rectangle cacheRect = rControlRegion;
1165     Size keySize = cacheRect.GetSize();
1166
1167     WinSalGraphicsImplBase* pImpl = dynamic_cast<WinSalGraphicsImplBase*>(mpImpl.get());
1168     if( !pImpl->UseRenderNativeControl())
1169         pImpl = nullptr;
1170
1171     // tdf#95618 - A few controls render outside the region they're given.
1172     if (pImpl && nType == ControlType::TabItem)
1173     {
1174         tools::Rectangle rNativeBoundingRegion;
1175         tools::Rectangle rNativeContentRegion;
1176         if (getNativeControlRegion(nType, nPart, rControlRegion, nState, aValue, aCaption,
1177                                    rNativeBoundingRegion, rNativeContentRegion))
1178         {
1179             cacheRect = rNativeBoundingRegion;
1180             keySize = rNativeBoundingRegion.GetSize();
1181         }
1182     }
1183
1184     if (pImpl && nType == ControlType::MenuPopup && (nPart == ControlPart::MenuItemCheckMark || nPart == ControlPart::MenuItemRadioMark))
1185     {
1186         tools::Rectangle aRectangle = GetMenuPopupMarkRegion(aValue);
1187         if (!aRectangle.IsEmpty())
1188         {
1189             cacheRect = GetMenuPopupMarkRegion(aValue);
1190             buttonRect = cacheRect;
1191             keySize = cacheRect.GetSize();
1192         }
1193     }
1194
1195
1196     ControlCacheKey aControlCacheKey(nType, nPart, nState, keySize);
1197     if (pImpl != nullptr && pImpl->TryRenderCachedNativeControl(aControlCacheKey, buttonRect.Left(), buttonRect.Top()))
1198     {
1199         return true;
1200     }
1201
1202     switch( nType )
1203     {
1204         case ControlType::Pushbutton:
1205         case ControlType::Radiobutton:
1206         case ControlType::Checkbox:
1207             hTheme = getThemeHandle( mhWnd, L"Button");
1208             break;
1209         case ControlType::Scrollbar:
1210             hTheme = getThemeHandle( mhWnd, L"Scrollbar");
1211             break;
1212         case ControlType::Combobox:
1213             if( nPart == ControlPart::Entire )
1214                 hTheme = getThemeHandle( mhWnd, L"Edit");
1215             else if( nPart == ControlPart::ButtonDown )
1216                 hTheme = getThemeHandle( mhWnd, L"Combobox");
1217             break;
1218         case ControlType::Spinbox:
1219             if( nPart == ControlPart::Entire )
1220                 hTheme = getThemeHandle( mhWnd, L"Edit");
1221             else
1222                 hTheme = getThemeHandle( mhWnd, L"Spin");
1223             break;
1224         case ControlType::SpinButtons:
1225             hTheme = getThemeHandle( mhWnd, L"Spin");
1226             break;
1227         case ControlType::Editbox:
1228         case ControlType::MultilineEditbox:
1229             hTheme = getThemeHandle( mhWnd, L"Edit");
1230             break;
1231         case ControlType::Listbox:
1232             if( nPart == ControlPart::Entire || nPart == ControlPart::ListboxWindow )
1233                 hTheme = getThemeHandle( mhWnd, L"Listview");
1234             else if( nPart == ControlPart::ButtonDown )
1235                 hTheme = getThemeHandle( mhWnd, L"Combobox");
1236             break;
1237         case ControlType::TabPane:
1238         case ControlType::TabBody:
1239         case ControlType::TabItem:
1240             hTheme = getThemeHandle( mhWnd, L"Tab");
1241             break;
1242         case ControlType::Toolbar:
1243             if( nPart == ControlPart::Entire || nPart == ControlPart::Button )
1244                 hTheme = getThemeHandle( mhWnd, L"Toolbar");
1245             else
1246                 // use rebar for grip and background
1247                 hTheme = getThemeHandle( mhWnd, L"Rebar");
1248             break;
1249         case ControlType::Menubar:
1250             if( nPart == ControlPart::Entire )
1251                 hTheme = getThemeHandle( mhWnd, L"Rebar");
1252             else if( GetSalData()->mbThemeMenuSupport )
1253             {
1254                 if( nPart == ControlPart::MenuItem )
1255                     hTheme = getThemeHandle( mhWnd, L"Menu" );
1256             }
1257             break;
1258         case ControlType::Progress:
1259             if( nPart == ControlPart::Entire )
1260                 hTheme = getThemeHandle( mhWnd, L"Progress");
1261             break;
1262         case ControlType::ListNode:
1263             if( nPart == ControlPart::Entire )
1264                 hTheme = getThemeHandle( mhWnd, L"TreeView");
1265             break;
1266         case ControlType::Slider:
1267             if( nPart == ControlPart::TrackHorzArea || nPart == ControlPart::TrackVertArea )
1268                 hTheme = getThemeHandle( mhWnd, L"Trackbar" );
1269             break;
1270         case ControlType::MenuPopup:
1271             if( GetSalData()->mbThemeMenuSupport )
1272             {
1273                 if( nPart == ControlPart::Entire || nPart == ControlPart::MenuItem ||
1274                     nPart == ControlPart::MenuItemCheckMark || nPart == ControlPart::MenuItemRadioMark ||
1275                     nPart == ControlPart::Separator
1276                     )
1277                     hTheme = getThemeHandle( mhWnd, L"Menu" );
1278             }
1279             break;
1280         default:
1281             hTheme = nullptr;
1282             break;
1283     }
1284
1285     if( !hTheme )
1286         return false;
1287
1288     RECT rc;
1289     rc.left   = buttonRect.Left();
1290     rc.right  = buttonRect.Right()+1;
1291     rc.top    = buttonRect.Top();
1292     rc.bottom = buttonRect.Bottom()+1;
1293
1294     OUString aCaptionStr(aCaption.replace('~', '&')); // translate mnemonics
1295
1296     if (pImpl == nullptr)
1297     {
1298         // set default text alignment
1299         int ta = SetTextAlign(getHDC(), TA_LEFT|TA_TOP|TA_NOUPDATECP);
1300
1301         bOk = ImplDrawNativeControl(getHDC(), hTheme, rc, nType, nPart, nState, aValue, aCaptionStr);
1302
1303         // restore alignment
1304         SetTextAlign(getHDC(), ta);
1305     }
1306     else
1307     {
1308         // We can do OpenGL/Skia
1309         std::unique_ptr<CompatibleDC> aBlackDC(CompatibleDC::create(*this, cacheRect.Left(), cacheRect.Top(), cacheRect.GetWidth()+1, cacheRect.GetHeight()+1));
1310         SetTextAlign(aBlackDC->getCompatibleHDC(), TA_LEFT|TA_TOP|TA_NOUPDATECP);
1311         aBlackDC->fill(RGB(0, 0, 0));
1312
1313         std::unique_ptr<CompatibleDC> aWhiteDC(CompatibleDC::create(*this, cacheRect.Left(), cacheRect.Top(), cacheRect.GetWidth()+1, cacheRect.GetHeight()+1));
1314         SetTextAlign(aWhiteDC->getCompatibleHDC(), TA_LEFT|TA_TOP|TA_NOUPDATECP);
1315         aWhiteDC->fill(RGB(0xff, 0xff, 0xff));
1316
1317         if (ImplDrawNativeControl(aBlackDC->getCompatibleHDC(), hTheme, rc, nType, nPart, nState, aValue, aCaptionStr) &&
1318             ImplDrawNativeControl(aWhiteDC->getCompatibleHDC(), hTheme, rc, nType, nPart, nState, aValue, aCaptionStr))
1319         {
1320             bOk = pImpl->RenderAndCacheNativeControl(*aWhiteDC, *aBlackDC, cacheRect.Left(), cacheRect.Top(), aControlCacheKey);
1321         }
1322     }
1323
1324     return bOk;
1325 }
1326
1327 bool WinSalGraphics::getNativeControlRegion(  ControlType nType,
1328                                 ControlPart nPart,
1329                                 const tools::Rectangle& rControlRegion,
1330                                 ControlState nState,
1331                                 const ImplControlValue& rControlValue,
1332                                 const OUString&,
1333                                 tools::Rectangle &rNativeBoundingRegion,
1334                                 tools::Rectangle &rNativeContentRegion )
1335 {
1336     bool bRet = false;
1337
1338     // FIXME: rNativeBoundingRegion has a different origin
1339     //        depending on which part is used; horrors.
1340
1341     HDC hDC = GetDC( mhWnd );
1342     if( nType == ControlType::Toolbar )
1343     {
1344         if( nPart == ControlPart::ThumbHorz || nPart == ControlPart::ThumbVert )
1345         {
1346             /*
1347             // the vertical gripper is not supported in most themes and it makes no
1348             // sense to only support horizontal gripper
1349
1350             HTHEME hTheme = getThemeHandle( mhWnd, L"Rebar");
1351             if( hTheme )
1352             {
1353             tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC, nPart == ControlPart::ThumbHorz ? RP_GRIPPERVERT : RP_GRIPPER,
1354                     0, rControlRegion.GetBoundRect() ) );
1355                 if( nPart == ControlPart::ThumbHorz && !aRect.IsEmpty() )
1356                 {
1357                     tools::Rectangle aVertRect( 0, 0, aRect.getHeight(), aRect.getWidth() );
1358                     rNativeContentRegion = aVertRect;
1359                 }
1360                 else
1361                     rNativeContentRegion = aRect;
1362                 rNativeBoundingRegion = rNativeContentRegion;
1363                 if( !rNativeContentRegion.IsEmpty() )
1364                     bRet = TRUE;
1365             }
1366             */
1367         }
1368         if( nPart == ControlPart::Button )
1369         {
1370             HTHEME hTheme = getThemeHandle( mhWnd, L"Toolbar");
1371             if( hTheme )
1372             {
1373                 tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC, TP_SPLITBUTTONDROPDOWN,
1374                     TS_HOT, rControlRegion ) );
1375                 rNativeContentRegion = aRect;
1376                 rNativeBoundingRegion = rNativeContentRegion;
1377                 if( !rNativeContentRegion.IsEmpty() )
1378                     bRet = true;
1379             }
1380         }
1381     }
1382     if( nType == ControlType::Progress && nPart == ControlPart::Entire )
1383     {
1384         HTHEME hTheme = getThemeHandle( mhWnd, L"Progress");
1385         if( hTheme )
1386         {
1387             tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC, PP_BAR,
1388                 0, rControlRegion ) );
1389             rNativeContentRegion = aRect;
1390             rNativeBoundingRegion = rNativeContentRegion;
1391             if( !rNativeContentRegion.IsEmpty() )
1392                 bRet = true;
1393         }
1394     }
1395     if( (nType == ControlType::Listbox || nType == ControlType::Combobox ) && nPart == ControlPart::Entire )
1396     {
1397         HTHEME hTheme = getThemeHandle( mhWnd, L"Combobox");
1398         if( hTheme )
1399         {
1400             tools::Rectangle aBoxRect( rControlRegion );
1401             tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC, CP_DROPDOWNBUTTON,
1402                                                CBXS_NORMAL, aBoxRect ) );
1403             if( aRect.GetHeight() > aBoxRect.GetHeight() )
1404                 aBoxRect.SetBottom( aBoxRect.Top() + aRect.GetHeight() );
1405             if( aRect.GetWidth() > aBoxRect.GetWidth() )
1406                 aBoxRect.SetRight( aBoxRect.Left() + aRect.GetWidth() );
1407             rNativeContentRegion = aBoxRect;
1408             rNativeBoundingRegion = rNativeContentRegion;
1409             if( !aRect.IsEmpty() )
1410                 bRet = true;
1411         }
1412     }
1413
1414     if( (nType == ControlType::Editbox || nType == ControlType::Spinbox) && nPart == ControlPart::Entire )
1415     {
1416         HTHEME hTheme = getThemeHandle( mhWnd, L"Edit");
1417         if( hTheme )
1418         {
1419             // get border size
1420             tools::Rectangle aBoxRect( rControlRegion );
1421             tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC, EP_BACKGROUNDWITHBORDER,
1422                                                EBWBS_HOT, aBoxRect ) );
1423             // ad app font height
1424             NONCLIENTMETRICSW aNonClientMetrics;
1425             aNonClientMetrics.cbSize = sizeof( aNonClientMetrics );
1426             if ( SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, sizeof( aNonClientMetrics ), &aNonClientMetrics, 0 ) )
1427             {
1428                 long nFontHeight = aNonClientMetrics.lfMessageFont.lfHeight;
1429                 if( nFontHeight < 0 )
1430                     nFontHeight = -nFontHeight;
1431
1432                 if( aRect.GetHeight() && nFontHeight )
1433                 {
1434                     aRect.AdjustBottom(aRect.GetHeight());
1435                     aRect.AdjustBottom(nFontHeight);
1436                     if( aRect.GetHeight() > aBoxRect.GetHeight() )
1437                         aBoxRect.SetBottom( aBoxRect.Top() + aRect.GetHeight() );
1438                     if( aRect.GetWidth() > aBoxRect.GetWidth() )
1439                         aBoxRect.SetRight( aBoxRect.Left() + aRect.GetWidth() );
1440                     rNativeContentRegion = aBoxRect;
1441                     rNativeBoundingRegion = rNativeContentRegion;
1442                     bRet = true;
1443                 }
1444             }
1445         }
1446     }
1447
1448     if( GetSalData()->mbThemeMenuSupport )
1449     {
1450         if( nType == ControlType::MenuPopup )
1451         {
1452             if( nPart == ControlPart::MenuItemCheckMark ||
1453                 nPart == ControlPart::MenuItemRadioMark )
1454             {
1455                 HTHEME hTheme = getThemeHandle( mhWnd, L"Menu");
1456                 tools::Rectangle aBoxRect( rControlRegion );
1457                 tools::Rectangle aRect( ImplGetThemeRect( hTheme, hDC,
1458                     MENU_POPUPCHECK,
1459                     MC_CHECKMARKNORMAL,
1460                     aBoxRect ) );
1461                 if( aBoxRect.GetWidth() && aBoxRect.GetHeight() )
1462                 {
1463                     rNativeContentRegion = aRect;
1464                     rNativeBoundingRegion = rNativeContentRegion;
1465                     bRet = true;
1466                 }
1467             }
1468         }
1469     }
1470
1471     if( nType == ControlType::Slider && ( (nPart == ControlPart::ThumbHorz) || (nPart == ControlPart::ThumbVert) ) )
1472     {
1473         HTHEME hTheme = getThemeHandle( mhWnd, L"Trackbar");
1474         if( hTheme )
1475         {
1476             int iPart = (nPart == ControlPart::ThumbHorz) ? TKP_THUMB : TKP_THUMBVERT;
1477             int iState = (nPart == ControlPart::ThumbHorz) ? static_cast<int>(TUS_NORMAL) : static_cast<int>(TUVS_NORMAL);
1478             tools::Rectangle aThumbRect = ImplGetThemeRect( hTheme, hDC, iPart, iState, tools::Rectangle() );
1479             if( nPart == ControlPart::ThumbHorz )
1480             {
1481                 long nW = aThumbRect.GetWidth();
1482                 tools::Rectangle aRect( rControlRegion );
1483                 aRect.SetRight( aRect.Left() + nW - 1 );
1484                 rNativeContentRegion = aRect;
1485                 rNativeBoundingRegion = rNativeContentRegion;
1486             }
1487             else
1488             {
1489                 long nH = aThumbRect.GetHeight();
1490                 tools::Rectangle aRect( rControlRegion );
1491                 aRect.SetBottom( aRect.Top() + nH - 1 );
1492                 rNativeContentRegion = aRect;
1493                 rNativeBoundingRegion = rNativeContentRegion;
1494             }
1495             bRet = true;
1496         }
1497     }
1498
1499     if ( ( nType == ControlType::TabItem ) && ( nPart == ControlPart::Entire ) )
1500     {
1501         tools::Rectangle aControlRect( rControlRegion );
1502         rNativeContentRegion = aControlRect;
1503
1504         aControlRect.AdjustBottom(-1);
1505
1506         if( rControlValue.getType() == ControlType::TabItem )
1507         {
1508             const TabitemValue& rValue = static_cast<const TabitemValue&>(rControlValue);
1509             if (rValue.isBothAligned())
1510                 aControlRect.AdjustRight(-1);
1511
1512             if ( nState & ControlState::SELECTED )
1513             {
1514                 aControlRect.AdjustLeft(-2);
1515                 if (!rValue.isBothAligned())
1516                 {
1517                     if (rValue.isLeftAligned() || rValue.isNotAligned())
1518                         aControlRect.AdjustRight(2);
1519                     if (rValue.isRightAligned())
1520                         aControlRect.AdjustRight(1);
1521                 }
1522                 aControlRect.AdjustTop(-2);
1523                 aControlRect.AdjustBottom(2);
1524             }
1525         }
1526         rNativeBoundingRegion = aControlRect;
1527         bRet = true;
1528     }
1529
1530     ReleaseDC( mhWnd, hDC );
1531     return bRet;
1532 }
1533
1534 void WinSalGraphics::updateSettingsNative( AllSettings& rSettings )
1535 {
1536     if ( !vsAPI.IsThemeActive() )
1537         return;
1538
1539     StyleSettings aStyleSettings = rSettings.GetStyleSettings();
1540     ImplSVData* pSVData = ImplGetSVData();
1541
1542     // don't draw frame around each and every toolbar
1543     pSVData->maNWFData.mbDockingAreaAvoidTBFrames = true;
1544
1545     // FIXME get the color directly from the theme, not from the settings
1546     Color aMenuBarTextColor = aStyleSettings.GetPersonaMenuBarTextColor().value_or( aStyleSettings.GetMenuTextColor() );
1547     // in aero menuitem highlight text is drawn in the same color as normal
1548     aStyleSettings.SetMenuHighlightTextColor( aStyleSettings.GetMenuTextColor() );
1549     aStyleSettings.SetMenuBarRolloverTextColor( aMenuBarTextColor );
1550     aStyleSettings.SetMenuBarHighlightTextColor( aMenuBarTextColor );
1551     pSVData->maNWFData.mnMenuFormatBorderX = 2;
1552     pSVData->maNWFData.mnMenuFormatBorderY = 2;
1553     pSVData->maNWFData.maMenuBarHighlightTextColor = aMenuBarTextColor;
1554     GetSalData()->mbThemeMenuSupport = true;
1555
1556     rSettings.SetStyleSettings( aStyleSettings );
1557 }
1558
1559 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */