src/msw/renderer.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/renderer.cpp
   3 // Purpose:     implementation of wxRendererNative for Windows
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     20.07.2003
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
   9 // License:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // for compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/string.h"
  29     #include "wx/window.h"
  30     #include "wx/dc.h"
  31     #include "wx/settings.h"
  32 #endif //WX_PRECOMP
  33
  34 #include "wx/scopeguard.h"
  35 #include "wx/splitter.h"
  36 #include "wx/renderer.h"
  37 #include "wx/msw/private.h"
  38 #include "wx/msw/uxtheme.h"
  39
  40 // tmschema.h is in Win32 Platform SDK and might not be available with earlier
  41 // compilers
  42 #ifndef CP_DROPDOWNBUTTON
  43     #define BP_PUSHBUTTON      1
  44     #define BP_RADIOBUTTON     2
  45     #define BP_CHECKBOX        3
  46     #define RBS_UNCHECKEDNORMAL 1
  47     #define RBS_CHECKEDNORMAL   (RBS_UNCHECKEDNORMAL + 4)
  48     #define RBS_MIXEDNORMAL     (RBS_CHECKEDNORMAL + 4)
  49     #define CBS_UNCHECKEDNORMAL 1
  50     #define CBS_CHECKEDNORMAL   (CBS_UNCHECKEDNORMAL + 4)
  51     #define CBS_MIXEDNORMAL     (CBS_CHECKEDNORMAL + 4)
  52
  53     #define PBS_NORMAL          1
  54     #define PBS_HOT             2
  55     #define PBS_PRESSED         3
  56     #define PBS_DISABLED        4
  57     #define PBS_DEFAULTED       5
  58
  59     #define CP_DROPDOWNBUTTON  1
  60
  61     #define CBXS_NORMAL        1
  62     #define CBXS_HOT           2
  63     #define CBXS_PRESSED       3
  64     #define CBXS_DISABLED      4
  65
  66     #define TVP_GLYPH           2
  67
  68     #define GLPS_CLOSED         1
  69     #define GLPS_OPENED         2
  70
  71     #define HP_HEADERITEM       1
  72
  73     #define HIS_NORMAL          1
  74     #define HIS_HOT             2
  75     #define HIS_PRESSED         3
  76
  77     #define TMT_HEIGHT          2417
  78
  79     #define HP_HEADERSORTARROW  4
  80     #define HSAS_SORTEDUP       1
  81     #define HSAS_SORTEDDOWN     2
  82
  83     #define EP_EDITTEXT         1
  84     #define ETS_NORMAL          1
  85     #define ETS_HOT             2
  86     #define ETS_SELECTED        3
  87     #define ETS_DISABLED        4
  88     #define ETS_FOCUSED         5
  89     #define ETS_READONLY        6
  90     #define ETS_ASSIST          7
  91     #define TMT_FILLCOLOR       3802
  92     #define TMT_TEXTCOLOR       3803
  93     #define TMT_BORDERCOLOR     3801
  94     #define TMT_EDGEFILLCOLOR   3808
  95 #endif
  96
  97 #if defined(__WXWINCE__)
  98     #ifndef DFCS_FLAT
  99         #define DFCS_FLAT 0
 100     #endif
 101     #ifndef DFCS_MONO
 102         #define DFCS_MONO 0
 103     #endif
 104 #endif
 105
 106 #ifndef DFCS_HOT
 107     #define DFCS_HOT 0x1000
 108 #endif
 109
 110 // ----------------------------------------------------------------------------
 111 // methods common to wxRendererMSW and wxRendererXP
 112 // ----------------------------------------------------------------------------
 113
 114 class wxRendererMSWBase : public wxDelegateRendererNative
 115 {
 116 public:
 117     wxRendererMSWBase() { }
 118     wxRendererMSWBase(wxRendererNative& rendererNative)
 119         : wxDelegateRendererNative(rendererNative) { }
 120
 121     void DrawFocusRect(wxWindow * win,
 122                         wxDC& dc,
 123                         const wxRect& rect,
 124                         int flags = 0);
 125
 126     void DrawItemSelectionRect(wxWindow *win,
 127                                 wxDC& dc,
 128                                 const wxRect& rect,
 129                                 int flags = 0);
 130 };
 131
 132 // ----------------------------------------------------------------------------
 133 // wxRendererMSW: wxRendererNative implementation for "old" Win32 systems
 134 // ----------------------------------------------------------------------------
 135
 136 class wxRendererMSW : public wxRendererMSWBase
 137 {
 138 public:
 139     wxRendererMSW() { }
 140
 141     static wxRendererNative& Get();
 142
 143     virtual void DrawComboBoxDropButton(wxWindow *win,
 144                                         wxDC& dc,
 145                                         const wxRect& rect,
 146                                         int flags = 0);
 147
 148     virtual void DrawCheckBox(wxWindow *win,
 149                               wxDC& dc,
 150                               const wxRect& rect,
 151                               int flags = 0)
 152     {
 153         DoDrawButton(DFCS_BUTTONCHECK, win, dc, rect, flags);
 154     }
 155
 156     virtual void DrawPushButton(wxWindow *win,
 157                                 wxDC& dc,
 158                                 const wxRect& rect,
 159                                 int flags = 0);
 160
 161     virtual void DrawChoice(wxWindow* win,
 162                             wxDC& dc,
 163                             const wxRect& rect,
 164                             int flags = 0);
 165
 166     virtual void DrawComboBox(wxWindow* win,
 167                               wxDC& dc,
 168                               const wxRect& rect,
 169                               int flags = 0);
 170
 171     virtual void DrawTextCtrl(wxWindow* win,
 172                               wxDC& dc,
 173                               const wxRect& rect,
 174                               int flags = 0);
 175
 176     virtual void DrawRadioBitmap(wxWindow* win,
 177                                  wxDC& dc,
 178                                  const wxRect& rect,
 179                                  int flags = 0)
 180     {
 181         DoDrawButton(DFCS_BUTTONRADIO, win, dc, rect, flags);
 182     }
 183
 184     virtual wxSize GetCheckBoxSize(wxWindow *win);
 185
 186     virtual int GetHeaderButtonHeight(wxWindow *win);
 187
 188 private:
 189     // common part of Draw{PushButton,CheckBox,RadioBitmap}(): wraps
 190     // DrawFrameControl(DFC_BUTTON)
 191     void DoDrawButton(UINT kind,
 192                       wxWindow *win,
 193                       wxDC& dc,
 194                       const wxRect& rect,
 195                       int flags);
 196
 197     wxDECLARE_NO_COPY_CLASS(wxRendererMSW);
 198 };
 199
 200 // ----------------------------------------------------------------------------
 201 // wxRendererXP: wxRendererNative implementation for Windows XP and later
 202 // ----------------------------------------------------------------------------
 203
 204 #if wxUSE_UXTHEME
 205
 206 class wxRendererXP : public wxRendererMSWBase
 207 {
 208 public:
 209     wxRendererXP() : wxRendererMSWBase(wxRendererMSW::Get()) { }
 210
 211     static wxRendererNative& Get();
 212
 213     virtual int DrawHeaderButton(wxWindow *win,
 214                                   wxDC& dc,
 215                                   const wxRect& rect,
 216                                   int flags = 0,
 217                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 218                                   wxHeaderButtonParams* params = NULL);
 219
 220     virtual void DrawTreeItemButton(wxWindow *win,
 221                                     wxDC& dc,
 222                                     const wxRect& rect,
 223                                     int flags = 0);
 224     virtual void DrawSplitterBorder(wxWindow *win,
 225                                     wxDC& dc,
 226                                     const wxRect& rect,
 227                                     int flags = 0);
 228     virtual void DrawSplitterSash(wxWindow *win,
 229                                   wxDC& dc,
 230                                   const wxSize& size,
 231                                   wxCoord position,
 232                                   wxOrientation orient,
 233                                   int flags = 0);
 234     virtual void DrawComboBoxDropButton(wxWindow *win,
 235                                         wxDC& dc,
 236                                         const wxRect& rect,
 237                                         int flags = 0);
 238     virtual void DrawCheckBox(wxWindow *win,
 239                               wxDC& dc,
 240                               const wxRect& rect,
 241                               int flags = 0)
 242     {
 243         if ( !DoDrawXPButton(BP_CHECKBOX, win, dc, rect, flags) )
 244             m_rendererNative.DrawCheckBox(win, dc, rect, flags);
 245     }
 246
 247     virtual void DrawPushButton(wxWindow *win,
 248                                 wxDC& dc,
 249                                 const wxRect& rect,
 250                                 int flags = 0)
 251     {
 252         if ( !DoDrawXPButton(BP_PUSHBUTTON, win, dc, rect, flags) )
 253             m_rendererNative.DrawPushButton(win, dc, rect, flags);
 254     }
 255
 256     virtual void DrawRadioBitmap(wxWindow *win,
 257                                  wxDC& dc,
 258                                  const wxRect& rect,
 259                                  int flags = 0)
 260     {
 261         if ( !DoDrawXPButton(BP_RADIOBUTTON, win, dc, rect, flags) )
 262             m_rendererNative.DrawRadioBitmap(win, dc, rect, flags);
 263     }
 264
 265     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win);
 266
 267 private:
 268     // common part of DrawCheckBox(), DrawPushButton() and DrawRadioBitmap()
 269     bool DoDrawXPButton(int kind,
 270                         wxWindow *win,
 271                         wxDC& dc,
 272                         const wxRect& rect,
 273                         int flags);
 274
 275     wxDECLARE_NO_COPY_CLASS(wxRendererXP);
 276 };
 277
 278 #endif // wxUSE_UXTHEME
 279
 280
 281 // ============================================================================
 282 // wxRendererMSWBase implementation
 283 // ============================================================================
 284
 285 void wxRendererMSWBase::DrawFocusRect(wxWindow * WXUNUSED(win),
 286                                       wxDC& dc,
 287                                       const wxRect& rect,
 288                                       int WXUNUSED(flags))
 289 {
 290     RECT rc;
 291     wxCopyRectToRECT(rect, rc);
 292
 293     ::DrawFocusRect(GetHdcOf(dc.GetTempHDC()), &rc);
 294 }
 295
 296 void wxRendererMSWBase::DrawItemSelectionRect(wxWindow *win,
 297                                               wxDC& dc,
 298                                               const wxRect& rect,
 299                                               int flags)
 300 {
 301     wxBrush brush;
 302     if ( flags & wxCONTROL_SELECTED )
 303     {
 304         if ( flags & wxCONTROL_FOCUSED )
 305         {
 306             brush = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
 307         }
 308         else // !focused
 309         {
 310             brush = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
 311         }
 312     }
 313     else // !selected
 314     {
 315         brush = *wxTRANSPARENT_BRUSH;
 316     }
 317
 318     dc.SetBrush(brush);
 319     dc.SetPen(*wxTRANSPARENT_PEN);
 320     dc.DrawRectangle( rect );
 321
 322     if ((flags & wxCONTROL_FOCUSED) && (flags & wxCONTROL_CURRENT))
 323         DrawFocusRect( win, dc, rect, flags );
 324 }
 325
 326
 327 // ============================================================================
 328 // wxRendererNative and wxRendererMSW implementation
 329 // ============================================================================
 330
 331 /* static */
 332 wxRendererNative& wxRendererNative::GetDefault()
 333 {
 334 #if wxUSE_UXTHEME
 335     wxUxThemeEngine *themeEngine = wxUxThemeEngine::Get();
 336     if ( themeEngine && themeEngine->IsAppThemed() )
 337         return wxRendererXP::Get();
 338 #endif // wxUSE_UXTHEME
 339
 340     return wxRendererMSW::Get();
 341 }
 342
 343 /* static */
 344 wxRendererNative& wxRendererMSW::Get()
 345 {
 346     static wxRendererMSW s_rendererMSW;
 347
 348     return s_rendererMSW;
 349 }
 350
 351 void
 352 wxRendererMSW::DrawComboBoxDropButton(wxWindow * WXUNUSED(win),
 353                                       wxDC& dc,
 354                                       const wxRect& rect,
 355                                       int flags)
 356 {
 357     RECT r;
 358     wxCopyRectToRECT(rect, r);
 359
 360     int style = DFCS_SCROLLCOMBOBOX;
 361     if ( flags & wxCONTROL_DISABLED )
 362         style |= DFCS_INACTIVE;
 363     if ( flags & wxCONTROL_PRESSED )
 364         style |= DFCS_PUSHED | DFCS_FLAT;
 365
 366     ::DrawFrameControl(GetHdcOf(dc.GetTempHDC()), &r, DFC_SCROLL, style);
 367 }
 368
 369 void
 370 wxRendererMSW::DoDrawButton(UINT kind,
 371                             wxWindow * WXUNUSED(win),
 372                             wxDC& dc,
 373                             const wxRect& rect,
 374                             int flags)
 375 {
 376     RECT r;
 377     wxCopyRectToRECT(rect, r);
 378
 379     int style = kind;
 380     if ( flags & wxCONTROL_CHECKED )
 381         style |= DFCS_CHECKED;
 382     if ( flags & wxCONTROL_DISABLED )
 383         style |= DFCS_INACTIVE;
 384     if ( flags & wxCONTROL_FLAT )
 385         style |= DFCS_MONO;
 386     if ( flags & wxCONTROL_PRESSED )
 387         style |= DFCS_PUSHED;
 388     if ( flags & wxCONTROL_CURRENT )
 389         style |= DFCS_HOT;
 390
 391     ::DrawFrameControl(GetHdcOf(dc.GetTempHDC()), &r, DFC_BUTTON, style);
 392 }
 393
 394 void
 395 wxRendererMSW::DrawPushButton(wxWindow *win,
 396                               wxDC& dc,
 397                               const wxRect& rectOrig,
 398                               int flags)
 399 {
 400     wxRect rect(rectOrig);
 401     if ( flags & wxCONTROL_ISDEFAULT )
 402     {
 403         // DrawFrameControl() doesn't seem to support default buttons so we
 404         // have to draw the border ourselves
 405         wxDCPenChanger pen(dc, *wxBLACK_PEN);
 406         wxDCBrushChanger brush(dc, *wxTRANSPARENT_BRUSH);
 407         dc.DrawRectangle(rect);
 408         rect.Deflate(1);
 409     }
 410
 411     DoDrawButton(DFCS_BUTTONPUSH, win, dc, rect, flags);
 412 }
 413
 414 wxSize wxRendererMSW::GetCheckBoxSize(wxWindow * WXUNUSED(win))
 415 {
 416     return wxSize(::GetSystemMetrics(SM_CXMENUCHECK),
 417                   ::GetSystemMetrics(SM_CYMENUCHECK));
 418 }
 419
 420 int wxRendererMSW::GetHeaderButtonHeight(wxWindow * WXUNUSED(win))
 421 {
 422     // some "reasonable" value returned in case of error, it doesn't really
 423     // correspond to anything but it's better than returning 0
 424     static const int DEFAULT_HEIGHT = 20;
 425
 426
 427     // create a temporary header window just to get its geometry
 428     HWND hwndHeader = ::CreateWindow(WC_HEADER, NULL, 0,
 429                                      0, 0, 0, 0, NULL, NULL, NULL, NULL);
 430     if ( !hwndHeader )
 431         return DEFAULT_HEIGHT;
 432
 433     wxON_BLOCK_EXIT1( ::DestroyWindow, hwndHeader );
 434
 435     // initialize the struct filled with the values by Header_Layout()
 436     RECT parentRect = { 0, 0, 100, 100 };
 437     WINDOWPOS wp = { 0, 0, 0, 0, 0, 0, 0 };
 438     HDLAYOUT hdl = { &parentRect, &wp };
 439
 440     return Header_Layout(hwndHeader, &hdl) ? wp.cy : DEFAULT_HEIGHT;
 441 }
 442
 443 // Uses the theme to draw the border and fill for something like a wxTextCtrl
 444 void wxRendererMSW::DrawTextCtrl(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
 445 {
 446     wxColour fill;
 447     wxColour bdr;
 448     COLORREF cref;
 449
 450 #if wxUSE_UXTHEME
 451     wxUxThemeHandle hTheme(win, L"EDIT");
 452     if (hTheme)
 453     {
 454         wxUxThemeEngine::Get()->GetThemeColor(hTheme, EP_EDITTEXT,
 455                                               ETS_NORMAL, TMT_FILLCOLOR, &cref);
 456         fill = wxRGBToColour(cref);
 457
 458         int etsState;
 459         if ( flags & wxCONTROL_DISABLED )
 460             etsState = ETS_DISABLED;
 461         else
 462             etsState = ETS_NORMAL;
 463
 464         wxUxThemeEngine::Get()->GetThemeColor(hTheme, EP_EDITTEXT,
 465                                               etsState, TMT_BORDERCOLOR, &cref);
 466         bdr = wxRGBToColour(cref);
 467     }
 468     else
 469 #endif
 470     {
 471         fill = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
 472         bdr = *wxBLACK;
 473     }
 474
 475     dc.SetPen( bdr );
 476     dc.SetBrush( fill );
 477     dc.DrawRectangle(rect);
 478 }
 479
 480
 481 // Draw the equivalent of a wxComboBox
 482 void wxRendererMSW::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
 483 {
 484     // Draw the main part of the control same as TextCtrl
 485     DrawTextCtrl(win, dc, rect, flags);
 486
 487     // Draw the button inside the border, on the right side
 488     wxRect br(rect);
 489     br.height -= 2;
 490     br.x += br.width - br.height - 1;
 491     br.width = br.height;
 492     br.y += 1;
 493
 494     DrawComboBoxDropButton(win, dc, br, flags);
 495 }
 496
 497
 498 void wxRendererMSW::DrawChoice(wxWindow* win, wxDC& dc,
 499                            const wxRect& rect, int flags)
 500 {
 501     DrawComboBox(win, dc, rect, flags);
 502 }
 503
 504 // ============================================================================
 505 // wxRendererXP implementation
 506 // ============================================================================
 507
 508 #if wxUSE_UXTHEME
 509
 510 /* static */
 511 wxRendererNative& wxRendererXP::Get()
 512 {
 513     static wxRendererXP s_rendererXP;
 514
 515     return s_rendererXP;
 516 }
 517
 518 // NOTE: There is no guarantee that the button drawn fills the entire rect (XP
 519 // default theme, for example), so the caller should have cleared button's
 520 // background before this call. This is quite likely a wxMSW-specific thing.
 521 void
 522 wxRendererXP::DrawComboBoxDropButton(wxWindow * win,
 523                                       wxDC& dc,
 524                                       const wxRect& rect,
 525                                       int flags)
 526 {
 527     wxUxThemeHandle hTheme(win, L"COMBOBOX");
 528     if ( !hTheme )
 529     {
 530         m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags);
 531         return;
 532     }
 533
 534     RECT r;
 535     wxCopyRectToRECT(rect, r);
 536
 537     int state;
 538     if ( flags & wxCONTROL_PRESSED )
 539         state = CBXS_PRESSED;
 540     else if ( flags & wxCONTROL_CURRENT )
 541         state = CBXS_HOT;
 542     else if ( flags & wxCONTROL_DISABLED )
 543         state = CBXS_DISABLED;
 544     else
 545         state = CBXS_NORMAL;
 546
 547     wxUxThemeEngine::Get()->DrawThemeBackground
 548                             (
 549                                 hTheme,
 550                                 GetHdcOf(dc.GetTempHDC()),
 551                                 CP_DROPDOWNBUTTON,
 552                                 state,
 553                                 &r,
 554                                 NULL
 555                             );
 556
 557 }
 558
 559 int
 560 wxRendererXP::DrawHeaderButton(wxWindow *win,
 561                                wxDC& dc,
 562                                const wxRect& rect,
 563                                int flags,
 564                                wxHeaderSortIconType sortArrow,
 565                                wxHeaderButtonParams* params)
 566 {
 567     wxUxThemeHandle hTheme(win, L"HEADER");
 568     if ( !hTheme )
 569     {
 570         return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params);
 571     }
 572
 573     RECT r;
 574     wxCopyRectToRECT(rect, r);
 575
 576     int state;
 577     if ( flags & wxCONTROL_PRESSED )
 578         state = HIS_PRESSED;
 579     else if ( flags & wxCONTROL_CURRENT )
 580         state = HIS_HOT;
 581     else
 582         state = HIS_NORMAL;
 583     wxUxThemeEngine::Get()->DrawThemeBackground
 584                             (
 585                                 hTheme,
 586                                 GetHdcOf(dc.GetTempHDC()),
 587                                 HP_HEADERITEM,
 588                                 state,
 589                                 &r,
 590                                 NULL
 591                             );
 592
 593     // NOTE: Using the theme to draw HP_HEADERSORTARROW doesn't do anything.
 594     // Why?  If this can be fixed then draw the sort arrows using the theme
 595     // and then clear those flags before calling DrawHeaderButtonContents.
 596
 597     // Add any extras that are specified in flags and params
 598     return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params);
 599 }
 600
 601
 602 void
 603 wxRendererXP::DrawTreeItemButton(wxWindow *win,
 604                                  wxDC& dc,
 605                                  const wxRect& rect,
 606                                  int flags)
 607 {
 608     wxUxThemeHandle hTheme(win, L"TREEVIEW");
 609     if ( !hTheme )
 610     {
 611         m_rendererNative.DrawTreeItemButton(win, dc, rect, flags);
 612         return;
 613     }
 614
 615     RECT r;
 616     wxCopyRectToRECT(rect, r);
 617
 618     int state = flags & wxCONTROL_EXPANDED ? GLPS_OPENED : GLPS_CLOSED;
 619     wxUxThemeEngine::Get()->DrawThemeBackground
 620                             (
 621                                 hTheme,
 622                                 GetHdcOf(dc.GetTempHDC()),
 623                                 TVP_GLYPH,
 624                                 state,
 625                                 &r,
 626                                 NULL
 627                             );
 628 }
 629
 630 bool
 631 wxRendererXP::DoDrawXPButton(int kind,
 632                              wxWindow *win,
 633                              wxDC& dc,
 634                              const wxRect& rect,
 635                              int flags)
 636 {
 637     wxUxThemeHandle hTheme(win, L"BUTTON");
 638     if ( !hTheme )
 639         return false;
 640
 641     RECT r;
 642     wxCopyRectToRECT(rect, r);
 643
 644     // determine the base state depending on the button kind
 645     int state;
 646     switch ( kind )
 647     {
 648         case BP_PUSHBUTTON:
 649             state = PBS_NORMAL;
 650             break;
 651
 652         case BP_RADIOBUTTON:
 653             state = RBS_UNCHECKEDNORMAL;
 654             break;
 655
 656         case BP_CHECKBOX:
 657             state = CBS_UNCHECKEDNORMAL;
 658             break;
 659
 660         default:
 661             wxFAIL_MSG( "unknown button kind" );
 662             return false;
 663     }
 664
 665     // XBS_XXX is followed by XBX_XXXHOT, then XBS_XXXPRESSED and DISABLED
 666     enum
 667     {
 668         NORMAL_OFFSET,
 669         HOT_OFFSET,
 670         PRESSED_OFFSET,
 671         DISABLED_OFFSET,
 672         STATES_COUNT
 673     };
 674
 675     // in both RBS_ and CBS_ enums CHECKED elements are offset by 4 from base
 676     // (UNCHECKED) ones and MIXED are offset by 4 again as there are all states
 677     // from the above enum in between them
 678     if ( flags & wxCONTROL_CHECKED )
 679         state += STATES_COUNT;
 680     else if ( flags & wxCONTROL_UNDETERMINED )
 681         state += 2*STATES_COUNT;
 682
 683     if ( flags & wxCONTROL_DISABLED )
 684         state += DISABLED_OFFSET;
 685     else if ( flags & wxCONTROL_PRESSED )
 686         state += PRESSED_OFFSET;
 687     else if ( flags & wxCONTROL_CURRENT )
 688         state += HOT_OFFSET;
 689     // wxCONTROL_ISDEFAULT flag is only valid for push buttons
 690     else if ( kind == BP_PUSHBUTTON && (flags & wxCONTROL_ISDEFAULT) )
 691         state = PBS_DEFAULTED;
 692
 693     wxUxThemeEngine::Get()->DrawThemeBackground
 694                             (
 695                                 hTheme,
 696                                 GetHdcOf(dc.GetTempHDC()),
 697                                 kind,
 698                                 state,
 699                                 &r,
 700                                 NULL
 701                             );
 702
 703     return true;
 704 }
 705
 706 // ----------------------------------------------------------------------------
 707 // splitter drawing
 708 // ----------------------------------------------------------------------------
 709
 710 // the width of the sash: this is the same as used by Explorer...
 711 static const wxCoord SASH_WIDTH = 4;
 712
 713 wxSplitterRenderParams
 714 wxRendererXP::GetSplitterParams(const wxWindow * win)
 715 {
 716     if ( win->HasFlag(wxSP_NO_XP_THEME) )
 717         return m_rendererNative.GetSplitterParams(win);
 718     else
 719         return wxSplitterRenderParams(SASH_WIDTH, 0, false);
 720 }
 721
 722 void
 723 wxRendererXP::DrawSplitterBorder(wxWindow * win,
 724                                  wxDC& dc,
 725                                  const wxRect& rect,
 726                                  int flags)
 727 {
 728     if ( win->HasFlag(wxSP_NO_XP_THEME) )
 729     {
 730         m_rendererNative.DrawSplitterBorder(win, dc, rect, flags);
 731     }
 732 }
 733
 734 void
 735 wxRendererXP::DrawSplitterSash(wxWindow *win,
 736                                wxDC& dc,
 737                                const wxSize& size,
 738                                wxCoord position,
 739                                wxOrientation orient,
 740                                int flags)
 741 {
 742     if ( !win->HasFlag(wxSP_NO_XP_THEME) )
 743     {
 744         dc.SetPen(*wxTRANSPARENT_PEN);
 745         dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)));
 746         if ( orient == wxVERTICAL )
 747         {
 748             dc.DrawRectangle(position, 0, SASH_WIDTH, size.y);
 749         }
 750         else // wxHORIZONTAL
 751         {
 752             dc.DrawRectangle(0, position, size.x, SASH_WIDTH);
 753         }
 754
 755         return;
 756     }
 757
 758     m_rendererNative.DrawSplitterSash(win, dc, size, position, orient, flags);
 759 }
 760
 761 #endif // wxUSE_UXTHEME