src/univ/themes/win32.cpp

   1 // Name:        univ/themes/win32.cpp
   2 // Purpose:     wxUniversal theme implementing Win32-like LNF
   3 // Author:      Vadim Zeitlin
   4 // Modified by:
   5 // Created:     06.08.00
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   8 // Licence:     wxWindows license
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ===========================================================================
  12 // declarations
  13 // ===========================================================================
  14
  15 // ---------------------------------------------------------------------------
  16 // headers
  17 // ---------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #ifndef WX_PRECOMP
  27     #include "wx/timer.h"
  28     #include "wx/intl.h"
  29     #include "wx/dc.h"
  30     #include "wx/window.h"
  31
  32     #include "wx/dcmemory.h"
  33
  34     #include "wx/button.h"
  35     #include "wx/listbox.h"
  36     #include "wx/checklst.h"
  37     #include "wx/combobox.h"
  38     #include "wx/scrolbar.h"
  39     #include "wx/slider.h"
  40     #include "wx/textctrl.h"
  41     #include "wx/toolbar.h"
  42
  43     #ifdef __WXMSW__
  44         // for COLOR_* constants
  45         #include "wx/msw/private.h"
  46     #endif
  47 #endif // WX_PRECOMP
  48
  49 #include "wx/notebook.h"
  50 #include "wx/spinbutt.h"
  51 #include "wx/settings.h"
  52 #include "wx/menu.h"
  53 #include "wx/artprov.h"
  54 #include "wx/toplevel.h"
  55
  56 #include "wx/univ/scrtimer.h"
  57 #include "wx/univ/renderer.h"
  58 #include "wx/univ/inphand.h"
  59 #include "wx/univ/colschem.h"
  60 #include "wx/univ/theme.h"
  61
  62 // ----------------------------------------------------------------------------
  63 // constants
  64 // ----------------------------------------------------------------------------
  65
  66 static const int BORDER_THICKNESS = 2;
  67
  68 // the offset between the label and focus rect around it
  69 static const int FOCUS_RECT_OFFSET_X = 1;
  70 static const int FOCUS_RECT_OFFSET_Y = 1;
  71
  72 static const int FRAME_BORDER_THICKNESS            = 3;
  73 static const int RESIZEABLE_FRAME_BORDER_THICKNESS = 4;
  74 static const int FRAME_TITLEBAR_HEIGHT             = 18;
  75 static const int FRAME_BUTTON_WIDTH                = 16;
  76 static const int FRAME_BUTTON_HEIGHT               = 14;
  77
  78 static const size_t NUM_STATUSBAR_GRIP_BANDS = 3;
  79 static const size_t WIDTH_STATUSBAR_GRIP_BAND = 4;
  80 static const size_t STATUSBAR_GRIP_SIZE =
  81     WIDTH_STATUSBAR_GRIP_BAND*NUM_STATUSBAR_GRIP_BANDS;
  82
  83 static const wxCoord SLIDER_MARGIN = 6; // margin around slider
  84 static const wxCoord SLIDER_THUMB_LENGTH = 18;
  85 static const wxCoord SLIDER_TICK_LENGTH = 6;
  86
  87 enum IndicatorType
  88 {
  89     IndicatorType_Check,
  90     IndicatorType_Radio,
  91     IndicatorType_Menu,
  92     IndicatorType_Max
  93 };
  94
  95 enum IndicatorState
  96 {
  97     IndicatorState_Normal,
  98     IndicatorState_Pressed, // this one is for check/radioboxes
  99     IndicatorState_Selected = IndicatorState_Pressed, // for menus
 100     IndicatorState_Disabled,
 101     IndicatorState_SelectedDisabled,    // only for the menus
 102     IndicatorState_Max
 103 };
 104
 105 enum IndicatorStatus
 106 {
 107     IndicatorStatus_Checked,
 108     IndicatorStatus_Unchecked,
 109     IndicatorStatus_Max
 110 };
 111
 112 // wxWin32Renderer: draw the GUI elements in Win32 style
 113 // ----------------------------------------------------------------------------
 114
 115 class wxWin32Renderer : public wxRenderer
 116 {
 117 public:
 118     // constants
 119     enum wxArrowDirection
 120     {
 121         Arrow_Left,
 122         Arrow_Right,
 123         Arrow_Up,
 124         Arrow_Down,
 125         Arrow_Max
 126     };
 127
 128     enum wxArrowStyle
 129     {
 130         Arrow_Normal,
 131         Arrow_Disabled,
 132         Arrow_Pressed,
 133         Arrow_Inversed,
 134         Arrow_InversedDisabled,
 135         Arrow_StateMax
 136     };
 137
 138     enum wxFrameButtonType
 139     {
 140         FrameButton_Close,
 141         FrameButton_Minimize,
 142         FrameButton_Maximize,
 143         FrameButton_Restore,
 144         FrameButton_Help,
 145         FrameButton_Max
 146     };
 147
 148     // ctor
 149     wxWin32Renderer(const wxColourScheme *scheme);
 150
 151     // implement the base class pure virtuals
 152     virtual void DrawBackground(wxDC& dc,
 153                                 const wxColour& col,
 154                                 const wxRect& rect,
 155                                 int flags = 0,
 156                                 wxWindow *window = NULL);
 157     virtual void DrawLabel(wxDC& dc,
 158                            const wxString& label,
 159                            const wxRect& rect,
 160                            int flags = 0,
 161                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 162                            int indexAccel = -1,
 163                            wxRect *rectBounds = NULL);
 164     virtual void DrawButtonLabel(wxDC& dc,
 165                                  const wxString& label,
 166                                  const wxBitmap& image,
 167                                  const wxRect& rect,
 168                                  int flags = 0,
 169                                  int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 170                                  int indexAccel = -1,
 171                                  wxRect *rectBounds = NULL);
 172     virtual void DrawBorder(wxDC& dc,
 173                             wxBorder border,
 174                             const wxRect& rect,
 175                             int flags = 0,
 176                             wxRect *rectIn = (wxRect *)NULL);
 177     virtual void DrawHorizontalLine(wxDC& dc,
 178                                     wxCoord y, wxCoord x1, wxCoord x2);
 179     virtual void DrawVerticalLine(wxDC& dc,
 180                                   wxCoord x, wxCoord y1, wxCoord y2);
 181     virtual void DrawFrame(wxDC& dc,
 182                            const wxString& label,
 183                            const wxRect& rect,
 184                            int flags = 0,
 185                            int alignment = wxALIGN_LEFT,
 186                            int indexAccel = -1);
 187     virtual void DrawTextBorder(wxDC& dc,
 188                                 wxBorder border,
 189                                 const wxRect& rect,
 190                                 int flags = 0,
 191                                 wxRect *rectIn = (wxRect *)NULL);
 192     virtual void DrawButtonBorder(wxDC& dc,
 193                                   const wxRect& rect,
 194                                   int flags = 0,
 195                                   wxRect *rectIn = (wxRect *)NULL);
 196     virtual void DrawArrow(wxDC& dc,
 197                            wxDirection dir,
 198                            const wxRect& rect,
 199                            int flags = 0);
 200     virtual void DrawScrollbarArrow(wxDC& dc,
 201                                     wxDirection dir,
 202                                     const wxRect& rect,
 203                                     int flags = 0)
 204         { DrawArrow(dc, dir, rect, flags); }
 205     virtual void DrawScrollbarThumb(wxDC& dc,
 206                                     wxOrientation orient,
 207                                     const wxRect& rect,
 208                                     int flags = 0);
 209     virtual void DrawScrollbarShaft(wxDC& dc,
 210                                     wxOrientation orient,
 211                                     const wxRect& rect,
 212                                     int flags = 0);
 213     virtual void DrawScrollCorner(wxDC& dc,
 214                                   const wxRect& rect);
 215     virtual void DrawItem(wxDC& dc,
 216                           const wxString& label,
 217                           const wxRect& rect,
 218                           int flags = 0);
 219     virtual void DrawCheckItem(wxDC& dc,
 220                                const wxString& label,
 221                                const wxBitmap& bitmap,
 222                                const wxRect& rect,
 223                                int flags = 0);
 224     virtual void DrawCheckButton(wxDC& dc,
 225                                  const wxString& label,
 226                                  const wxBitmap& bitmap,
 227                                  const wxRect& rect,
 228                                  int flags = 0,
 229                                  wxAlignment align = wxALIGN_LEFT,
 230                                  int indexAccel = -1);
 231     virtual void DrawRadioButton(wxDC& dc,
 232                                  const wxString& label,
 233                                  const wxBitmap& bitmap,
 234                                  const wxRect& rect,
 235                                  int flags = 0,
 236                                  wxAlignment align = wxALIGN_LEFT,
 237                                  int indexAccel = -1);
 238     virtual void DrawToolBarButton(wxDC& dc,
 239                                    const wxString& label,
 240                                    const wxBitmap& bitmap,
 241                                    const wxRect& rect,
 242                                    int flags);
 243     virtual void DrawTextLine(wxDC& dc,
 244                               const wxString& text,
 245                               const wxRect& rect,
 246                               int selStart = -1,
 247                               int selEnd = -1,
 248                               int flags = 0);
 249     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
 250     virtual void DrawTab(wxDC& dc,
 251                          const wxRect& rect,
 252                          wxDirection dir,
 253                          const wxString& label,
 254                          const wxBitmap& bitmap = wxNullBitmap,
 255                          int flags = 0,
 256                          int indexAccel = -1);
 257
 258     virtual void DrawSliderShaft(wxDC& dc,
 259                                  const wxRect& rect,
 260                                  int lenThumb,
 261                                  wxOrientation orient,
 262                                  int flags = 0,
 263                                  long style = 0,
 264                                  wxRect *rectShaft = NULL);
 265     virtual void DrawSliderThumb(wxDC& dc,
 266                                  const wxRect& rect,
 267                                  wxOrientation orient,
 268                                  int flags = 0,
 269                                  long style = 0);
 270     virtual void DrawSliderTicks(wxDC& dc,
 271                                  const wxRect& rect,
 272                                  int lenThumb,
 273                                  wxOrientation orient,
 274                                  int start,
 275                                  int end,
 276                                  int step = 1,
 277                                  int flags = 0,
 278                                  long style = 0);
 279
 280     virtual void DrawMenuBarItem(wxDC& dc,
 281                                  const wxRect& rect,
 282                                  const wxString& label,
 283                                  int flags = 0,
 284                                  int indexAccel = -1);
 285     virtual void DrawMenuItem(wxDC& dc,
 286                               wxCoord y,
 287                               const wxMenuGeometryInfo& geometryInfo,
 288                               const wxString& label,
 289                               const wxString& accel,
 290                               const wxBitmap& bitmap = wxNullBitmap,
 291                               int flags = 0,
 292                               int indexAccel = -1);
 293     virtual void DrawMenuSeparator(wxDC& dc,
 294                                    wxCoord y,
 295                                    const wxMenuGeometryInfo& geomInfo);
 296
 297     virtual void DrawStatusField(wxDC& dc,
 298                                  const wxRect& rect,
 299                                  const wxString& label,
 300                                  int flags = 0);
 301
 302     // titlebars
 303     virtual void DrawFrameTitleBar(wxDC& dc,
 304                                    const wxRect& rect,
 305                                    const wxString& title,
 306                                    const wxIcon& icon,
 307                                    int flags,
 308                                    int specialButton = 0,
 309                                    int specialButtonFlags = 0);
 310     virtual void DrawFrameBorder(wxDC& dc,
 311                                  const wxRect& rect,
 312                                  int flags);
 313     virtual void DrawFrameBackground(wxDC& dc,
 314                                      const wxRect& rect,
 315                                      int flags);
 316     virtual void DrawFrameTitle(wxDC& dc,
 317                                 const wxRect& rect,
 318                                 const wxString& title,
 319                                 int flags);
 320     virtual void DrawFrameIcon(wxDC& dc,
 321                                const wxRect& rect,
 322                                const wxIcon& icon,
 323                                int flags);
 324     virtual void DrawFrameButton(wxDC& dc,
 325                                  wxCoord x, wxCoord y,
 326                                  int button,
 327                                  int flags = 0);
 328     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const;
 329     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const;
 330     virtual wxSize GetFrameMinSize(int flags) const;
 331     virtual wxSize GetFrameIconSize() const;
 332     virtual int HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const;
 333
 334     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
 335                                  wxBitmap *bmpFocus,
 336                                  wxBitmap *bmpPressed,
 337                                  wxBitmap *bmpDisabled);
 338
 339     virtual void AdjustSize(wxSize *size, const wxWindow *window);
 340     virtual wxRect GetBorderDimensions(wxBorder border) const;
 341     virtual bool AreScrollbarsInsideBorder() const;
 342
 343     virtual wxSize GetScrollbarArrowSize() const
 344         { return m_sizeScrollbarArrow; }
 345     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
 346                                     wxScrollBar::Element elem,
 347                                     int thumbPos = -1) const;
 348     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
 349     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
 350                                        const wxPoint& pt) const;
 351     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
 352                                      int thumbPos = -1);
 353     virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);
 354     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
 355         { return fontHeight + 2; }
 356     virtual wxSize GetCheckBitmapSize() const
 357         { return wxSize(13, 13); }
 358     virtual wxSize GetRadioBitmapSize() const
 359         { return wxSize(12, 12); }
 360     virtual wxCoord GetCheckItemMargin() const
 361         { return 0; }
 362
 363     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
 364         { if ( separator ) *separator = 5; return wxSize(16, 15); }
 365     virtual wxSize GetToolBarMargin() const
 366         { return wxSize(4, 4); }
 367
 368     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
 369                                     const wxRect& rect) const;
 370     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
 371                                      const wxRect& rect,
 372                                      wxCoord *extraSpaceBeyond) const;
 373
 374     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
 375     virtual wxSize GetTabPadding() const { return wxSize(6, 5); }
 376
 377     virtual wxCoord GetSliderDim() const { return SLIDER_THUMB_LENGTH + 2*BORDER_THICKNESS; }
 378     virtual wxCoord GetSliderTickLen() const { return SLIDER_TICK_LENGTH; }
 379     virtual wxRect GetSliderShaftRect(const wxRect& rect,
 380                                       int lenThumb,
 381                                       wxOrientation orient,
 382                                       long style = 0) const;
 383     virtual wxSize GetSliderThumbSize(const wxRect& rect,
 384                                       int lenThumb,
 385                                       wxOrientation orient) const;
 386     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
 387
 388     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
 389     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
 390                                                 const wxMenu& menu) const;
 391
 392     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
 393
 394 protected:
 395     // helper of DrawLabel() and DrawCheckOrRadioButton()
 396     void DoDrawLabel(wxDC& dc,
 397                      const wxString& label,
 398                      const wxRect& rect,
 399                      int flags = 0,
 400                      int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 401                      int indexAccel = -1,
 402                      wxRect *rectBounds = NULL,
 403                      const wxPoint& focusOffset
 404                         = wxPoint(FOCUS_RECT_OFFSET_X, FOCUS_RECT_OFFSET_Y));
 405
 406     // common part of DrawLabel() and DrawItem()
 407     void DrawFocusRect(wxDC& dc, const wxRect& rect);
 408
 409     // DrawLabel() and DrawButtonLabel() helper
 410     void DrawLabelShadow(wxDC& dc,
 411                          const wxString& label,
 412                          const wxRect& rect,
 413                          int alignment,
 414                          int indexAccel);
 415
 416     // DrawButtonBorder() helper
 417     void DoDrawBackground(wxDC& dc,
 418                           const wxColour& col,
 419                           const wxRect& rect,
 420                           wxWindow *window = NULL );
 421
 422     // DrawBorder() helpers: all of them shift and clip the DC after drawing
 423     // the border
 424
 425     // just draw a rectangle with the given pen
 426     void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
 427
 428     // draw the lower left part of rectangle
 429     void DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen);
 430
 431     // draw the rectange using the first brush for the left and top sides and
 432     // the second one for the bottom and right ones
 433     void DrawShadedRect(wxDC& dc, wxRect *rect,
 434                         const wxPen& pen1, const wxPen& pen2);
 435
 436     // draw the normal 3D border
 437     void DrawRaisedBorder(wxDC& dc, wxRect *rect);
 438
 439     // draw the sunken 3D border
 440     void DrawSunkenBorder(wxDC& dc, wxRect *rect);
 441
 442     // draw the border used for scrollbar arrows
 443     void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = FALSE);
 444
 445     // public DrawArrow()s helper
 446     void DrawArrow(wxDC& dc, const wxRect& rect,
 447                    wxArrowDirection arrowDir, wxArrowStyle arrowStyle);
 448
 449     // DrawArrowButton is used by DrawScrollbar and DrawComboButton
 450     void DrawArrowButton(wxDC& dc, const wxRect& rect,
 451                          wxArrowDirection arrowDir,
 452                          wxArrowStyle arrowStyle);
 453
 454     // DrawCheckButton/DrawRadioButton helper
 455     void DrawCheckOrRadioButton(wxDC& dc,
 456                                 const wxString& label,
 457                                 const wxBitmap& bitmap,
 458                                 const wxRect& rect,
 459                                 int flags,
 460                                 wxAlignment align,
 461                                 int indexAccel,
 462                                 wxCoord focusOffsetY);
 463
 464     // draw a normal or transposed line (useful for using the same code fo both
 465     // horizontal and vertical widgets)
 466     void DrawLine(wxDC& dc,
 467                   wxCoord x1, wxCoord y1,
 468                   wxCoord x2, wxCoord y2,
 469                   bool transpose = FALSE)
 470     {
 471         if ( transpose )
 472             dc.DrawLine(y1, x1, y2, x2);
 473         else
 474             dc.DrawLine(x1, y1, x2, y2);
 475     }
 476
 477     // get the standard check/radio button bitmap
 478     wxBitmap GetIndicator(IndicatorType indType, int flags);
 479     wxBitmap GetCheckBitmap(int flags)
 480         { return GetIndicator(IndicatorType_Check, flags); }
 481     wxBitmap GetRadioBitmap(int flags)
 482         { return GetIndicator(IndicatorType_Radio, flags); }
 483
 484 private:
 485     const wxColourScheme *m_scheme;
 486
 487     // the sizing parameters (TODO make them changeable)
 488     wxSize m_sizeScrollbarArrow;
 489
 490     // GDI objects we use for drawing
 491     wxColour m_colDarkGrey,
 492              m_colHighlight;
 493
 494     wxPen m_penBlack,
 495           m_penDarkGrey,
 496           m_penLightGrey,
 497           m_penHighlight;
 498
 499     wxFont m_titlebarFont;
 500
 501     // the checked and unchecked bitmaps for DrawCheckItem()
 502     wxBitmap m_bmpCheckBitmaps[IndicatorStatus_Max];
 503
 504     // the bitmaps returned by GetIndicator()
 505     wxBitmap m_bmpIndicators[IndicatorType_Max]
 506                             [IndicatorState_Max]
 507                             [IndicatorStatus_Max];
 508
 509     // titlebar icons:
 510     wxBitmap m_bmpFrameButtons[FrameButton_Max];
 511
 512     // first row is for the normal state, second - for the disabled
 513     wxBitmap m_bmpArrows[Arrow_StateMax][Arrow_Max];
 514 };
 515
 516 // ----------------------------------------------------------------------------
 517 // wxWin32InputHandler and derived classes: process the keyboard and mouse
 518 // messages according to Windows standards
 519 // ----------------------------------------------------------------------------
 520
 521 class wxWin32InputHandler : public wxInputHandler
 522 {
 523 public:
 524     wxWin32InputHandler(wxWin32Renderer *renderer);
 525
 526     virtual bool HandleKey(wxInputConsumer *control,
 527                            const wxKeyEvent& event,
 528                            bool pressed);
 529     virtual bool HandleMouse(wxInputConsumer *control,
 530                              const wxMouseEvent& event);
 531
 532 protected:
 533     wxWin32Renderer *m_renderer;
 534 };
 535
 536 class wxWin32ScrollBarInputHandler : public wxStdScrollBarInputHandler
 537 {
 538 public:
 539     wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
 540                                  wxInputHandler *handler);
 541
 542     virtual bool HandleMouse(wxInputConsumer *control, const wxMouseEvent& event);
 543     virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
 544
 545     virtual bool OnScrollTimer(wxScrollBar *scrollbar,
 546                                const wxControlAction& action);
 547
 548 protected:
 549     virtual bool IsAllowedButton(int button) { return button == 1; }
 550
 551     virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
 552     {
 553         // we don't highlight anything
 554     }
 555
 556     // the first and last event which caused the thumb to move
 557     wxMouseEvent m_eventStartDrag,
 558                  m_eventLastDrag;
 559
 560     // have we paused the scrolling because the mouse moved?
 561     bool m_scrollPaused;
 562
 563     // we remember the interval of the timer to be able to restart it
 564     int m_interval;
 565 };
 566
 567 class wxWin32CheckboxInputHandler : public wxStdCheckboxInputHandler
 568 {
 569 public:
 570     wxWin32CheckboxInputHandler(wxInputHandler *handler)
 571         : wxStdCheckboxInputHandler(handler) { }
 572
 573     virtual bool HandleKey(wxInputConsumer *control,
 574                            const wxKeyEvent& event,
 575                            bool pressed);
 576 };
 577
 578 class wxWin32TextCtrlInputHandler : public wxStdTextCtrlInputHandler
 579 {
 580 public:
 581     wxWin32TextCtrlInputHandler(wxInputHandler *handler)
 582         : wxStdTextCtrlInputHandler(handler) { }
 583
 584     virtual bool HandleKey(wxInputConsumer *control,
 585                            const wxKeyEvent& event,
 586                            bool pressed);
 587 };
 588
 589 class wxWin32StatusBarInputHandler : public wxStdInputHandler
 590 {
 591 public:
 592     wxWin32StatusBarInputHandler(wxInputHandler *handler);
 593
 594     virtual bool HandleMouse(wxInputConsumer *consumer,
 595                              const wxMouseEvent& event);
 596
 597     virtual bool HandleMouseMove(wxInputConsumer *consumer,
 598                                  const wxMouseEvent& event);
 599
 600 protected:
 601     // is the given point over the statusbar grip?
 602     bool IsOnGrip(wxWindow *statbar, const wxPoint& pt) const;
 603
 604 private:
 605     // the cursor we had replaced with the resize one
 606     wxCursor m_cursorOld;
 607
 608     // was the mouse over the grip last time we checked?
 609     bool m_isOnGrip;
 610 };
 611
 612 class wxWin32SystemMenuEvtHandler;
 613
 614 class wxWin32FrameInputHandler : public wxStdFrameInputHandler
 615 {
 616 public:
 617     wxWin32FrameInputHandler(wxInputHandler *handler);
 618     ~wxWin32FrameInputHandler();
 619
 620     virtual bool HandleMouse(wxInputConsumer *control,
 621                              const wxMouseEvent& event);
 622
 623     virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
 624
 625     void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
 626
 627 private:
 628     // was the mouse over the grip last time we checked?
 629     wxWin32SystemMenuEvtHandler *m_menuHandler;
 630 };
 631
 632 // ----------------------------------------------------------------------------
 633 // wxWin32ColourScheme: uses (default) Win32 colours
 634 // ----------------------------------------------------------------------------
 635
 636 class wxWin32ColourScheme : public wxColourScheme
 637 {
 638 public:
 639     virtual wxColour Get(StdColour col) const;
 640     virtual wxColour GetBackground(wxWindow *win) const;
 641 };
 642
 643 // ----------------------------------------------------------------------------
 644 // wxWin32ArtProvider
 645 // ----------------------------------------------------------------------------
 646
 647 class wxWin32ArtProvider : public wxArtProvider
 648 {
 649 protected:
 650     virtual wxBitmap CreateBitmap(const wxArtID& id,
 651                                   const wxArtClient& client,
 652                                   const wxSize& size);
 653 };
 654
 655 // ----------------------------------------------------------------------------
 656 // wxWin32Theme
 657 // ----------------------------------------------------------------------------
 658
 659 WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
 660
 661 class wxWin32Theme : public wxTheme
 662 {
 663 public:
 664     wxWin32Theme();
 665     virtual ~wxWin32Theme();
 666
 667     virtual wxRenderer *GetRenderer();
 668     virtual wxArtProvider *GetArtProvider();
 669     virtual wxInputHandler *GetInputHandler(const wxString& control);
 670     virtual wxColourScheme *GetColourScheme();
 671
 672 private:
 673     // get the default input handler
 674     wxInputHandler *GetDefaultInputHandler();
 675
 676     wxWin32Renderer *m_renderer;
 677
 678     wxWin32ArtProvider *m_artProvider;
 679
 680     // the names of the already created handlers and the handlers themselves
 681     // (these arrays are synchronized)
 682     wxSortedArrayString m_handlerNames;
 683     wxArrayHandlers m_handlers;
 684
 685     wxWin32InputHandler *m_handlerDefault;
 686
 687     wxWin32ColourScheme *m_scheme;
 688
 689     WX_DECLARE_THEME(win32)
 690 };
 691
 692 // ----------------------------------------------------------------------------
 693 // standard bitmaps
 694 // ----------------------------------------------------------------------------
 695
 696 // frame buttons bitmaps
 697
 698 static const char *frame_button_close_xpm[] = {
 699 "12 10 2 1",
 700 "         c None",
 701 ".        c black",
 702 "            ",
 703 "  ..    ..  ",
 704 "   ..  ..   ",
 705 "    ....    ",
 706 "     ..     ",
 707 "    ....    ",
 708 "   ..  ..   ",
 709 "  ..    ..  ",
 710 "            ",
 711 "            "};
 712
 713 static const char *frame_button_help_xpm[] = {
 714 "12 10 2 1",
 715 "         c None",
 716 ".        c #000000",
 717 "    ....    ",
 718 "   ..  ..   ",
 719 "   ..  ..   ",
 720 "      ..    ",
 721 "     ..     ",
 722 "     ..     ",
 723 "            ",
 724 "     ..     ",
 725 "     ..     ",
 726 "            "};
 727
 728 static const char *frame_button_maximize_xpm[] = {
 729 "12 10 2 1",
 730 "         c None",
 731 ".        c #000000",
 732 " .........  ",
 733 " .........  ",
 734 " .       .  ",
 735 " .       .  ",
 736 " .       .  ",
 737 " .       .  ",
 738 " .       .  ",
 739 " .       .  ",
 740 " .........  ",
 741 "            "};
 742
 743 static const char *frame_button_minimize_xpm[] = {
 744 "12 10 2 1",
 745 "         c None",
 746 ".        c #000000",
 747 "            ",
 748 "            ",
 749 "            ",
 750 "            ",
 751 "            ",
 752 "            ",
 753 "            ",
 754 "  ......    ",
 755 "  ......    ",
 756 "            "};
 757
 758 static const char *frame_button_restore_xpm[] = {
 759 "12 10 2 1",
 760 "         c None",
 761 ".        c #000000",
 762 "   ......   ",
 763 "   ......   ",
 764 "   .    .   ",
 765 " ...... .   ",
 766 " ...... .   ",
 767 " .    ...   ",
 768 " .    .     ",
 769 " .    .     ",
 770 " ......     ",
 771 "            "};
 772
 773 // menu bitmaps
 774
 775 static const char *checked_menu_xpm[] = {
 776 /* columns rows colors chars-per-pixel */
 777 "9 9 2 1",
 778 "w c None",
 779 "b c black",
 780 /* pixels */
 781 "wwwwwwwww",
 782 "wwwwwwwbw",
 783 "wwwwwwbbw",
 784 "wbwwwbbbw",
 785 "wbbwbbbww",
 786 "wbbbbbwww",
 787 "wwbbbwwww",
 788 "wwwbwwwww",
 789 "wwwwwwwww"
 790 };
 791
 792 static const char *selected_checked_menu_xpm[] = {
 793 /* columns rows colors chars-per-pixel */
 794 "9 9 2 1",
 795 "w c None",
 796 "b c white",
 797 /* pixels */
 798 "wwwwwwwww",
 799 "wwwwwwwbw",
 800 "wwwwwwbbw",
 801 "wbwwwbbbw",
 802 "wbbwbbbww",
 803 "wbbbbbwww",
 804 "wwbbbwwww",
 805 "wwwbwwwww",
 806 "wwwwwwwww"
 807 };
 808
 809 static const char *disabled_checked_menu_xpm[] = {
 810 /* columns rows colors chars-per-pixel */
 811 "9 9 3 1",
 812 "w c None",
 813 "b c #7f7f7f",
 814 "W c #e0e0e0",
 815 /* pixels */
 816 "wwwwwwwww",
 817 "wwwwwwwbw",
 818 "wwwwwwbbW",
 819 "wbwwwbbbW",
 820 "wbbwbbbWW",
 821 "wbbbbbWWw",
 822 "wwbbbWWww",
 823 "wwwbWWwww",
 824 "wwwwWwwww"
 825 };
 826
 827 static const char *selected_disabled_checked_menu_xpm[] = {
 828 /* columns rows colors chars-per-pixel */
 829 "9 9 2 1",
 830 "w c None",
 831 "b c #7f7f7f",
 832 /* pixels */
 833 "wwwwwwwww",
 834 "wwwwwwwbw",
 835 "wwwwwwbbw",
 836 "wbwwwbbbw",
 837 "wbbwbbbww",
 838 "wbbbbbwww",
 839 "wwbbbwwww",
 840 "wwwbwwwww",
 841 "wwwwwwwww"
 842 };
 843
 844 // checkbox and radiobox bitmaps below
 845
 846 static const char *checked_xpm[] = {
 847 /* columns rows colors chars-per-pixel */
 848 "13 13 5 1",
 849 "w c white",
 850 "b c black",
 851 "d c #7f7f7f",
 852 "g c #c0c0c0",
 853 "h c #e0e0e0",
 854 /* pixels */
 855 "ddddddddddddh",
 856 "dbbbbbbbbbbgh",
 857 "dbwwwwwwwwwgh",
 858 "dbwwwwwwwbwgh",
 859 "dbwwwwwwbbwgh",
 860 "dbwbwwwbbbwgh",
 861 "dbwbbwbbbwwgh",
 862 "dbwbbbbbwwwgh",
 863 "dbwwbbbwwwwgh",
 864 "dbwwwbwwwwwgh",
 865 "dbwwwwwwwwwgh",
 866 "dgggggggggggh",
 867 "hhhhhhhhhhhhh"
 868 };
 869
 870 static const char *pressed_checked_xpm[] = {
 871 /* columns rows colors chars-per-pixel */
 872 "13 13 4 1",
 873 "b c black",
 874 "d c #7f7f7f",
 875 "g c #c0c0c0",
 876 "h c #e0e0e0",
 877 /* pixels */
 878 "ddddddddddddh",
 879 "dbbbbbbbbbbgh",
 880 "dbggggggggggh",
 881 "dbgggggggbggh",
 882 "dbggggggbbggh",
 883 "dbgbgggbbbggh",
 884 "dbgbbgbbbgggh",
 885 "dbgbbbbbggggh",
 886 "dbggbbbgggggh",
 887 "dbgggbggggggh",
 888 "dbggggggggggh",
 889 "dgggggggggggh",
 890 "hhhhhhhhhhhhh"
 891 };
 892
 893 static const char *pressed_disabled_checked_xpm[] = {
 894 /* columns rows colors chars-per-pixel */
 895 "13 13 4 1",
 896 "b c black",
 897 "d c #7f7f7f",
 898 "g c #c0c0c0",
 899 "h c #e0e0e0",
 900 /* pixels */
 901 "ddddddddddddh",
 902 "dbbbbbbbbbbgh",
 903 "dbggggggggggh",
 904 "dbgggggggdggh",
 905 "dbggggggddggh",
 906 "dbgdgggdddggh",
 907 "dbgddgdddgggh",
 908 "dbgdddddggggh",
 909 "dbggdddgggggh",
 910 "dbgggdggggggh",
 911 "dbggggggggggh",
 912 "dgggggggggggh",
 913 "hhhhhhhhhhhhh"
 914 };
 915
 916 static const char *checked_item_xpm[] = {
 917 /* columns rows colors chars-per-pixel */
 918 "13 13 3 1",
 919 "w c white",
 920 "b c black",
 921 "d c #808080",
 922 /* pixels */
 923 "wwwwwwwwwwwww",
 924 "wdddddddddddw",
 925 "wdwwwwwwwwwdw",
 926 "wdwwwwwwwbwdw",
 927 "wdwwwwwwbbwdw",
 928 "wdwbwwwbbbwdw",
 929 "wdwbbwbbbwwdw",
 930 "wdwbbbbbwwwdw",
 931 "wdwwbbbwwwwdw",
 932 "wdwwwbwwwwwdw",
 933 "wdwwwwwwwwwdw",
 934 "wdddddddddddw",
 935 "wwwwwwwwwwwww"
 936 };
 937
 938 static const char *unchecked_xpm[] = {
 939 /* columns rows colors chars-per-pixel */
 940 "13 13 5 1",
 941 "w c white",
 942 "b c black",
 943 "d c #7f7f7f",
 944 "g c #c0c0c0",
 945 "h c #e0e0e0",
 946 /* pixels */
 947 "ddddddddddddh",
 948 "dbbbbbbbbbbgh",
 949 "dbwwwwwwwwwgh",
 950 "dbwwwwwwwwwgh",
 951 "dbwwwwwwwwwgh",
 952 "dbwwwwwwwwwgh",
 953 "dbwwwwwwwwwgh",
 954 "dbwwwwwwwwwgh",
 955 "dbwwwwwwwwwgh",
 956 "dbwwwwwwwwwgh",
 957 "dbwwwwwwwwwgh",
 958 "dgggggggggggh",
 959 "hhhhhhhhhhhhh"
 960 };
 961
 962 static const char *pressed_unchecked_xpm[] = {
 963 /* columns rows colors chars-per-pixel */
 964 "13 13 4 1",
 965 "b c black",
 966 "d c #7f7f7f",
 967 "g c #c0c0c0",
 968 "h c #e0e0e0",
 969 /* pixels */
 970 "ddddddddddddh",
 971 "dbbbbbbbbbbgh",
 972 "dbggggggggggh",
 973 "dbggggggggggh",
 974 "dbggggggggggh",
 975 "dbggggggggggh",
 976 "dbggggggggggh",
 977 "dbggggggggggh",
 978 "dbggggggggggh",
 979 "dbggggggggggh",
 980 "dbggggggggggh",
 981 "dbggggggggggh",
 982 "hhhhhhhhhhhhh"
 983 };
 984
 985 static const char *unchecked_item_xpm[] = {
 986 /* columns rows colors chars-per-pixel */
 987 "13 13 2 1",
 988 "w c white",
 989 "d c #808080",
 990 /* pixels */
 991 "wwwwwwwwwwwww",
 992 "wdddddddddddw",
 993 "wdwwwwwwwwwdw",
 994 "wdwwwwwwwwwdw",
 995 "wdwwwwwwwwwdw",
 996 "wdwwwwwwwwwdw",
 997 "wdwwwwwwwwwdw",
 998 "wdwwwwwwwwwdw",
 999 "wdwwwwwwwwwdw",
1000 "wdwwwwwwwwwdw",
1001 "wdwwwwwwwwwdw",
1002 "wdddddddddddw",
1003 "wwwwwwwwwwwww"
1004 };
1005
1006 static const char *checked_radio_xpm[] = {
1007 /* columns rows colors chars-per-pixel */
1008 "12 12 6 1",
1009 "  c None",
1010 "w c white",
1011 "b c black",
1012 "d c #7f7f7f",
1013 "g c #c0c0c0",
1014 "h c #e0e0e0",
1015 /* pixels */
1016 "    dddd    ",
1017 "  ddbbbbdd  ",
1018 " dbbwwwwbbh ",
1019 " dbwwwwwwgh ",
1020 "dbwwwbbwwwgh",
1021 "dbwwbbbbwwgh",
1022 "dbwwbbbbwwgh",
1023 "dbwwwbbwwwgh",
1024 " dbwwwwwwgh ",
1025 " dggwwwwggh ",
1026 "  hhgggghh  ",
1027 "    hhhh    "
1028 };
1029
1030 static const char *pressed_checked_radio_xpm[] = {
1031 /* columns rows colors chars-per-pixel */
1032 "12 12 6 1",
1033 "  c None",
1034 "w c white",
1035 "b c black",
1036 "d c #7f7f7f",
1037 "g c #c0c0c0",
1038 "h c #e0e0e0",
1039 /* pixels */
1040 "    dddd    ",
1041 "  ddbbbbdd  ",
1042 " dbbggggbbh ",
1043 " dbgggggggh ",
1044 "dbgggbbggggh",
1045 "dbggbbbbgggh",
1046 "dbggbbbbgggh",
1047 "dbgggbbggggh",
1048 " dbgggggggh ",
1049 " dggggggggh ",
1050 "  hhgggghh  ",
1051 "    hhhh    "
1052 };
1053
1054 static const char *pressed_disabled_checked_radio_xpm[] = {
1055 /* columns rows colors chars-per-pixel */
1056 "12 12 6 1",
1057 "  c None",
1058 "w c white",
1059 "b c black",
1060 "d c #7f7f7f",
1061 "g c #c0c0c0",
1062 "h c #e0e0e0",
1063 /* pixels */
1064 "    dddd    ",
1065 "  ddbbbbdd  ",
1066 " dbbggggbbh ",
1067 " dbgggggggh ",
1068 "dbgggddggggh",
1069 "dbggddddgggh",
1070 "dbggddddgggh",
1071 "dbgggddggggh",
1072 " dbgggggggh ",
1073 " dggggggggh ",
1074 "  hhgggghh  ",
1075 "    hhhh    ",
1076 };
1077
1078 static const char *unchecked_radio_xpm[] = {
1079 /* columns rows colors chars-per-pixel */
1080 "12 12 6 1",
1081 "  c None",
1082 "w c white",
1083 "b c black",
1084 "d c #7f7f7f",
1085 "g c #c0c0c0",
1086 "h c #e0e0e0",
1087 /* pixels */
1088 "    dddd    ",
1089 "  ddbbbbdd  ",
1090 " dbbwwwwbbh ",
1091 " dbwwwwwwgh ",
1092 "dbwwwwwwwwgh",
1093 "dbwwwwwwwwgh",
1094 "dbwwwwwwwwgh",
1095 "dbwwwwwwwwgh",
1096 " dbwwwwwwgh ",
1097 " dggwwwwggh ",
1098 "  hhgggghh  ",
1099 "    hhhh    "
1100 };
1101
1102 static const char *pressed_unchecked_radio_xpm[] = {
1103 /* columns rows colors chars-per-pixel */
1104 "12 12 6 1",
1105 "  c None",
1106 "w c white",
1107 "b c black",
1108 "d c #7f7f7f",
1109 "g c #c0c0c0",
1110 "h c #e0e0e0",
1111 /* pixels */
1112 "    dddd    ",
1113 "  ddbbbbdd  ",
1114 " dbbggggbbh ",
1115 " dbgggggggh ",
1116 "dbgggggggggh",
1117 "dbgggggggggh",
1118 "dbgggggggggh",
1119 "dbgggggggggh",
1120 " dbgggggggh ",
1121 " dggggggggh ",
1122 "  hhgggghh  ",
1123 "    hhhh    "
1124 };
1125
1126 static const char **
1127     xpmIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
1128 {
1129     // checkboxes first
1130     {
1131         // normal state
1132         { checked_xpm, unchecked_xpm },
1133
1134         // pressed state
1135         { pressed_checked_xpm, pressed_unchecked_xpm },
1136
1137         // disabled state
1138         { pressed_disabled_checked_xpm, pressed_unchecked_xpm },
1139     },
1140
1141     // radio
1142     {
1143         // normal state
1144         { checked_radio_xpm, unchecked_radio_xpm },
1145
1146         // pressed state
1147         { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm },
1148
1149         // disabled state
1150         { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm },
1151     },
1152
1153     // menu
1154     {
1155         // normal state
1156         { checked_menu_xpm, NULL },
1157
1158         // selected state
1159         { selected_checked_menu_xpm, NULL },
1160
1161         // disabled state
1162         { disabled_checked_menu_xpm, NULL },
1163
1164         // disabled selected state
1165         { selected_disabled_checked_menu_xpm, NULL },
1166     }
1167 };
1168
1169 static const char **xpmChecked[IndicatorStatus_Max] =
1170 {
1171     checked_item_xpm,
1172     unchecked_item_xpm
1173 };
1174
1175 // ============================================================================
1176 // implementation
1177 // ============================================================================
1178
1179 WX_IMPLEMENT_THEME(wxWin32Theme, win32, wxTRANSLATE("Win32 theme"));
1180
1181 // ----------------------------------------------------------------------------
1182 // wxWin32Theme
1183 // ----------------------------------------------------------------------------
1184
1185 wxWin32Theme::wxWin32Theme()
1186 {
1187     m_scheme = NULL;
1188     m_renderer = NULL;
1189     m_handlerDefault = NULL;
1190     m_artProvider = NULL;
1191 }
1192
1193 wxWin32Theme::~wxWin32Theme()
1194 {
1195     size_t count = m_handlers.GetCount();
1196     for ( size_t n = 0; n < count; n++ )
1197     {
1198         if ( m_handlers[n] != m_handlerDefault )
1199             delete m_handlers[n];
1200     }
1201
1202     delete m_handlerDefault;
1203
1204     delete m_renderer;
1205     delete m_scheme;
1206     wxArtProvider::RemoveProvider(m_artProvider);
1207 }
1208
1209 wxRenderer *wxWin32Theme::GetRenderer()
1210 {
1211     if ( !m_renderer )
1212     {
1213         m_renderer = new wxWin32Renderer(GetColourScheme());
1214     }
1215
1216     return m_renderer;
1217 }
1218
1219 wxArtProvider *wxWin32Theme::GetArtProvider()
1220 {
1221     if ( !m_artProvider )
1222     {
1223         m_artProvider = new wxWin32ArtProvider;
1224     }
1225
1226     return m_artProvider;
1227 }
1228
1229 wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
1230 {
1231     if ( !m_handlerDefault )
1232     {
1233         m_handlerDefault = new wxWin32InputHandler(m_renderer);
1234     }
1235
1236     return m_handlerDefault;
1237 }
1238
1239 wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
1240 {
1241     wxInputHandler *handler;
1242     int n = m_handlerNames.Index(control);
1243     if ( n == wxNOT_FOUND )
1244     {
1245         // create a new handler
1246         if ( control == wxINP_HANDLER_SCROLLBAR )
1247             handler = new wxWin32ScrollBarInputHandler(m_renderer,
1248                                                        GetDefaultInputHandler());
1249 #if wxUSE_BUTTON
1250         else if ( control == wxINP_HANDLER_BUTTON )
1251             handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
1252 #endif // wxUSE_BUTTON
1253 #if wxUSE_CHECKBOX
1254         else if ( control == wxINP_HANDLER_CHECKBOX )
1255             handler = new wxWin32CheckboxInputHandler(GetDefaultInputHandler());
1256 #endif // wxUSE_CHECKBOX
1257 #if wxUSE_COMBOBOX
1258         else if ( control == wxINP_HANDLER_COMBOBOX )
1259             handler = new wxStdComboBoxInputHandler(GetDefaultInputHandler());
1260 #endif // wxUSE_COMBOBOX
1261 #if wxUSE_LISTBOX
1262         else if ( control == wxINP_HANDLER_LISTBOX )
1263             handler = new wxStdListboxInputHandler(GetDefaultInputHandler());
1264 #endif // wxUSE_LISTBOX
1265 #if wxUSE_CHECKLISTBOX
1266         else if ( control == wxINP_HANDLER_CHECKLISTBOX )
1267             handler = new wxStdCheckListboxInputHandler(GetDefaultInputHandler());
1268 #endif // wxUSE_CHECKLISTBOX
1269 #if wxUSE_TEXTCTRL
1270         else if ( control == wxINP_HANDLER_TEXTCTRL )
1271             handler = new wxWin32TextCtrlInputHandler(GetDefaultInputHandler());
1272 #endif // wxUSE_TEXTCTRL
1273 #if wxUSE_SLIDER
1274         else if ( control == wxINP_HANDLER_SLIDER )
1275             handler = new wxStdSliderButtonInputHandler(GetDefaultInputHandler());
1276 #endif // wxUSE_SLIDER
1277 #if wxUSE_SPINBTN
1278         else if ( control == wxINP_HANDLER_SPINBTN )
1279             handler = new wxStdSpinButtonInputHandler(GetDefaultInputHandler());
1280 #endif // wxUSE_SPINBTN
1281 #if wxUSE_NOTEBOOK
1282         else if ( control == wxINP_HANDLER_NOTEBOOK )
1283             handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
1284 #endif // wxUSE_NOTEBOOK
1285 #if wxUSE_STATUSBAR
1286         else if ( control == wxINP_HANDLER_STATUSBAR )
1287             handler = new wxWin32StatusBarInputHandler(GetDefaultInputHandler());
1288 #endif // wxUSE_STATUSBAR
1289 #if wxUSE_TOOLBAR
1290         else if ( control == wxINP_HANDLER_TOOLBAR )
1291             handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
1292 #endif // wxUSE_TOOLBAR
1293         else if ( control == wxINP_HANDLER_TOPLEVEL )
1294             handler = new wxWin32FrameInputHandler(GetDefaultInputHandler());
1295         else
1296             handler = GetDefaultInputHandler();
1297
1298         n = m_handlerNames.Add(control);
1299         m_handlers.Insert(handler, n);
1300     }
1301     else // we already have it
1302     {
1303         handler = m_handlers[n];
1304     }
1305
1306     return handler;
1307 }
1308
1309 wxColourScheme *wxWin32Theme::GetColourScheme()
1310 {
1311     if ( !m_scheme )
1312     {
1313         m_scheme = new wxWin32ColourScheme;
1314     }
1315     return m_scheme;
1316 }
1317
1318 // ============================================================================
1319 // wxWin32ColourScheme
1320 // ============================================================================
1321
1322 wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
1323 {
1324     wxColour col;
1325     if ( win->UseBgCol() )
1326     {
1327         // use the user specified colour
1328         col = win->GetBackgroundColour();
1329     }
1330
1331     if ( win->IsContainerWindow() )
1332     {
1333         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
1334         if ( text )
1335         {
1336             if ( !text->IsEnabled() ) // not IsEditable()
1337                 col = Get(CONTROL);
1338             //else: execute code below
1339         }
1340
1341         if ( !col.Ok() )
1342         {
1343             // doesn't depend on the state
1344             col = Get(WINDOW);
1345         }
1346     }
1347     else
1348     {
1349         int flags = win->GetStateFlags();
1350
1351         // the colour set by the user should be used for the normal state
1352         // and for the states for which we don't have any specific colours
1353         if ( !col.Ok() || (flags & wxCONTROL_PRESSED) != 0 )
1354         {
1355             if ( wxDynamicCast(win, wxScrollBar) )
1356                 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
1357                                                     : SCROLLBAR);
1358             else
1359                 col = Get(CONTROL);
1360         }
1361     }
1362
1363     return col;
1364 }
1365
1366 wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
1367 {
1368     switch ( col )
1369     {
1370         // use the system colours under Windows
1371 #if defined(__WXMSW__)
1372         case WINDOW:            return wxColour(GetSysColor(COLOR_WINDOW));
1373
1374         case CONTROL_PRESSED:
1375         case CONTROL_CURRENT:
1376         case CONTROL:           return wxColour(GetSysColor(COLOR_BTNFACE));
1377
1378         case CONTROL_TEXT:      return wxColour(GetSysColor(COLOR_BTNTEXT));
1379
1380 #if defined(COLOR_3DLIGHT)
1381         case SCROLLBAR:         return wxColour(GetSysColor(COLOR_3DLIGHT));
1382 #else
1383         case SCROLLBAR:         return wxColour(0xe0e0e0);
1384 #endif
1385         case SCROLLBAR_PRESSED: return wxColour(GetSysColor(COLOR_BTNTEXT));
1386
1387         case HIGHLIGHT:         return wxColour(GetSysColor(COLOR_HIGHLIGHT));
1388         case HIGHLIGHT_TEXT:    return wxColour(GetSysColor(COLOR_HIGHLIGHTTEXT));
1389
1390 #if defined(COLOR_3DDKSHADOW)
1391         case SHADOW_DARK:       return wxColour(GetSysColor(COLOR_3DDKSHADOW));
1392 #else
1393         case SHADOW_DARK:       return wxColour(GetSysColor(COLOR_3DHADOW));
1394 #endif
1395
1396         case CONTROL_TEXT_DISABLED:
1397         case SHADOW_HIGHLIGHT:  return wxColour(GetSysColor(COLOR_BTNHIGHLIGHT));
1398
1399         case SHADOW_IN:         return wxColour(GetSysColor(COLOR_BTNFACE));
1400
1401         case CONTROL_TEXT_DISABLED_SHADOW:
1402         case SHADOW_OUT:        return wxColour(GetSysColor(COLOR_BTNSHADOW));
1403
1404         case TITLEBAR:          return wxColour(GetSysColor(COLOR_INACTIVECAPTION));
1405         case TITLEBAR_ACTIVE:   return wxColour(GetSysColor(COLOR_ACTIVECAPTION));
1406         case TITLEBAR_TEXT:     return wxColour(GetSysColor(COLOR_INACTIVECAPTIONTEXT));
1407         case TITLEBAR_ACTIVE_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
1408
1409         case DESKTOP:           return wxColour(0x808000);
1410 #else // !__WXMSW__
1411         // use the standard Windows colours elsewhere
1412         case WINDOW:            return *wxWHITE;
1413
1414         case CONTROL_PRESSED:
1415         case CONTROL_CURRENT:
1416         case CONTROL:           return wxColour(0xc0c0c0);
1417
1418         case CONTROL_TEXT:      return *wxBLACK;
1419
1420         case SCROLLBAR:         return wxColour(0xe0e0e0);
1421         case SCROLLBAR_PRESSED: return *wxBLACK;
1422
1423         case HIGHLIGHT:         return wxColour(0x800000);
1424         case HIGHLIGHT_TEXT:    return wxColour(0xffffff);
1425
1426         case SHADOW_DARK:       return *wxBLACK;
1427
1428         case CONTROL_TEXT_DISABLED:return wxColour(0xe0e0e0);
1429         case SHADOW_HIGHLIGHT:  return wxColour(0xffffff);
1430
1431         case SHADOW_IN:         return wxColour(0xc0c0c0);
1432
1433         case CONTROL_TEXT_DISABLED_SHADOW:
1434         case SHADOW_OUT:        return wxColour(0x7f7f7f);
1435
1436         case TITLEBAR:          return wxColour(0xaeaaae);
1437         case TITLEBAR_ACTIVE:   return wxColour(0x820300);
1438         case TITLEBAR_TEXT:     return wxColour(0xc0c0c0);
1439         case TITLEBAR_ACTIVE_TEXT:return *wxWHITE;
1440
1441         case DESKTOP:           return wxColour(0x808000);
1442 #endif // __WXMSW__
1443
1444         case GAUGE:             return Get(HIGHLIGHT);
1445
1446         case MAX:
1447         default:
1448             wxFAIL_MSG(_T("invalid standard colour"));
1449             return *wxBLACK;
1450     }
1451 }
1452
1453 // ============================================================================
1454 // wxWin32Renderer
1455 // ============================================================================
1456
1457 // ----------------------------------------------------------------------------
1458 // construction
1459 // ----------------------------------------------------------------------------
1460
1461 wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
1462 {
1463     // init data
1464     m_scheme = scheme;
1465     m_sizeScrollbarArrow = wxSize(16, 16);
1466
1467     // init colours and pens
1468     m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
1469
1470     m_colDarkGrey = wxSCHEME_COLOUR(scheme, SHADOW_OUT);
1471     m_penDarkGrey = wxPen(m_colDarkGrey, 0, wxSOLID);
1472
1473     m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
1474
1475     m_colHighlight = wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT);
1476     m_penHighlight = wxPen(m_colHighlight, 0, wxSOLID);
1477
1478     m_titlebarFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
1479     m_titlebarFont.SetWeight(wxFONTWEIGHT_BOLD);
1480
1481     // init the arrow bitmaps
1482     static const size_t ARROW_WIDTH = 7;
1483     static const size_t ARROW_LENGTH = 4;
1484
1485     wxMask *mask;
1486     wxMemoryDC dcNormal,
1487                dcDisabled,
1488                dcInverse;
1489     for ( size_t n = 0; n < Arrow_Max; n++ )
1490     {
1491         bool isVertical = n > Arrow_Right;
1492         int w, h;
1493         if ( isVertical )
1494         {
1495             w = ARROW_WIDTH;
1496             h = ARROW_LENGTH;
1497         }
1498         else
1499         {
1500             h = ARROW_WIDTH;
1501             w = ARROW_LENGTH;
1502         }
1503
1504         // disabled arrow is larger because of the shadow
1505         m_bmpArrows[Arrow_Normal][n].Create(w, h);
1506         m_bmpArrows[Arrow_Disabled][n].Create(w + 1, h + 1);
1507
1508         dcNormal.SelectObject(m_bmpArrows[Arrow_Normal][n]);
1509         dcDisabled.SelectObject(m_bmpArrows[Arrow_Disabled][n]);
1510
1511         dcNormal.SetBackground(*wxWHITE_BRUSH);
1512         dcDisabled.SetBackground(*wxWHITE_BRUSH);
1513         dcNormal.Clear();
1514         dcDisabled.Clear();
1515
1516         dcNormal.SetPen(m_penBlack);
1517         dcDisabled.SetPen(m_penDarkGrey);
1518
1519         // calculate the position of the point of the arrow
1520         wxCoord x1, y1;
1521         if ( isVertical )
1522         {
1523             x1 = (ARROW_WIDTH - 1)/2;
1524             y1 = n == Arrow_Up ? 0 : ARROW_LENGTH - 1;
1525         }
1526         else // horizontal
1527         {
1528             x1 = n == Arrow_Left ? 0 : ARROW_LENGTH - 1;
1529             y1 = (ARROW_WIDTH - 1)/2;
1530         }
1531
1532         wxCoord x2 = x1,
1533                 y2 = y1;
1534
1535         if ( isVertical )
1536             x2++;
1537         else
1538             y2++;
1539
1540         for ( size_t i = 0; i < ARROW_LENGTH; i++ )
1541         {
1542             dcNormal.DrawLine(x1, y1, x2, y2);
1543             dcDisabled.DrawLine(x1, y1, x2, y2);
1544
1545             if ( isVertical )
1546             {
1547                 x1--;
1548                 x2++;
1549
1550                 if ( n == Arrow_Up )
1551                 {
1552                     y1++;
1553                     y2++;
1554                 }
1555                 else // down arrow
1556                 {
1557                     y1--;
1558                     y2--;
1559                 }
1560             }
1561             else // left or right arrow
1562             {
1563                 y1--;
1564                 y2++;
1565
1566                 if ( n == Arrow_Left )
1567                 {
1568                     x1++;
1569                     x2++;
1570                 }
1571                 else
1572                 {
1573                     x1--;
1574                     x2--;
1575                 }
1576             }
1577         }
1578
1579         // draw the shadow for the disabled one
1580         dcDisabled.SetPen(m_penHighlight);
1581         switch ( n )
1582         {
1583             case Arrow_Left:
1584                 y1 += 2;
1585                 dcDisabled.DrawLine(x1, y1, x2, y2);
1586                 break;
1587
1588             case Arrow_Right:
1589                 x1 = ARROW_LENGTH - 1;
1590                 y1 = (ARROW_WIDTH - 1)/2 + 1;
1591                 x2 = 0;
1592                 y2 = ARROW_WIDTH;
1593                 dcDisabled.DrawLine(x1, y1, x2, y2);
1594                 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
1595                 break;
1596
1597             case Arrow_Up:
1598                 x1 += 2;
1599                 dcDisabled.DrawLine(x1, y1, x2, y2);
1600                 break;
1601
1602             case Arrow_Down:
1603                 x1 = ARROW_WIDTH - 1;
1604                 y1 = 1;
1605                 x2 = (ARROW_WIDTH - 1)/2;
1606                 y2 = ARROW_LENGTH;
1607                 dcDisabled.DrawLine(x1, y1, x2, y2);
1608                 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
1609                 break;
1610
1611         }
1612
1613         // create the inversed bitmap but only for the right arrow as we only
1614         // use it for the menus
1615         if ( n == Arrow_Right )
1616         {
1617             m_bmpArrows[Arrow_Inversed][n].Create(w, h);
1618             dcInverse.SelectObject(m_bmpArrows[Arrow_Inversed][n]);
1619             dcInverse.Clear();
1620             dcInverse.Blit(0, 0, w, h,
1621                           &dcNormal, 0, 0,
1622                           wxXOR);
1623             dcInverse.SelectObject(wxNullBitmap);
1624
1625             mask = new wxMask(m_bmpArrows[Arrow_Inversed][n], *wxBLACK);
1626             m_bmpArrows[Arrow_Inversed][n].SetMask(mask);
1627
1628             m_bmpArrows[Arrow_InversedDisabled][n].Create(w, h);
1629             dcInverse.SelectObject(m_bmpArrows[Arrow_InversedDisabled][n]);
1630             dcInverse.Clear();
1631             dcInverse.Blit(0, 0, w, h,
1632                           &dcDisabled, 0, 0,
1633                           wxXOR);
1634             dcInverse.SelectObject(wxNullBitmap);
1635
1636             mask = new wxMask(m_bmpArrows[Arrow_InversedDisabled][n], *wxBLACK);
1637             m_bmpArrows[Arrow_InversedDisabled][n].SetMask(mask);
1638         }
1639
1640         dcNormal.SelectObject(wxNullBitmap);
1641         dcDisabled.SelectObject(wxNullBitmap);
1642
1643         mask = new wxMask(m_bmpArrows[Arrow_Normal][n], *wxWHITE);
1644         m_bmpArrows[Arrow_Normal][n].SetMask(mask);
1645         mask = new wxMask(m_bmpArrows[Arrow_Disabled][n], *wxWHITE);
1646         m_bmpArrows[Arrow_Disabled][n].SetMask(mask);
1647
1648         m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
1649     }
1650
1651     // init the frame buttons bitmaps
1652     m_bmpFrameButtons[FrameButton_Close] = wxBitmap(frame_button_close_xpm);
1653     m_bmpFrameButtons[FrameButton_Minimize] = wxBitmap(frame_button_minimize_xpm);
1654     m_bmpFrameButtons[FrameButton_Maximize] = wxBitmap(frame_button_maximize_xpm);
1655     m_bmpFrameButtons[FrameButton_Restore] = wxBitmap(frame_button_restore_xpm);
1656     m_bmpFrameButtons[FrameButton_Help] = wxBitmap(frame_button_help_xpm);
1657 }
1658
1659 // ----------------------------------------------------------------------------
1660 // border stuff
1661 // ----------------------------------------------------------------------------
1662
1663 /*
1664    The raised border in Win32 looks like this:
1665
1666    IIIIIIIIIIIIIIIIIIIIIIB
1667    I                    GB
1668    I                    GB  I = white       (HILIGHT)
1669    I                    GB  H = light grey  (LIGHT)
1670    I                    GB  G = dark grey   (SHADOI)
1671    I                    GB  B = black       (DKSHADOI)
1672    I                    GB  I = hIghlight (COLOR_3DHILIGHT)
1673    I                    GB
1674    IGGGGGGGGGGGGGGGGGGGGGB
1675    BBBBBBBBBBBBBBBBBBBBBBB
1676
1677    The sunken border looks like this:
1678
1679    GGGGGGGGGGGGGGGGGGGGGGI
1680    GBBBBBBBBBBBBBBBBBBBBHI
1681    GB                   HI
1682    GB                   HI
1683    GB                   HI
1684    GB                   HI
1685    GB                   HI
1686    GB                   HI
1687    GHHHHHHHHHHHHHHHHHHHHHI
1688    IIIIIIIIIIIIIIIIIIIIIII
1689
1690    The static border (used for the controls which don't get focus) is like
1691    this:
1692
1693    GGGGGGGGGGGGGGGGGGGGGGW
1694    G                     W
1695    G                     W
1696    G                     W
1697    G                     W
1698    G                     W
1699    G                     W
1700    G                     W
1701    WWWWWWWWWWWWWWWWWWWWWWW
1702
1703    The most complicated is the double border:
1704
1705    HHHHHHHHHHHHHHHHHHHHHHB
1706    HWWWWWWWWWWWWWWWWWWWWGB
1707    HWHHHHHHHHHHHHHHHHHHHGB
1708    HWH                 HGB
1709    HWH                 HGB
1710    HWH                 HGB
1711    HWH                 HGB
1712    HWHHHHHHHHHHHHHHHHHHHGB
1713    HGGGGGGGGGGGGGGGGGGGGGB
1714    BBBBBBBBBBBBBBBBBBBBBBB
1715
1716    And the simple border is, well, simple:
1717
1718    BBBBBBBBBBBBBBBBBBBBBBB
1719    B                     B
1720    B                     B
1721    B                     B
1722    B                     B
1723    B                     B
1724    B                     B
1725    B                     B
1726    B                     B
1727    BBBBBBBBBBBBBBBBBBBBBBB
1728 */
1729
1730 void wxWin32Renderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
1731 {
1732     // draw
1733     dc.SetPen(pen);
1734     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1735     dc.DrawRectangle(*rect);
1736
1737     // adjust the rect
1738     rect->Inflate(-1);
1739 }
1740
1741 void wxWin32Renderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
1742 {
1743     // draw the bottom and right sides
1744     dc.SetPen(pen);
1745     dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
1746                 rect->GetRight() + 1, rect->GetBottom());
1747     dc.DrawLine(rect->GetRight(), rect->GetTop(),
1748                 rect->GetRight(), rect->GetBottom());
1749
1750     // adjust the rect
1751     rect->Inflate(-1);
1752 }
1753
1754 void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
1755                                      const wxPen& pen1, const wxPen& pen2)
1756 {
1757     // draw the rectangle
1758     dc.SetPen(pen1);
1759     dc.DrawLine(rect->GetLeft(), rect->GetTop(),
1760                 rect->GetLeft(), rect->GetBottom());
1761     dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
1762                 rect->GetRight(), rect->GetTop());
1763     dc.SetPen(pen2);
1764     dc.DrawLine(rect->GetRight(), rect->GetTop(),
1765                 rect->GetRight(), rect->GetBottom());
1766     dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
1767                 rect->GetRight() + 1, rect->GetBottom());
1768
1769     // adjust the rect
1770     rect->Inflate(-1);
1771 }
1772
1773 void wxWin32Renderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
1774 {
1775     DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
1776     DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
1777 }
1778
1779 void wxWin32Renderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
1780 {
1781     DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
1782     DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
1783 }
1784
1785 void wxWin32Renderer::DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed)
1786 {
1787     if ( isPressed )
1788     {
1789         DrawRect(dc, rect, m_penDarkGrey);
1790
1791         // the arrow is usually drawn inside border of width 2 and is offset by
1792         // another pixel in both directions when it's pressed - as the border
1793         // in this case is more narrow as well, we have to adjust rect like
1794         // this:
1795         rect->Inflate(-1);
1796         rect->x++;
1797         rect->y++;
1798     }
1799     else
1800     {
1801         DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
1802         DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
1803     }
1804 }
1805
1806 void wxWin32Renderer::DrawBorder(wxDC& dc,
1807                                  wxBorder border,
1808                                  const wxRect& rectTotal,
1809                                  int WXUNUSED(flags),
1810                                  wxRect *rectIn)
1811 {
1812     int i;
1813
1814     wxRect rect = rectTotal;
1815
1816     switch ( border )
1817     {
1818         case wxBORDER_SUNKEN:
1819             for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1820             {
1821                 DrawSunkenBorder(dc, &rect);
1822             }
1823             break;
1824
1825         case wxBORDER_STATIC:
1826             DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
1827             break;
1828
1829         case wxBORDER_RAISED:
1830             for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1831             {
1832                 DrawRaisedBorder(dc, &rect);
1833             }
1834             break;
1835
1836         case wxBORDER_DOUBLE:
1837             DrawArrowBorder(dc, &rect);
1838             DrawRect(dc, &rect, m_penLightGrey);
1839             break;
1840
1841         case wxBORDER_SIMPLE:
1842             for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1843             {
1844                 DrawRect(dc, &rect, m_penBlack);
1845             }
1846             break;
1847
1848         default:
1849             wxFAIL_MSG(_T("unknown border type"));
1850             // fall through
1851
1852         case wxBORDER_DEFAULT:
1853         case wxBORDER_NONE:
1854             break;
1855     }
1856
1857     if ( rectIn )
1858         *rectIn = rect;
1859 }
1860
1861 wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
1862 {
1863     wxCoord width;
1864     switch ( border )
1865     {
1866         case wxBORDER_RAISED:
1867         case wxBORDER_SUNKEN:
1868             width = BORDER_THICKNESS;
1869             break;
1870
1871         case wxBORDER_SIMPLE:
1872         case wxBORDER_STATIC:
1873             width = 1;
1874             break;
1875
1876         case wxBORDER_DOUBLE:
1877             width = 3;
1878             break;
1879
1880         default:
1881         {
1882             // char *crash = NULL;
1883             // *crash = 0;
1884             wxFAIL_MSG(_T("unknown border type"));
1885             // fall through
1886         }
1887
1888         case wxBORDER_DEFAULT:
1889         case wxBORDER_NONE:
1890             width = 0;
1891             break;
1892     }
1893
1894     wxRect rect;
1895     rect.x =
1896     rect.y =
1897     rect.width =
1898     rect.height = width;
1899
1900     return rect;
1901 }
1902
1903 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
1904 {
1905     return TRUE;
1906 }
1907
1908 // ----------------------------------------------------------------------------
1909 // borders
1910 // ----------------------------------------------------------------------------
1911
1912 void wxWin32Renderer::DrawTextBorder(wxDC& dc,
1913                                      wxBorder border,
1914                                      const wxRect& rect,
1915                                      int flags,
1916                                      wxRect *rectIn)
1917 {
1918     // text controls are not special under windows
1919     DrawBorder(dc, border, rect, flags, rectIn);
1920 }
1921
1922 void wxWin32Renderer::DrawButtonBorder(wxDC& dc,
1923                                        const wxRect& rectTotal,
1924                                        int flags,
1925                                        wxRect *rectIn)
1926 {
1927     wxRect rect = rectTotal;
1928
1929     if ( flags & wxCONTROL_PRESSED )
1930     {
1931         // button pressed: draw a double border around it
1932         DrawRect(dc, &rect, m_penBlack);
1933         DrawRect(dc, &rect, m_penDarkGrey);
1934     }
1935     else
1936     {
1937         // button not pressed
1938
1939         if ( flags & (wxCONTROL_FOCUSED | wxCONTROL_ISDEFAULT) )
1940         {
1941             // button either default or focused (or both): add an extra border around it
1942             DrawRect(dc, &rect, m_penBlack);
1943         }
1944
1945         // now draw a normal button
1946         DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
1947         DrawHalfRect(dc, &rect, m_penDarkGrey);
1948     }
1949
1950     if ( rectIn )
1951     {
1952         *rectIn = rect;
1953     }
1954 }
1955
1956 // ----------------------------------------------------------------------------
1957 // lines and frame
1958 // ----------------------------------------------------------------------------
1959
1960 void wxWin32Renderer::DrawHorizontalLine(wxDC& dc,
1961                                          wxCoord y, wxCoord x1, wxCoord x2)
1962 {
1963     dc.SetPen(m_penDarkGrey);
1964     dc.DrawLine(x1, y, x2 + 1, y);
1965     dc.SetPen(m_penHighlight);
1966     y++;
1967     dc.DrawLine(x1, y, x2 + 1, y);
1968 }
1969
1970 void wxWin32Renderer::DrawVerticalLine(wxDC& dc,
1971                                        wxCoord x, wxCoord y1, wxCoord y2)
1972 {
1973     dc.SetPen(m_penDarkGrey);
1974     dc.DrawLine(x, y1, x, y2 + 1);
1975     dc.SetPen(m_penHighlight);
1976     x++;
1977     dc.DrawLine(x, y1, x, y2 + 1);
1978 }
1979
1980 void wxWin32Renderer::DrawFrame(wxDC& dc,
1981                                 const wxString& label,
1982                                 const wxRect& rect,
1983                                 int flags,
1984                                 int alignment,
1985                                 int indexAccel)
1986 {
1987     wxCoord height = 0; // of the label
1988     wxRect rectFrame = rect;
1989     if ( !label.empty() )
1990     {
1991         // the text should touch the top border of the rect, so the frame
1992         // itself should be lower
1993         dc.GetTextExtent(label, NULL, &height);
1994         rectFrame.y += height / 2;
1995         rectFrame.height -= height / 2;
1996
1997         // we have to draw each part of the frame individually as we can't
1998         // erase the background beyond the label as it might contain some
1999         // pixmap already, so drawing everything and then overwriting part of
2000         // the frame with label doesn't work
2001
2002         // TODO: the +5 and space insertion should be customizable
2003
2004         wxRect rectText;
2005         rectText.x = rectFrame.x + 5;
2006         rectText.y = rect.y;
2007         rectText.width = rectFrame.width - 7; // +2 border width
2008         rectText.height = height;
2009
2010         wxString label2;
2011         label2 << _T(' ') << label << _T(' ');
2012         if ( indexAccel != -1 )
2013         {
2014             // adjust it as we prepended a space
2015             indexAccel++;
2016         }
2017
2018         wxRect rectLabel;
2019         DrawLabel(dc, label2, rectText, flags, alignment, indexAccel, &rectLabel);
2020
2021         StandardDrawFrame(dc, rectFrame, rectLabel);
2022     }
2023     else
2024     {
2025         // just draw the complete frame
2026         DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
2027         DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
2028     }
2029 }
2030
2031 // ----------------------------------------------------------------------------
2032 // label
2033 // ----------------------------------------------------------------------------
2034
2035 void wxWin32Renderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
2036 {
2037     // VZ: this doesn't work under Windows, the dotted pen has dots of 3
2038     //     pixels each while we really need dots here... PS_ALTERNATE might
2039     //     work, but it is for NT 5 only
2040 #if 0
2041     DrawRect(dc, &rect, wxPen(*wxBLACK, 0, wxDOT));
2042 #else
2043     // draw the pixels manually: note that to behave in the same manner as
2044     // DrawRect(), we must exclude the bottom and right borders from the
2045     // rectangle
2046     wxCoord x1 = rect.GetLeft(),
2047             y1 = rect.GetTop(),
2048             x2 = rect.GetRight(),
2049             y2 = rect.GetBottom();
2050
2051     dc.SetPen(wxPen(*wxBLACK, 0, wxSOLID));
2052
2053     // this seems to be closer than what Windows does than wxINVERT although
2054     // I'm still not sure if it's correct
2055     dc.SetLogicalFunction(wxAND_REVERSE);
2056
2057     wxCoord z;
2058     for ( z = x1 + 1; z < x2; z += 2 )
2059         dc.DrawPoint(z, rect.GetTop());
2060
2061     wxCoord shift = z == x2 ? 0 : 1;
2062     for ( z = y1 + shift; z < y2; z += 2 )
2063         dc.DrawPoint(x2, z);
2064
2065     shift = z == y2 ? 0 : 1;
2066     for ( z = x2 - shift; z > x1; z -= 2 )
2067         dc.DrawPoint(z, y2);
2068
2069     shift = z == x1 ? 0 : 1;
2070     for ( z = y2 - shift; z > y1; z -= 2 )
2071         dc.DrawPoint(x1, z);
2072
2073     dc.SetLogicalFunction(wxCOPY);
2074 #endif // 0/1
2075 }
2076
2077 void wxWin32Renderer::DrawLabelShadow(wxDC& dc,
2078                                       const wxString& label,
2079                                       const wxRect& rect,
2080                                       int alignment,
2081                                       int indexAccel)
2082 {
2083     // draw shadow of the text
2084     dc.SetTextForeground(m_colHighlight);
2085     wxRect rectShadow = rect;
2086     rectShadow.x++;
2087     rectShadow.y++;
2088     dc.DrawLabel(label, rectShadow, alignment, indexAccel);
2089
2090     // make the text grey
2091     dc.SetTextForeground(m_colDarkGrey);
2092 }
2093
2094 void wxWin32Renderer::DrawLabel(wxDC& dc,
2095                                 const wxString& label,
2096                                 const wxRect& rect,
2097                                 int flags,
2098                                 int alignment,
2099                                 int indexAccel,
2100                                 wxRect *rectBounds)
2101 {
2102     DoDrawLabel(dc, label, rect, flags, alignment, indexAccel, rectBounds);
2103 }
2104
2105 void wxWin32Renderer::DoDrawLabel(wxDC& dc,
2106                                   const wxString& label,
2107                                   const wxRect& rect,
2108                                   int flags,
2109                                   int alignment,
2110                                   int indexAccel,
2111                                   wxRect *rectBounds,
2112                                   const wxPoint& focusOffset)
2113 {
2114     // the underscores are not drawn for focused controls in wxMSW
2115     if ( flags & wxCONTROL_FOCUSED )
2116     {
2117         indexAccel = -1;
2118     }
2119
2120     if ( flags & wxCONTROL_DISABLED )
2121     {
2122         // the combination of wxCONTROL_SELECTED and wxCONTROL_DISABLED
2123         // currently only can happen for a menu item and it seems that Windows
2124         // doesn't draw the shadow in this case, so we don't do it neither
2125         if ( flags & wxCONTROL_SELECTED )
2126         {
2127             // just make the label text greyed out
2128             dc.SetTextForeground(m_colDarkGrey);
2129         }
2130         else // draw normal disabled label
2131         {
2132             DrawLabelShadow(dc, label, rect, alignment, indexAccel);
2133         }
2134     }
2135
2136     wxRect rectLabel;
2137     dc.DrawLabel(label, wxNullBitmap, rect, alignment, indexAccel, &rectLabel);
2138
2139     if ( flags & wxCONTROL_DISABLED )
2140     {
2141         // restore the fg colour
2142         dc.SetTextForeground(*wxBLACK);
2143     }
2144
2145     if ( flags & wxCONTROL_FOCUSED )
2146     {
2147         if ( focusOffset.x || focusOffset.y )
2148         {
2149             rectLabel.Inflate(focusOffset.x, focusOffset.y);
2150         }
2151
2152         DrawFocusRect(dc, rectLabel);
2153     }
2154
2155     if ( rectBounds )
2156         *rectBounds = rectLabel;
2157 }
2158
2159 void wxWin32Renderer::DrawButtonLabel(wxDC& dc,
2160                                       const wxString& label,
2161                                       const wxBitmap& image,
2162                                       const wxRect& rect,
2163                                       int flags,
2164                                       int alignment,
2165                                       int indexAccel,
2166                                       wxRect *rectBounds)
2167 {
2168     // the underscores are not drawn for focused controls in wxMSW
2169     if ( flags & wxCONTROL_PRESSED )
2170     {
2171         indexAccel = -1;
2172     }
2173
2174     wxRect rectLabel = rect;
2175     if ( !label.empty() )
2176     {
2177         // shift the label if a button is pressed
2178         if ( flags & wxCONTROL_PRESSED )
2179         {
2180             rectLabel.x++;
2181             rectLabel.y++;
2182         }
2183
2184         if ( flags & wxCONTROL_DISABLED )
2185         {
2186             DrawLabelShadow(dc, label, rectLabel, alignment, indexAccel);
2187         }
2188
2189         // leave enough space for the focus rectangle
2190         if ( flags & wxCONTROL_FOCUSED )
2191         {
2192             rectLabel.Inflate(-2);
2193         }
2194     }
2195
2196     dc.DrawLabel(label, image, rectLabel, alignment, indexAccel, rectBounds);
2197
2198     if ( !label.empty() && (flags & wxCONTROL_FOCUSED) )
2199     {
2200         if ( flags & wxCONTROL_PRESSED )
2201         {
2202             // the focus rectangle is never pressed, so undo the shift done
2203             // above
2204             rectLabel.x--;
2205             rectLabel.y--;
2206             rectLabel.width--;
2207             rectLabel.height--;
2208         }
2209
2210         DrawFocusRect(dc, rectLabel);
2211     }
2212 }
2213
2214 // ----------------------------------------------------------------------------
2215 // (check)listbox items
2216 // ----------------------------------------------------------------------------
2217
2218 void wxWin32Renderer::DrawItem(wxDC& dc,
2219                                const wxString& label,
2220                                const wxRect& rect,
2221                                int flags)
2222 {
2223     wxDCTextColourChanger colChanger(dc);
2224
2225     if ( flags & wxCONTROL_SELECTED )
2226     {
2227         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2228
2229         wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2230         dc.SetBrush(wxBrush(colBg, wxSOLID));
2231         dc.SetPen(wxPen(colBg, 0, wxSOLID));
2232         dc.DrawRectangle(rect);
2233     }
2234
2235     wxRect rectText = rect;
2236     rectText.x += 2;
2237     rectText.width -= 2;
2238     dc.DrawLabel(label, wxNullBitmap, rectText);
2239
2240     if ( flags & wxCONTROL_FOCUSED )
2241     {
2242         DrawFocusRect(dc, rect);
2243     }
2244 }
2245
2246 void wxWin32Renderer::DrawCheckItem(wxDC& dc,
2247                                     const wxString& label,
2248                                     const wxBitmap& bitmap,
2249                                     const wxRect& rect,
2250                                     int flags)
2251 {
2252     wxBitmap bmp;
2253     if ( bitmap.Ok() )
2254     {
2255         bmp = bitmap;
2256     }
2257     else // use default bitmap
2258     {
2259         IndicatorStatus i = flags & wxCONTROL_CHECKED
2260                                 ? IndicatorStatus_Checked
2261                                 : IndicatorStatus_Unchecked;
2262
2263         if ( !m_bmpCheckBitmaps[i].Ok() )
2264         {
2265             m_bmpCheckBitmaps[i] = wxBitmap(xpmChecked[i]);
2266         }
2267
2268         bmp = m_bmpCheckBitmaps[i];
2269     }
2270
2271     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
2272                   TRUE /* use mask */);
2273
2274     wxRect rectLabel = rect;
2275     int bmpWidth = bmp.GetWidth();
2276     rectLabel.x += bmpWidth;
2277     rectLabel.width -= bmpWidth;
2278
2279     DrawItem(dc, label, rectLabel, flags);
2280 }
2281
2282 // ----------------------------------------------------------------------------
2283 // check/radio buttons
2284 // ----------------------------------------------------------------------------
2285
2286 wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
2287 {
2288     IndicatorState indState;
2289     if ( flags & wxCONTROL_SELECTED )
2290         indState = flags & wxCONTROL_DISABLED ? IndicatorState_SelectedDisabled
2291                                               : IndicatorState_Selected;
2292     else if ( flags & wxCONTROL_DISABLED )
2293         indState = IndicatorState_Disabled;
2294     else if ( flags & wxCONTROL_PRESSED )
2295         indState = IndicatorState_Pressed;
2296     else
2297         indState = IndicatorState_Normal;
2298
2299     IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
2300                                     ? IndicatorStatus_Checked
2301                                     : IndicatorStatus_Unchecked;
2302
2303     wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
2304     if ( !bmp.Ok() )
2305     {
2306         const char **xpm = xpmIndicators[indType][indState][indStatus];
2307         if ( xpm )
2308         {
2309             // create and cache it
2310             bmp = wxBitmap(xpm);
2311             m_bmpIndicators[indType][indState][indStatus] = bmp;
2312         }
2313     }
2314
2315     return bmp;
2316 }
2317
2318 void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
2319                                              const wxString& label,
2320                                              const wxBitmap& bitmap,
2321                                              const wxRect& rect,
2322                                              int flags,
2323                                              wxAlignment align,
2324                                              int indexAccel,
2325                                              wxCoord focusOffsetY)
2326 {
2327     // calculate the position of the bitmap and of the label
2328     wxCoord heightBmp = bitmap.GetHeight();
2329     wxCoord xBmp,
2330             yBmp = rect.y + (rect.height - heightBmp) / 2;
2331
2332     wxRect rectLabel;
2333     dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
2334     rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
2335
2336     // align label vertically with the bitmap - looks nicer like this
2337     rectLabel.y -= (rectLabel.height - heightBmp) % 2;
2338
2339     // calc horz position
2340     if ( align == wxALIGN_RIGHT )
2341     {
2342         xBmp = rect.GetRight() - bitmap.GetWidth();
2343         rectLabel.x = rect.x + 3;
2344         rectLabel.SetRight(xBmp);
2345     }
2346     else // normal (checkbox to the left of the text) case
2347     {
2348         xBmp = rect.x;
2349         rectLabel.x = xBmp + bitmap.GetWidth() + 5;
2350         rectLabel.SetRight(rect.GetRight());
2351     }
2352
2353     dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
2354
2355     DoDrawLabel(
2356                 dc, label, rectLabel,
2357                 flags,
2358                 wxALIGN_LEFT | wxALIGN_TOP,
2359                 indexAccel,
2360                 NULL,         // we don't need bounding rect
2361                 // use custom vert focus rect offset
2362                 wxPoint(FOCUS_RECT_OFFSET_X, focusOffsetY)
2363                );
2364 }
2365
2366 void wxWin32Renderer::DrawRadioButton(wxDC& dc,
2367                                       const wxString& label,
2368                                       const wxBitmap& bitmap,
2369                                       const wxRect& rect,
2370                                       int flags,
2371                                       wxAlignment align,
2372                                       int indexAccel)
2373 {
2374     wxBitmap bmp;
2375     if ( bitmap.Ok() )
2376         bmp = bitmap;
2377     else
2378         bmp = GetRadioBitmap(flags);
2379
2380     DrawCheckOrRadioButton(dc, label,
2381                            bmp,
2382                            rect, flags, align, indexAccel,
2383                            FOCUS_RECT_OFFSET_Y); // default focus rect offset
2384 }
2385
2386 void wxWin32Renderer::DrawCheckButton(wxDC& dc,
2387                                       const wxString& label,
2388                                       const wxBitmap& bitmap,
2389                                       const wxRect& rect,
2390                                       int flags,
2391                                       wxAlignment align,
2392                                       int indexAccel)
2393 {
2394     wxBitmap bmp;
2395     if ( bitmap.Ok() )
2396         bmp = bitmap;
2397     else
2398         bmp = GetCheckBitmap(flags);
2399
2400     DrawCheckOrRadioButton(dc, label,
2401                            bmp,
2402                            rect, flags, align, indexAccel,
2403                            0); // no focus rect offset for checkboxes
2404 }
2405
2406 void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
2407                                         const wxString& label,
2408                                         const wxBitmap& bitmap,
2409                                         const wxRect& rectOrig,
2410                                         int flags)
2411 {
2412     if ( !label.empty() || bitmap.Ok() )
2413     {
2414         wxRect rect = rectOrig;
2415         rect.Deflate(BORDER_THICKNESS);
2416
2417         if ( flags & wxCONTROL_PRESSED )
2418         {
2419             DrawBorder(dc, wxBORDER_SUNKEN, rect, flags);
2420         }
2421         else if ( flags & wxCONTROL_CURRENT )
2422         {
2423             DrawBorder(dc, wxBORDER_RAISED, rect, flags);
2424         }
2425
2426         dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
2427     }
2428     else // a separator
2429     {
2430         // leave a small gap aroudn the line, also account for the toolbar
2431         // border itself
2432         DrawVerticalLine(dc, rectOrig.x + rectOrig.width/2,
2433                          rectOrig.y + 2*BORDER_THICKNESS,
2434                          rectOrig.GetBottom() - BORDER_THICKNESS);
2435     }
2436 }
2437
2438 // ----------------------------------------------------------------------------
2439 // text control
2440 // ----------------------------------------------------------------------------
2441
2442 void wxWin32Renderer::DrawTextLine(wxDC& dc,
2443                                    const wxString& text,
2444                                    const wxRect& rect,
2445                                    int selStart,
2446                                    int selEnd,
2447                                    int flags)
2448 {
2449     // nothing special to do here
2450     StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
2451 }
2452
2453 void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
2454 {
2455     // we don't draw them
2456 }
2457
2458 // ----------------------------------------------------------------------------
2459 // notebook
2460 // ----------------------------------------------------------------------------
2461
2462 void wxWin32Renderer::DrawTab(wxDC& dc,
2463                               const wxRect& rectOrig,
2464                               wxDirection dir,
2465                               const wxString& label,
2466                               const wxBitmap& bitmap,
2467                               int flags,
2468                               int indexAccel)
2469 {
2470     wxRect rect = rectOrig;
2471
2472     // the current tab is drawn indented (to the top for default case) and
2473     // bigger than the other ones
2474     const wxSize indent = GetTabIndent();
2475     if ( flags & wxCONTROL_SELECTED )
2476     {
2477         switch ( dir )
2478         {
2479             default:
2480                 wxFAIL_MSG(_T("invaild notebook tab orientation"));
2481                 // fall through
2482
2483             case wxTOP:
2484                 rect.Inflate(indent.x, 0);
2485                 rect.y -= indent.y;
2486                 rect.height += indent.y;
2487                 break;
2488
2489             case wxBOTTOM:
2490                 rect.Inflate(indent.x, 0);
2491                 rect.height += indent.y;
2492                 break;
2493
2494             case wxLEFT:
2495             case wxRIGHT:
2496                 wxFAIL_MSG(_T("TODO"));
2497                 break;
2498         }
2499     }
2500
2501     // draw the text, image and the focus around them (if necessary)
2502     wxRect rectLabel = rect;
2503     rectLabel.Deflate(1, 1);
2504     DrawButtonLabel(dc, label, bitmap, rectLabel,
2505                     flags, wxALIGN_CENTRE, indexAccel);
2506
2507     // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
2508     static const wxCoord CUTOFF = 2; // radius of the rounded corner
2509     wxCoord x = rect.x,
2510             y = rect.y,
2511             x2 = rect.GetRight(),
2512             y2 = rect.GetBottom();
2513
2514     // FIXME: all this code will break if the tab indent or the border width,
2515     //        it is tied to the fact that both of them are equal to 2
2516     switch ( dir )
2517     {
2518         default:
2519         case wxTOP:
2520             dc.SetPen(m_penHighlight);
2521             dc.DrawLine(x, y2, x, y + CUTOFF);
2522             dc.DrawLine(x, y + CUTOFF, x + CUTOFF, y);
2523             dc.DrawLine(x + CUTOFF, y, x2 - CUTOFF + 1, y);
2524
2525             dc.SetPen(m_penBlack);
2526             dc.DrawLine(x2, y2, x2, y + CUTOFF);
2527             dc.DrawLine(x2, y + CUTOFF, x2 - CUTOFF, y);
2528
2529             dc.SetPen(m_penDarkGrey);
2530             dc.DrawLine(x2 - 1, y2, x2 - 1, y + CUTOFF - 1);
2531
2532             if ( flags & wxCONTROL_SELECTED )
2533             {
2534                 dc.SetPen(m_penLightGrey);
2535
2536                 // overwrite the part of the border below this tab
2537                 dc.DrawLine(x + 1, y2 + 1, x2 - 1, y2 + 1);
2538
2539                 // and the shadow of the tab to the left of us
2540                 dc.DrawLine(x + 1, y + CUTOFF + 1, x + 1, y2 + 1);
2541             }
2542             break;
2543
2544         case wxBOTTOM:
2545             dc.SetPen(m_penHighlight);
2546             // we need to continue one pixel further to overwrite the corner of
2547             // the border for the selected tab
2548             dc.DrawLine(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0),
2549                         x, y2 - CUTOFF);
2550             dc.DrawLine(x, y2 - CUTOFF, x + CUTOFF, y2);
2551
2552             dc.SetPen(m_penBlack);
2553             dc.DrawLine(x + CUTOFF, y2, x2 - CUTOFF + 1, y2);
2554             dc.DrawLine(x2, y, x2, y2 - CUTOFF);
2555             dc.DrawLine(x2, y2 - CUTOFF, x2 - CUTOFF, y2);
2556
2557             dc.SetPen(m_penDarkGrey);
2558             dc.DrawLine(x + CUTOFF, y2 - 1, x2 - CUTOFF + 1, y2 - 1);
2559             dc.DrawLine(x2 - 1, y, x2 - 1, y2 - CUTOFF + 1);
2560
2561             if ( flags & wxCONTROL_SELECTED )
2562             {
2563                 dc.SetPen(m_penLightGrey);
2564
2565                 // overwrite the part of the (double!) border above this tab
2566                 dc.DrawLine(x + 1, y - 1, x2 - 1, y - 1);
2567                 dc.DrawLine(x + 1, y - 2, x2 - 1, y - 2);
2568
2569                 // and the shadow of the tab to the left of us
2570                 dc.DrawLine(x + 1, y2 - CUTOFF, x + 1, y - 1);
2571             }
2572             break;
2573
2574         case wxLEFT:
2575         case wxRIGHT:
2576             wxFAIL_MSG(_T("TODO"));
2577     }
2578 }
2579
2580 // ----------------------------------------------------------------------------
2581 // slider
2582 // ----------------------------------------------------------------------------
2583
2584 wxSize wxWin32Renderer::GetSliderThumbSize(const wxRect& rect,
2585                                            int lenThumb,
2586                                            wxOrientation orient) const
2587 {
2588     wxSize size;
2589     wxCoord width  = wxMax (lenThumb, SLIDER_THUMB_LENGTH) / 2;
2590     wxCoord height = wxMax (lenThumb, SLIDER_THUMB_LENGTH);
2591
2592     if (orient == wxHORIZONTAL)
2593     {
2594         size.x = width;
2595         size.y = height;
2596     }
2597     else
2598     { // == wxVERTICAL
2599         size.x = height;
2600         size.y = width;
2601     }
2602
2603     return size;
2604 }
2605
2606 wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
2607                                            int lenThumb,
2608                                            wxOrientation orient,
2609                                            long style) const
2610 {
2611     bool transpose = (orient == wxVERTICAL);
2612     bool left  = ((style & wxSL_AUTOTICKS) != 0) &
2613                  (((style & wxSL_TOP) != 0) & !transpose |
2614                   ((style & wxSL_LEFT) != 0) & transpose |
2615                   ((style & wxSL_BOTH) != 0));
2616     bool right = ((style & wxSL_AUTOTICKS) != 0) &
2617                  (((style & wxSL_BOTTOM) != 0) & !transpose |
2618                   ((style & wxSL_RIGHT) != 0) & transpose |
2619                   ((style & wxSL_BOTH) != 0));
2620
2621     wxRect rect = rectOrig;
2622
2623     wxSize sizeThumb = GetSliderThumbSize (rect, lenThumb, orient);
2624
2625     if (orient == wxHORIZONTAL) {
2626         rect.x += SLIDER_MARGIN;
2627         if (left & right)
2628         {
2629             rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS) / 2, sizeThumb.y/2);
2630         }
2631         else if (left)
2632         {
2633             rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS - sizeThumb.y/2), sizeThumb.y/2);
2634         }
2635         else
2636         {
2637             rect.y += sizeThumb.y/2;
2638         }
2639         rect.width -= 2*SLIDER_MARGIN;
2640         rect.height = 2*BORDER_THICKNESS;
2641     }
2642     else
2643     { // == wxVERTICAL
2644         rect.y += SLIDER_MARGIN;
2645         if (left & right)
2646         {
2647             rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS) / 2, sizeThumb.x/2);
2648         }
2649         else if (left)
2650         {
2651             rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS - sizeThumb.x/2), sizeThumb.x/2);
2652         }
2653         else
2654         {
2655             rect.x += sizeThumb.x/2;
2656         }
2657         rect.width = 2*BORDER_THICKNESS;
2658         rect.height -= 2*SLIDER_MARGIN;
2659     }
2660
2661     return rect;
2662 }
2663
2664 void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
2665                                       const wxRect& rectOrig,
2666                                       int lenThumb,
2667                                       wxOrientation orient,
2668                                       int flags,
2669                                       long style,
2670                                       wxRect *rectShaft)
2671 {
2672     /*    show shaft geometry
2673
2674              shaft
2675         +-------------+
2676         |             |
2677         |     XXX     |  <-- x1
2678         |     XXX     |
2679         |     XXX     |
2680         |     XXX     |
2681         |     XXX     |  <-- x2
2682         |             |
2683         +-------------+
2684
2685               ^ ^
2686               | |
2687              y1 y2
2688     */
2689
2690     if (flags & wxCONTROL_FOCUSED) {
2691         DrawFocusRect(dc, rectOrig);
2692     }
2693
2694     wxRect rect = GetSliderShaftRect(rectOrig, lenThumb, orient, style);
2695
2696     if (rectShaft) *rectShaft = rect;
2697
2698     DrawSunkenBorder(dc, &rect);
2699 }
2700
2701 void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
2702                                       const wxRect& rect,
2703                                       wxOrientation orient,
2704                                       int flags,
2705                                       long style)
2706 {
2707     /*    show thumb geometry
2708
2709              H       <--- y1
2710            H H B
2711          H     H B
2712        H         H B <--- y3
2713        H         D B
2714        H         D B
2715        H         D B
2716        H         D B   where H is hightlight colour
2717        H         D B         D    dark grey
2718        H         D B         B    black
2719        H         D B
2720        H         D B
2721        H         D B <--- y4
2722          H     D B
2723            H D B
2724              B       <--- y2
2725
2726        ^     ^     ^
2727        |     |     |
2728        x1    x3    x2
2729
2730        The interior of this shape is filled with the hatched brush if the thumb
2731        is pressed.
2732     */
2733
2734     DrawBackground(dc, wxNullColour, rect, flags);
2735
2736     bool transpose = (orient == wxVERTICAL);
2737     bool left  = ((style & wxSL_AUTOTICKS) != 0) &
2738                  (((style & wxSL_TOP) != 0) & !transpose |
2739                   ((style & wxSL_LEFT) != 0) & transpose) &
2740                  ((style & wxSL_BOTH) == 0);
2741     bool right = ((style & wxSL_AUTOTICKS) != 0) &
2742                  (((style & wxSL_BOTTOM) != 0) & !transpose |
2743                   ((style & wxSL_RIGHT) != 0) & transpose) &
2744                  ((style & wxSL_BOTH) == 0);
2745
2746     wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
2747     wxCoord c = ((transpose ? rect.height : rect.width) - 2*sizeArrow);
2748
2749     wxCoord x1, x2, x3, y1, y2, y3, y4;
2750     x1 = (transpose ? rect.y : rect.x);
2751     x2 = (transpose ? rect.GetBottom() : rect.GetRight());
2752     x3 = (x1-1+c) + sizeArrow;
2753     y1 = (transpose ? rect.x : rect.y);
2754     y2 = (transpose ? rect.GetRight() : rect.GetBottom());
2755     y3 = (left  ? (y1-1+c) + sizeArrow : y1);
2756     y4 = (right ? (y2+1-c) - sizeArrow : y2);
2757
2758     dc.SetPen(m_penBlack);
2759     if (left) {
2760         DrawLine(dc, x3+1-c, y1, x2, y3, transpose);
2761     }
2762     DrawLine(dc, x2, y3, x2, y4, transpose);
2763     if (right)
2764     {
2765         DrawLine(dc, x3+1-c, y2, x2, y4, transpose);
2766     }
2767     else
2768     {
2769         DrawLine(dc, x1, y2, x2, y2, transpose);
2770     }
2771
2772     dc.SetPen(m_penDarkGrey);
2773     DrawLine(dc, x2-1, y3+1, x2-1, y4-1, transpose);
2774     if (right) {
2775         DrawLine(dc, x3+1-c, y2-1, x2-1, y4, transpose);
2776     }
2777     else
2778     {
2779         DrawLine(dc, x1+1, y2-1, x2-1, y2-1, transpose);
2780     }
2781
2782     dc.SetPen(m_penHighlight);
2783     if (left)
2784     {
2785         DrawLine(dc, x1, y3, x3, y1, transpose);
2786         DrawLine(dc, x3+1-c, y1+1, x2-1, y3, transpose);
2787     }
2788     else
2789     {
2790         DrawLine(dc, x1, y1, x2, y1, transpose);
2791     }
2792     DrawLine(dc, x1, y3, x1, y4, transpose);
2793     if (right)
2794     {
2795         DrawLine(dc, x1, y4, x3+c, y2+c, transpose);
2796     }
2797
2798     if (flags & wxCONTROL_PRESSED) {
2799         // TODO: MSW fills the entire area inside, not just the rect
2800         wxRect rectInt = rect;
2801         if ( transpose )
2802         {
2803             rectInt.SetLeft(y3);
2804             rectInt.SetRight(y4);
2805         }
2806         else
2807         {
2808             rectInt.SetTop(y3);
2809             rectInt.SetBottom(y4);
2810         }
2811         rectInt.Deflate(2);
2812
2813 #if !defined(__WXMGL__)
2814         static const char *stipple_xpm[] = {
2815             /* columns rows colors chars-per-pixel */
2816             "2 2 2 1",
2817             "  c None",
2818             "w c white",
2819             /* pixels */
2820             "w ",
2821             " w",
2822         };
2823 #else
2824         // VS: MGL can only do 8x8 stipple brushes
2825         static const char *stipple_xpm[] = {
2826             /* columns rows colors chars-per-pixel */
2827             "8 8 2 1",
2828             "  c None",
2829             "w c white",
2830             /* pixels */
2831             "w w w w ",
2832             " w w w w",
2833             "w w w w ",
2834             " w w w w",
2835             "w w w w ",
2836             " w w w w",
2837             "w w w w ",
2838             " w w w w",
2839         };
2840 #endif
2841         dc.SetBrush(wxBrush(stipple_xpm));
2842
2843         dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
2844         dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, CONTROL));
2845         dc.SetPen(*wxTRANSPARENT_PEN);
2846         dc.DrawRectangle(rectInt);
2847     }
2848 }
2849
2850 void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
2851                                       const wxRect& rect,
2852                                       int lenThumb,
2853                                       wxOrientation orient,
2854                                       int start,
2855                                       int end,
2856                                       int step,
2857                                       int flags,
2858                                       long style)
2859 {
2860     /*    show ticks geometry
2861
2862         left        right
2863         ticks shaft ticks
2864         ----   XX   ----  <-- x1
2865         ----   XX   ----
2866         ----   XX   ----
2867         ----   XX   ----  <-- x2
2868
2869         ^  ^        ^  ^
2870         |  |        |  |
2871         y3 y1       y2 y4
2872     */
2873
2874     // empty slider?
2875     if (end == start) return;
2876
2877     bool transpose = (orient == wxVERTICAL);
2878     bool left  = ((style & wxSL_AUTOTICKS) != 0) &
2879                  (((style & wxSL_TOP) != 0) & !transpose |
2880                   ((style & wxSL_LEFT) != 0) & transpose |
2881                   ((style & wxSL_BOTH) != 0));
2882     bool right = ((style & wxSL_AUTOTICKS) != 0) &
2883                  (((style & wxSL_BOTTOM) != 0) & !transpose |
2884                   ((style & wxSL_RIGHT) != 0) & transpose |
2885                   ((style & wxSL_BOTH) != 0));
2886
2887     // default thumb size
2888     wxSize sizeThumb = GetSliderThumbSize (rect, 0, orient);
2889     wxCoord defaultLen = (transpose ? sizeThumb.x : sizeThumb.y);
2890
2891     // normal thumb size
2892     sizeThumb = GetSliderThumbSize (rect, lenThumb, orient);
2893     wxCoord widthThumb  = (transpose ? sizeThumb.y : sizeThumb.x);
2894
2895     wxRect rectShaft = GetSliderShaftRect (rect, lenThumb, orient, style);
2896
2897     wxCoord x1, x2, y1, y2, y3, y4 , len;
2898     x1 = (transpose ? rectShaft.y : rectShaft.x) + widthThumb/2;
2899     x2 = (transpose ? rectShaft.GetBottom() : rectShaft.GetRight()) - widthThumb/2;
2900     y1 = (transpose ? rectShaft.x : rectShaft.y) - defaultLen/2;
2901     y2 = (transpose ? rectShaft.GetRight() : rectShaft.GetBottom()) + defaultLen/2;
2902     y3 = (transpose ? rect.x : rect.y);
2903     y4 = (transpose ? rect.GetRight() : rect.GetBottom());
2904     len = x2 - x1;
2905
2906     dc.SetPen(m_penBlack);
2907
2908     int range = end - start;
2909     for ( int n = 0; n < range; n += step ) {
2910         wxCoord x = x1 + (len*n) / range;
2911
2912         if (left & (y1 > y3)) {
2913             DrawLine(dc, x, y1, x, y3, orient == wxVERTICAL);
2914         }
2915         if (right & (y4 > y2)) {
2916             DrawLine(dc, x, y2, x, y4, orient == wxVERTICAL);
2917         }
2918     }
2919     // always draw the line at the end position
2920     if (left & (y1 > y3)) {
2921         DrawLine(dc, x2, y1, x2, y3, orient == wxVERTICAL);
2922     }
2923     if (right & (y4 > y2)) {
2924         DrawLine(dc, x2, y2, x2, y4, orient == wxVERTICAL);
2925     }
2926 }
2927
2928 // ----------------------------------------------------------------------------
2929 // menu and menubar
2930 // ----------------------------------------------------------------------------
2931
2932 // wxWin32MenuGeometryInfo: the wxMenuGeometryInfo used by wxWin32Renderer
2933 class WXDLLEXPORT wxWin32MenuGeometryInfo : public wxMenuGeometryInfo
2934 {
2935 public:
2936     virtual wxSize GetSize() const { return m_size; }
2937
2938     wxCoord GetLabelOffset() const { return m_ofsLabel; }
2939     wxCoord GetAccelOffset() const { return m_ofsAccel; }
2940
2941     wxCoord GetItemHeight() const { return m_heightItem; }
2942
2943 private:
2944     // the total size of the menu
2945     wxSize m_size;
2946
2947     // the offset of the start of the menu item label
2948     wxCoord m_ofsLabel;
2949
2950     // the offset of the start of the accel label
2951     wxCoord m_ofsAccel;
2952
2953     // the height of a normal (not separator) item
2954     wxCoord m_heightItem;
2955
2956     friend wxMenuGeometryInfo *
2957         wxWin32Renderer::GetMenuGeometry(wxWindow *, const wxMenu&) const;
2958 };
2959
2960 // FIXME: all constants are hardcoded but shouldn't be
2961 static const wxCoord MENU_LEFT_MARGIN = 9;
2962 static const wxCoord MENU_RIGHT_MARGIN = 18;
2963 static const wxCoord MENU_VERT_MARGIN = 3;
2964
2965 // the margin around bitmap/check marks (on each side)
2966 static const wxCoord MENU_BMP_MARGIN = 2;
2967
2968 // the margin between the labels and accel strings
2969 static const wxCoord MENU_ACCEL_MARGIN = 8;
2970
2971 // the separator height in pixels: in fact, strangely enough, the real height
2972 // is 2 but Windows adds one extra pixel in the bottom margin, so take it into
2973 // account here
2974 static const wxCoord MENU_SEPARATOR_HEIGHT = 3;
2975
2976 // the size of the standard checkmark bitmap
2977 static const wxCoord MENU_CHECK_SIZE = 9;
2978
2979 void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
2980                                       const wxRect& rectOrig,
2981                                       const wxString& label,
2982                                       int flags,
2983                                       int indexAccel)
2984 {
2985     wxRect rect = rectOrig;
2986     rect.height--;
2987
2988     wxDCTextColourChanger colChanger(dc);
2989
2990     if ( flags & wxCONTROL_SELECTED )
2991     {
2992         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2993
2994         wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2995         dc.SetBrush(wxBrush(colBg, wxSOLID));
2996         dc.SetPen(wxPen(colBg, 0, wxSOLID));
2997         dc.DrawRectangle(rect);
2998     }
2999
3000     // don't draw the focus rect around menu bar items
3001     DrawLabel(dc, label, rect, flags & ~wxCONTROL_FOCUSED,
3002               wxALIGN_CENTRE, indexAccel);
3003 }
3004
3005 void wxWin32Renderer::DrawMenuItem(wxDC& dc,
3006                                    wxCoord y,
3007                                    const wxMenuGeometryInfo& gi,
3008                                    const wxString& label,
3009                                    const wxString& accel,
3010                                    const wxBitmap& bitmap,
3011                                    int flags,
3012                                    int indexAccel)
3013 {
3014     const wxWin32MenuGeometryInfo& geometryInfo =
3015         (const wxWin32MenuGeometryInfo&)gi;
3016
3017     wxRect rect;
3018     rect.x = 0;
3019     rect.y = y;
3020     rect.width = geometryInfo.GetSize().x;
3021     rect.height = geometryInfo.GetItemHeight();
3022
3023     // draw the selected item specially
3024     wxDCTextColourChanger colChanger(dc);
3025     if ( flags & wxCONTROL_SELECTED )
3026     {
3027         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
3028
3029         wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
3030         dc.SetBrush(wxBrush(colBg, wxSOLID));
3031         dc.SetPen(wxPen(colBg, 0, wxSOLID));
3032         dc.DrawRectangle(rect);
3033     }
3034
3035     // draw the bitmap: use the bitmap provided or the standard checkmark for
3036     // the checkable items
3037     wxBitmap bmp = bitmap;
3038     if ( !bmp.Ok() && (flags & wxCONTROL_CHECKED) )
3039     {
3040         bmp = GetIndicator(IndicatorType_Menu, flags);
3041     }
3042
3043     if ( bmp.Ok() )
3044     {
3045         rect.SetRight(geometryInfo.GetLabelOffset());
3046         wxControlRenderer::DrawBitmap(dc, bmp, rect);
3047     }
3048
3049     // draw the label
3050     rect.x = geometryInfo.GetLabelOffset();
3051     rect.SetRight(geometryInfo.GetAccelOffset());
3052
3053     DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE_VERTICAL, indexAccel);
3054
3055     // draw the accel string
3056     rect.x = geometryInfo.GetAccelOffset();
3057     rect.SetRight(geometryInfo.GetSize().x);
3058
3059     // NB: no accel index here
3060     DrawLabel(dc, accel, rect, flags, wxALIGN_CENTRE_VERTICAL);
3061
3062     // draw the submenu indicator
3063     if ( flags & wxCONTROL_ISSUBMENU )
3064     {
3065         rect.x = geometryInfo.GetSize().x - MENU_RIGHT_MARGIN;
3066         rect.width = MENU_RIGHT_MARGIN;
3067
3068         wxArrowStyle arrowStyle;
3069         if ( flags & wxCONTROL_DISABLED )
3070             arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InversedDisabled
3071                                                     : Arrow_Disabled;
3072         else if ( flags & wxCONTROL_SELECTED )
3073             arrowStyle = Arrow_Inversed;
3074         else
3075             arrowStyle = Arrow_Normal;
3076
3077         DrawArrow(dc, rect, Arrow_Right, arrowStyle);
3078     }
3079 }
3080
3081 void wxWin32Renderer::DrawMenuSeparator(wxDC& dc,
3082                                         wxCoord y,
3083                                         const wxMenuGeometryInfo& geomInfo)
3084 {
3085     DrawHorizontalLine(dc, y + MENU_VERT_MARGIN, 0, geomInfo.GetSize().x);
3086 }
3087
3088 wxSize wxWin32Renderer::GetMenuBarItemSize(const wxSize& sizeText) const
3089 {
3090     wxSize size = sizeText;
3091
3092     // FIXME: menubar height is configurable under Windows
3093     size.x += 12;
3094     size.y += 6;
3095
3096     return size;
3097 }
3098
3099 wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
3100                                                      const wxMenu& menu) const
3101 {
3102     // prepare the dc: for now we draw all the items with the system font
3103     wxClientDC dc(win);
3104     dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
3105
3106     // the height of a normal item
3107     wxCoord heightText = dc.GetCharHeight();
3108
3109     // the total height
3110     wxCoord height = 0;
3111
3112     // the max length of label and accel strings: the menu width is the sum of
3113     // them, even if they're for different items (as the accels should be
3114     // aligned)
3115     //
3116     // the max length of the bitmap is never 0 as Windows always leaves enough
3117     // space for a check mark indicator
3118     wxCoord widthLabelMax = 0,
3119             widthAccelMax = 0,
3120             widthBmpMax = MENU_LEFT_MARGIN;
3121
3122     for ( wxMenuItemList::Node *node = menu.GetMenuItems().GetFirst();
3123           node;
3124           node = node->GetNext() )
3125     {
3126         // height of this item
3127         wxCoord h;
3128
3129         wxMenuItem *item = node->GetData();
3130         if ( item->IsSeparator() )
3131         {
3132             h = MENU_SEPARATOR_HEIGHT;
3133         }
3134         else // not separator
3135         {
3136             h = heightText;
3137
3138             wxCoord widthLabel;
3139             dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
3140             if ( widthLabel > widthLabelMax )
3141             {
3142                 widthLabelMax = widthLabel;
3143             }
3144
3145             wxCoord widthAccel;
3146             dc.GetTextExtent(item->GetAccelString(), &widthAccel, NULL);
3147             if ( widthAccel > widthAccelMax )
3148             {
3149                 widthAccelMax = widthAccel;
3150             }
3151
3152             const wxBitmap& bmp = item->GetBitmap();
3153             if ( bmp.Ok() )
3154             {
3155                 wxCoord widthBmp = bmp.GetWidth();
3156                 if ( widthBmp > widthBmpMax )
3157                     widthBmpMax = widthBmp;
3158             }
3159             //else if ( item->IsCheckable() ): no need to check for this as
3160             // MENU_LEFT_MARGIN is big enough to show the check mark
3161         }
3162
3163         h += 2*MENU_VERT_MARGIN;
3164
3165         // remember the item position and height
3166         item->SetGeometry(height, h);
3167
3168         height += h;
3169     }
3170
3171     // bundle the metrics into a struct and return it
3172     wxWin32MenuGeometryInfo *gi = new wxWin32MenuGeometryInfo;
3173
3174     gi->m_ofsLabel = widthBmpMax + 2*MENU_BMP_MARGIN;
3175     gi->m_ofsAccel = gi->m_ofsLabel + widthLabelMax;
3176     if ( widthAccelMax > 0 )
3177     {
3178         // if we actually have any accesl, add a margin
3179         gi->m_ofsAccel += MENU_ACCEL_MARGIN;
3180     }
3181
3182     gi->m_heightItem = heightText + 2*MENU_VERT_MARGIN;
3183
3184     gi->m_size.x = gi->m_ofsAccel + widthAccelMax + MENU_RIGHT_MARGIN;
3185     gi->m_size.y = height;
3186
3187     return gi;
3188 }
3189
3190 // ----------------------------------------------------------------------------
3191 // status bar
3192 // ----------------------------------------------------------------------------
3193
3194 static const wxCoord STATBAR_BORDER_X = 2;
3195 static const wxCoord STATBAR_BORDER_Y = 2;
3196
3197 wxSize wxWin32Renderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
3198 {
3199     if ( borderBetweenFields )
3200         *borderBetweenFields = 2;
3201
3202     return wxSize(STATBAR_BORDER_X, STATBAR_BORDER_Y);
3203 }
3204
3205 void wxWin32Renderer::DrawStatusField(wxDC& dc,
3206                                       const wxRect& rect,
3207                                       const wxString& label,
3208                                       int flags)
3209 {
3210     wxRect rectIn;
3211
3212     if ( flags & wxCONTROL_ISDEFAULT )
3213     {
3214         // draw the size grip: it is a normal rect except that in the lower
3215         // right corner we have several bands which may be used for dragging
3216         // the status bar corner
3217         //
3218         // each band consists of 4 stripes: m_penHighlight, double
3219         // m_penDarkGrey and transparent one
3220         wxCoord x2 = rect.GetRight(),
3221                 y2 = rect.GetBottom();
3222
3223         // draw the upper left part of the rect normally
3224         dc.SetPen(m_penDarkGrey);
3225         dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
3226         dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
3227
3228         // draw the grey stripes of the grip
3229         size_t n;
3230         wxCoord ofs = WIDTH_STATUSBAR_GRIP_BAND - 1;
3231         for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
3232         {
3233             dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
3234             dc.DrawLine(x2 - ofs, y2 - 1, x2, y2 - ofs - 1);
3235         }
3236
3237         // draw the white stripes
3238         dc.SetPen(m_penHighlight);
3239         ofs = WIDTH_STATUSBAR_GRIP_BAND + 1;
3240         for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
3241         {
3242             dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
3243         }
3244
3245         // draw the remaining rect boundaries
3246         ofs -= WIDTH_STATUSBAR_GRIP_BAND;
3247         dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
3248         dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
3249
3250         rectIn = rect;
3251         rectIn.Deflate(1);
3252
3253         rectIn.width -= STATUSBAR_GRIP_SIZE;
3254     }
3255     else // normal pane
3256     {
3257         DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
3258     }
3259
3260     rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
3261
3262     wxDCClipper clipper(dc, rectIn);
3263     DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
3264 }
3265
3266 // ----------------------------------------------------------------------------
3267 // combobox
3268 // ----------------------------------------------------------------------------
3269
3270 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
3271                                       wxBitmap *bmpFocus,
3272                                       wxBitmap *bmpPressed,
3273                                       wxBitmap *bmpDisabled)
3274 {
3275     static const wxCoord widthCombo = 16;
3276     static const wxCoord heightCombo = 17;
3277
3278     wxMemoryDC dcMem;
3279
3280     if ( bmpNormal )
3281     {
3282         bmpNormal->Create(widthCombo, heightCombo);
3283         dcMem.SelectObject(*bmpNormal);
3284         DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
3285                         Arrow_Down, Arrow_Normal);
3286     }
3287
3288     if ( bmpPressed )
3289     {
3290         bmpPressed->Create(widthCombo, heightCombo);
3291         dcMem.SelectObject(*bmpPressed);
3292         DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
3293                         Arrow_Down, Arrow_Pressed);
3294     }
3295
3296     if ( bmpDisabled )
3297     {
3298         bmpDisabled->Create(widthCombo, heightCombo);
3299         dcMem.SelectObject(*bmpDisabled);
3300         DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
3301                         Arrow_Down, Arrow_Disabled);
3302     }
3303 }
3304
3305 // ----------------------------------------------------------------------------
3306 // background
3307 // ----------------------------------------------------------------------------
3308
3309 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
3310                                        const wxColour& col,
3311                                        const wxRect& rect,
3312                                        wxWindow *window )
3313 {
3314     wxBrush brush(col, wxSOLID);
3315     dc.SetBrush(brush);
3316     dc.SetPen(*wxTRANSPARENT_PEN);
3317     dc.DrawRectangle(rect);
3318 }
3319
3320 void wxWin32Renderer::DrawBackground(wxDC& dc,
3321                                      const wxColour& col,
3322                                      const wxRect& rect,
3323                                      int flags,
3324                                      wxWindow *window )
3325 {
3326     // just fill it with the given or default bg colour
3327     wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
3328     DoDrawBackground(dc, colBg, rect, window );
3329 }
3330
3331 // ----------------------------------------------------------------------------
3332 // scrollbar
3333 // ----------------------------------------------------------------------------
3334
3335 void wxWin32Renderer::DrawArrow(wxDC& dc,
3336                                 wxDirection dir,
3337                                 const wxRect& rect,
3338                                 int flags)
3339 {
3340     // get the bitmap for this arrow
3341     wxArrowDirection arrowDir;
3342     switch ( dir )
3343     {
3344         case wxLEFT:    arrowDir = Arrow_Left; break;
3345         case wxRIGHT:   arrowDir = Arrow_Right; break;
3346         case wxUP:      arrowDir = Arrow_Up; break;
3347         case wxDOWN:    arrowDir = Arrow_Down; break;
3348
3349         default:
3350             wxFAIL_MSG(_T("unknown arrow direction"));
3351             return;
3352     }
3353
3354     wxArrowStyle arrowStyle;
3355     if ( flags & wxCONTROL_PRESSED )
3356     {
3357         // can't be pressed and disabled
3358         arrowStyle = Arrow_Pressed;
3359     }
3360     else
3361     {
3362         arrowStyle = flags & wxCONTROL_DISABLED ? Arrow_Disabled : Arrow_Normal;
3363     }
3364
3365     DrawArrowButton(dc, rect, arrowDir, arrowStyle);
3366 }
3367
3368 void wxWin32Renderer::DrawArrow(wxDC& dc,
3369                                 const wxRect& rect,
3370                                 wxArrowDirection arrowDir,
3371                                 wxArrowStyle arrowStyle)
3372 {
3373     const wxBitmap& bmp = m_bmpArrows[arrowStyle][arrowDir];
3374
3375     // under Windows the arrows always have the same size so just centre it in
3376     // the provided rectangle
3377     wxCoord x = rect.x + (rect.width - bmp.GetWidth()) / 2,
3378             y = rect.y + (rect.height - bmp.GetHeight()) / 2;
3379
3380     // Windows does it like this...
3381     if ( arrowDir == Arrow_Left )
3382         x--;
3383
3384     // draw it
3385     dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
3386 }
3387
3388 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
3389                                       const wxRect& rectAll,
3390                                       wxArrowDirection arrowDir,
3391                                       wxArrowStyle arrowStyle)
3392 {
3393     wxRect rect = rectAll;
3394     DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
3395     DrawArrowBorder(dc, &rect, arrowStyle == Arrow_Pressed);
3396     DrawArrow(dc, rect, arrowDir, arrowStyle);
3397 }
3398
3399 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
3400                                          wxOrientation orient,
3401                                          const wxRect& rect,
3402                                          int flags)
3403 {
3404     // we don't use the flags, the thumb never changes appearance
3405     wxRect rectThumb = rect;
3406     DrawArrowBorder(dc, &rectThumb);
3407     DrawBackground(dc, wxNullColour, rectThumb);
3408 }
3409
3410 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
3411                                          wxOrientation orient,
3412                                          const wxRect& rectBar,
3413                                          int flags)
3414 {
3415     wxColourScheme::StdColour col = flags & wxCONTROL_PRESSED
3416                                     ? wxColourScheme::SCROLLBAR_PRESSED
3417                                     : wxColourScheme::SCROLLBAR;
3418     DoDrawBackground(dc, m_scheme->Get(col), rectBar);
3419 }
3420
3421 void wxWin32Renderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
3422 {
3423     DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
3424 }
3425
3426 wxRect wxWin32Renderer::GetScrollbarRect(const wxScrollBar *scrollbar,
3427                                          wxScrollBar::Element elem,
3428                                          int thumbPos) const
3429 {
3430     return StandardGetScrollbarRect(scrollbar, elem,
3431                                     thumbPos, m_sizeScrollbarArrow);
3432 }
3433
3434 wxCoord wxWin32Renderer::GetScrollbarSize(const wxScrollBar *scrollbar)
3435 {
3436     return StandardScrollBarSize(scrollbar, m_sizeScrollbarArrow);
3437 }
3438
3439 wxHitTest wxWin32Renderer::HitTestScrollbar(const wxScrollBar *scrollbar,
3440                                             const wxPoint& pt) const
3441 {
3442     return StandardHitTestScrollbar(scrollbar, pt, m_sizeScrollbarArrow);
3443 }
3444
3445 wxCoord wxWin32Renderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
3446                                           int thumbPos)
3447 {
3448     return StandardScrollbarToPixel(scrollbar, thumbPos, m_sizeScrollbarArrow);
3449 }
3450
3451 int wxWin32Renderer::PixelToScrollbar(const wxScrollBar *scrollbar,
3452                                       wxCoord coord)
3453 {
3454     return StandardPixelToScrollbar(scrollbar, coord, m_sizeScrollbarArrow);
3455 }
3456
3457 // ----------------------------------------------------------------------------
3458 // top level windows
3459 // ----------------------------------------------------------------------------
3460
3461 int wxWin32Renderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
3462 {
3463     wxRect client = GetFrameClientArea(rect, flags);
3464
3465     if ( client.Inside(pt) )
3466         return wxHT_TOPLEVEL_CLIENT_AREA;
3467
3468     if ( flags & wxTOPLEVEL_TITLEBAR )
3469     {
3470         wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3471
3472         if ( flags & wxTOPLEVEL_ICON )
3473         {
3474             if ( wxRect(client.GetPosition(), GetFrameIconSize()).Inside(pt) )
3475                 return wxHT_TOPLEVEL_ICON;
3476         }
3477
3478         wxRect btnRect(client.GetRight() - 2 - FRAME_BUTTON_WIDTH,
3479                        client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2,
3480                        FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
3481
3482         if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
3483         {
3484             if ( btnRect.Inside(pt) )
3485                 return wxHT_TOPLEVEL_BUTTON_CLOSE;
3486             btnRect.x -= FRAME_BUTTON_WIDTH + 2;
3487         }
3488         if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
3489         {
3490             if ( btnRect.Inside(pt) )
3491                 return wxHT_TOPLEVEL_BUTTON_MAXIMIZE;
3492             btnRect.x -= FRAME_BUTTON_WIDTH;
3493         }
3494         if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
3495         {
3496             if ( btnRect.Inside(pt) )
3497                 return wxHT_TOPLEVEL_BUTTON_RESTORE;
3498             btnRect.x -= FRAME_BUTTON_WIDTH;
3499         }
3500         if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
3501         {
3502             if ( btnRect.Inside(pt) )
3503                 return wxHT_TOPLEVEL_BUTTON_ICONIZE;
3504             btnRect.x -= FRAME_BUTTON_WIDTH;
3505         }
3506         if ( flags & wxTOPLEVEL_BUTTON_HELP )
3507         {
3508             if ( btnRect.Inside(pt) )
3509                 return wxHT_TOPLEVEL_BUTTON_HELP;
3510             btnRect.x -= FRAME_BUTTON_WIDTH;
3511         }
3512
3513         if ( pt.y >= client.y && pt.y < client.y + FRAME_TITLEBAR_HEIGHT )
3514             return wxHT_TOPLEVEL_TITLEBAR;
3515     }
3516
3517     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3518     {
3519         // we are certainly at one of borders, lets decide which one:
3520
3521         int border = 0;
3522         // dirty trick, relies on the way wxHT_TOPLEVEL_XXX are defined!
3523         if ( pt.x < client.x )
3524             border |= wxHT_TOPLEVEL_BORDER_W;
3525         else if ( pt.x >= client.width + client.x )
3526             border |= wxHT_TOPLEVEL_BORDER_E;
3527         if ( pt.y < client.y )
3528             border |= wxHT_TOPLEVEL_BORDER_N;
3529         else if ( pt.y >= client.height + client.y )
3530             border |= wxHT_TOPLEVEL_BORDER_S;
3531         return border;
3532     }
3533
3534     return wxHT_NOWHERE;
3535 }
3536
3537 void wxWin32Renderer::DrawFrameTitleBar(wxDC& dc,
3538                                         const wxRect& rect,
3539                                         const wxString& title,
3540                                         const wxIcon& icon,
3541                                         int flags,
3542                                         int specialButton,
3543                                         int specialButtonFlags)
3544 {
3545     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3546     {
3547         DrawFrameBorder(dc, rect, flags);
3548     }
3549     if ( flags & wxTOPLEVEL_TITLEBAR )
3550     {
3551         DrawFrameBackground(dc, rect, flags);
3552         if ( flags & wxTOPLEVEL_ICON )
3553             DrawFrameIcon(dc, rect, icon, flags);
3554         DrawFrameTitle(dc, rect, title, flags);
3555
3556         wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3557         wxCoord x,y;
3558         x = client.GetRight() - 2 - FRAME_BUTTON_WIDTH;
3559         y = client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2;
3560
3561         if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
3562         {
3563             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_CLOSE,
3564                             (specialButton == wxTOPLEVEL_BUTTON_CLOSE) ?
3565                             specialButtonFlags : 0);
3566             x -= FRAME_BUTTON_WIDTH + 2;
3567         }
3568         if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
3569         {
3570             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_MAXIMIZE,
3571                             (specialButton == wxTOPLEVEL_BUTTON_MAXIMIZE) ?
3572                             specialButtonFlags : 0);
3573             x -= FRAME_BUTTON_WIDTH;
3574         }
3575         if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
3576         {
3577             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_RESTORE,
3578                             (specialButton == wxTOPLEVEL_BUTTON_RESTORE) ?
3579                             specialButtonFlags : 0);
3580             x -= FRAME_BUTTON_WIDTH;
3581         }
3582         if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
3583         {
3584             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_ICONIZE,
3585                             (specialButton == wxTOPLEVEL_BUTTON_ICONIZE) ?
3586                             specialButtonFlags : 0);
3587             x -= FRAME_BUTTON_WIDTH;
3588         }
3589         if ( flags & wxTOPLEVEL_BUTTON_HELP )
3590         {
3591             DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
3592                             (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
3593                             specialButtonFlags : 0);
3594             x -= FRAME_BUTTON_WIDTH;
3595         }
3596     }
3597 }
3598
3599 void wxWin32Renderer::DrawFrameBorder(wxDC& dc,
3600                                       const wxRect& rect,
3601                                       int flags)
3602 {
3603     if ( !(flags & wxTOPLEVEL_BORDER) ) return;
3604
3605     wxRect r(rect);
3606
3607     DrawShadedRect(dc, &r, m_penLightGrey, m_penBlack);
3608     DrawShadedRect(dc, &r, m_penHighlight, m_penDarkGrey);
3609     DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
3610     if ( flags & wxTOPLEVEL_RESIZEABLE )
3611         DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
3612 }
3613
3614 void wxWin32Renderer::DrawFrameBackground(wxDC& dc,
3615                                           const wxRect& rect,
3616                                           int flags)
3617 {
3618     if ( !(flags & wxTOPLEVEL_TITLEBAR) ) return;
3619
3620     wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
3621                    wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE) :
3622                    wxSCHEME_COLOUR(m_scheme, TITLEBAR);
3623
3624     wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3625     r.height = FRAME_TITLEBAR_HEIGHT;
3626
3627     DrawBackground(dc, col, r);
3628 }
3629
3630 void wxWin32Renderer::DrawFrameTitle(wxDC& dc,
3631                                      const wxRect& rect,
3632                                      const wxString& title,
3633                                      int flags)
3634 {
3635     wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
3636                    wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE_TEXT) :
3637                    wxSCHEME_COLOUR(m_scheme, TITLEBAR_TEXT);
3638
3639     wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3640     r.height = FRAME_TITLEBAR_HEIGHT;
3641     if ( flags & wxTOPLEVEL_ICON )
3642     {
3643         r.x += FRAME_TITLEBAR_HEIGHT;
3644         r.width -= FRAME_TITLEBAR_HEIGHT + 2;
3645     }
3646     else
3647     {
3648         r.x += 1;
3649         r.width -= 3;
3650     }
3651
3652     if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
3653         r.width -= FRAME_BUTTON_WIDTH + 2;
3654     if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
3655         r.width -= FRAME_BUTTON_WIDTH;
3656     if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
3657         r.width -= FRAME_BUTTON_WIDTH;
3658     if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
3659         r.width -= FRAME_BUTTON_WIDTH;
3660     if ( flags & wxTOPLEVEL_BUTTON_HELP )
3661         r.width -= FRAME_BUTTON_WIDTH;
3662
3663     dc.SetFont(m_titlebarFont);
3664     dc.SetTextForeground(col);
3665
3666     wxCoord textW;
3667     dc.GetTextExtent(title, &textW, NULL);
3668     if ( textW > r.width )
3669     {
3670         // text is too big, let's shorten it and add "..." after it:
3671         size_t len = title.length();
3672         wxCoord WSoFar, letterW;
3673
3674         dc.GetTextExtent(wxT("..."), &WSoFar, NULL);
3675         if ( WSoFar > r.width )
3676         {
3677             // not enough space to draw anything
3678             return;
3679         }
3680
3681         wxString s;
3682         s.Alloc(len);
3683         for (size_t i = 0; i < len; i++)
3684         {
3685             dc.GetTextExtent(title[i], &letterW, NULL);
3686             if ( letterW + WSoFar > r.width )
3687                 break;
3688             WSoFar += letterW;
3689             s << title[i];
3690         }
3691         s << wxT("...");
3692         dc.DrawLabel(s, wxNullBitmap, r,
3693                      wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
3694     }
3695     else
3696         dc.DrawLabel(title, wxNullBitmap, r,
3697                      wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
3698 }
3699
3700 void wxWin32Renderer::DrawFrameIcon(wxDC& dc,
3701                                     const wxRect& rect,
3702                                     const wxIcon& icon,
3703                                     int flags)
3704 {
3705     if ( icon.Ok() )
3706     {
3707         wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3708         dc.DrawIcon(icon, r.x, r.y);
3709     }
3710 }
3711
3712 void wxWin32Renderer::DrawFrameButton(wxDC& dc,
3713                                       wxCoord x, wxCoord y,
3714                                       int button,
3715                                       int flags)
3716 {
3717     wxRect r(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
3718
3719     size_t idx = 0;
3720     switch (button)
3721     {
3722         case wxTOPLEVEL_BUTTON_CLOSE:    idx = FrameButton_Close; break;
3723         case wxTOPLEVEL_BUTTON_MAXIMIZE: idx = FrameButton_Maximize; break;
3724         case wxTOPLEVEL_BUTTON_ICONIZE: idx = FrameButton_Minimize; break;
3725         case wxTOPLEVEL_BUTTON_RESTORE:  idx = FrameButton_Restore; break;
3726         case wxTOPLEVEL_BUTTON_HELP:     idx = FrameButton_Help; break;
3727         default:
3728             wxFAIL_MSG(wxT("incorrect button specification"));
3729     }
3730
3731     if ( flags & wxCONTROL_PRESSED )
3732     {
3733         DrawShadedRect(dc, &r, m_penBlack, m_penHighlight);
3734         DrawShadedRect(dc, &r, m_penDarkGrey, m_penLightGrey);
3735         DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
3736         dc.DrawBitmap(m_bmpFrameButtons[idx], r.x+1, r.y+1, TRUE);
3737     }
3738     else
3739     {
3740         DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
3741         DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
3742         DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
3743         dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, TRUE);
3744     }
3745 }
3746
3747
3748 wxRect wxWin32Renderer::GetFrameClientArea(const wxRect& rect,
3749                                            int flags) const
3750 {
3751     wxRect r(rect);
3752
3753     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3754     {
3755         int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
3756                         RESIZEABLE_FRAME_BORDER_THICKNESS :
3757                         FRAME_BORDER_THICKNESS;
3758         r.Inflate(-border);
3759     }
3760     if ( flags & wxTOPLEVEL_TITLEBAR )
3761     {
3762         r.y += FRAME_TITLEBAR_HEIGHT;
3763         r.height -= FRAME_TITLEBAR_HEIGHT;
3764     }
3765
3766     return r;
3767 }
3768
3769 wxSize wxWin32Renderer::GetFrameTotalSize(const wxSize& clientSize,
3770                                      int flags) const
3771 {
3772     wxSize s(clientSize);
3773
3774     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3775     {
3776         int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
3777                         RESIZEABLE_FRAME_BORDER_THICKNESS :
3778                         FRAME_BORDER_THICKNESS;
3779         s.x += 2*border;
3780         s.y += 2*border;
3781     }
3782     if ( flags & wxTOPLEVEL_TITLEBAR )
3783         s.y += FRAME_TITLEBAR_HEIGHT;
3784
3785     return s;
3786 }
3787
3788 wxSize wxWin32Renderer::GetFrameMinSize(int flags) const
3789 {
3790     wxSize s(0, 0);
3791
3792     if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3793     {
3794         int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
3795                         RESIZEABLE_FRAME_BORDER_THICKNESS :
3796                         FRAME_BORDER_THICKNESS;
3797         s.x += 2*border;
3798         s.y += 2*border;
3799     }
3800
3801     if ( flags & wxTOPLEVEL_TITLEBAR )
3802     {
3803         s.y += FRAME_TITLEBAR_HEIGHT;
3804
3805         if ( flags & wxTOPLEVEL_ICON )
3806             s.x += FRAME_TITLEBAR_HEIGHT + 2;
3807         if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
3808             s.x += FRAME_BUTTON_WIDTH + 2;
3809         if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
3810             s.x += FRAME_BUTTON_WIDTH;
3811         if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
3812             s.x += FRAME_BUTTON_WIDTH;
3813         if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
3814             s.x += FRAME_BUTTON_WIDTH;
3815         if ( flags & wxTOPLEVEL_BUTTON_HELP )
3816             s.x += FRAME_BUTTON_WIDTH;
3817     }
3818
3819     return s;
3820 }
3821
3822 wxSize wxWin32Renderer::GetFrameIconSize() const
3823 {
3824     return wxSize(16, 16);
3825 }
3826
3827
3828 // ----------------------------------------------------------------------------
3829 // standard icons
3830 // ----------------------------------------------------------------------------
3831
3832 static char *error_xpm[]={
3833 "32 32 5 1",
3834 ". c None",
3835 "# c #800000",
3836 "b c #808080",
3837 "a c #ff0000",
3838 "c c #ffffff",
3839 "...........########.............",
3840 "........###aaaaaaaa###..........",
3841 ".......#aaaaaaaaaaaaaa#.........",
3842 ".....##aaaaaaaaaaaaaaaa##.......",
3843 "....#aaaaaaaaaaaaaaaaaaaa#......",
3844 "...#aaaaaaaaaaaaaaaaaaaaaa#.....",
3845 "...#aaaaaaaaaaaaaaaaaaaaaa#b....",
3846 "..#aaaaaacaaaaaaaaaacaaaaaa#b...",
3847 ".#aaaaaacccaaaaaaaacccaaaaaa#...",
3848 ".#aaaaacccccaaaaaacccccaaaaa#b..",
3849 ".#aaaaaacccccaaaacccccaaaaaa#bb.",
3850 "#aaaaaaaacccccaacccccaaaaaaaa#b.",
3851 "#aaaaaaaaaccccccccccaaaaaaaaa#b.",
3852 "#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
3853 "#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
3854 "#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
3855 "#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
3856 "#aaaaaaaaaccccccccccaaaaaaaaa#bb",
3857 "#aaaaaaaacccccaacccccaaaaaaaa#bb",
3858 ".#aaaaaacccccaaaacccccaaaaaa#bbb",
3859 ".#aaaaacccccaaaaaacccccaaaaa#bbb",
3860 ".#aaaaaacccaaaaaaaacccaaaaaa#bb.",
3861 "..#aaaaaacaaaaaaaaaacaaaaaa#bbb.",
3862 "...#aaaaaaaaaaaaaaaaaaaaaa#bbbb.",
3863 "...#aaaaaaaaaaaaaaaaaaaaaa#bbb..",
3864 "....#aaaaaaaaaaaaaaaaaaaa#bbb...",
3865 ".....##aaaaaaaaaaaaaaaa##bbbb...",
3866 "......b#aaaaaaaaaaaaaa#bbbbb....",
3867 ".......b###aaaaaaaa###bbbbb.....",
3868 ".........bb########bbbbbb.......",
3869 "..........bbbbbbbbbbbbbb........",
3870 ".............bbbbbbbb..........."};
3871
3872 static char *info_xpm[]={
3873 "32 32 6 1",
3874 ". c None",
3875 "d c #000000",
3876 "c c #0000ff",
3877 "# c #808080",
3878 "a c #c0c0c0",
3879 "b c #ffffff",
3880 "...........########.............",
3881 "........###abbbbbba###..........",
3882 "......##abbbbbbbbbbbba##........",
3883 ".....#abbbbbbbbbbbbbbbba#.......",
3884 "....#bbbbbbbaccccabbbbbbbd......",
3885 "...#bbbbbbbbccccccbbbbbbbbd.....",
3886 "..#bbbbbbbbbccccccbbbbbbbbbd....",
3887 ".#abbbbbbbbbaccccabbbbbbbbbad...",
3888 ".#bbbbbbbbbbbbbbbbbbbbbbbbbbd#..",
3889 "#abbbbbbbbbbbbbbbbbbbbbbbbbbad#.",
3890 "#bbbbbbbbbbcccccccbbbbbbbbbbbd#.",
3891 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3892 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3893 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3894 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3895 "#abbbbbbbbbbbcccccbbbbbbbbbbad##",
3896 ".#bbbbbbbbbbbcccccbbbbbbbbbbd###",
3897 ".#abbbbbbbbbbcccccbbbbbbbbbad###",
3898 "..#bbbbbbbbcccccccccbbbbbbbd###.",
3899 "...dbbbbbbbbbbbbbbbbbbbbbbd####.",
3900 "....dbbbbbbbbbbbbbbbbbbbbd####..",
3901 ".....dabbbbbbbbbbbbbbbbad####...",
3902 "......ddabbbbbbbbbbbbadd####....",
3903 ".......#dddabbbbbbaddd#####.....",
3904 "........###dddabbbd#######......",
3905 "..........####dbbbd#####........",
3906 ".............#dbbbd##...........",
3907 "...............dbbd##...........",
3908 "................dbd##...........",
3909 ".................dd##...........",
3910 "..................###...........",
3911 "...................##..........."};
3912
3913 static char *question_xpm[]={
3914 "32 32 6 1",
3915 ". c None",
3916 "c c #000000",
3917 "d c #0000ff",
3918 "# c #808080",
3919 "a c #c0c0c0",
3920 "b c #ffffff",
3921 "...........########.............",
3922 "........###abbbbbba###..........",
3923 "......##abbbbbbbbbbbba##........",
3924 ".....#abbbbbbbbbbbbbbbba#.......",
3925 "....#bbbbbbbbbbbbbbbbbbbbc......",
3926 "...#bbbbbbbaddddddabbbbbbbc.....",
3927 "..#bbbbbbbadabbddddabbbbbbbc....",
3928 ".#abbbbbbbddbbbbddddbbbbbbbac...",
3929 ".#bbbbbbbbddddbbddddbbbbbbbbc#..",
3930 "#abbbbbbbbddddbaddddbbbbbbbbac#.",
3931 "#bbbbbbbbbaddabddddbbbbbbbbbbc#.",
3932 "#bbbbbbbbbbbbbadddbbbbbbbbbbbc##",
3933 "#bbbbbbbbbbbbbdddbbbbbbbbbbbbc##",
3934 "#bbbbbbbbbbbbbddabbbbbbbbbbbbc##",
3935 "#bbbbbbbbbbbbbddbbbbbbbbbbbbbc##",
3936 "#abbbbbbbbbbbbbbbbbbbbbbbbbbac##",
3937 ".#bbbbbbbbbbbaddabbbbbbbbbbbc###",
3938 ".#abbbbbbbbbbddddbbbbbbbbbbac###",
3939 "..#bbbbbbbbbbddddbbbbbbbbbbc###.",
3940 "...cbbbbbbbbbaddabbbbbbbbbc####.",
3941 "....cbbbbbbbbbbbbbbbbbbbbc####..",
3942 ".....cabbbbbbbbbbbbbbbbac####...",
3943 "......ccabbbbbbbbbbbbacc####....",
3944 ".......#cccabbbbbbaccc#####.....",
3945 "........###cccabbbc#######......",
3946 "..........####cbbbc#####........",
3947 ".............#cbbbc##...........",
3948 "...............cbbc##...........",
3949 "................cbc##...........",
3950 ".................cc##...........",
3951 "..................###...........",
3952 "...................##..........."};
3953
3954 static char *warning_xpm[]={
3955 "32 32 6 1",
3956 ". c None",
3957 "c c #000000",
3958 "# c #808000",
3959 "d c #808080",
3960 "b c #c0c0c0",
3961 "a c #ffff00",
3962 ".............###................",
3963 "............#aabc...............",
3964 "...........#aaaabcd.............",
3965 "...........#aaaaacdd............",
3966 "..........#aaaaaabcdd...........",
3967 "..........#aaaaaaacdd...........",
3968 ".........#aaaaaaaabcdd..........",
3969 ".........#aaaaaaaaacdd..........",
3970 "........#aaaaaaaaaabcdd.........",
3971 "........#aaabcccbaaacdd.........",
3972 ".......#aaaacccccaaabcdd........",
3973 ".......#aaaacccccaaaacdd........",
3974 "......#aaaaacccccaaaabcdd.......",
3975 "......#aaaaacccccaaaaacdd.......",
3976 ".....#aaaaaacccccaaaaabcdd......",
3977 ".....#aaaaaa#ccc#aaaaaacdd......",
3978 "....#aaaaaaabcccbaaaaaabcdd.....",
3979 "....#aaaaaaaacccaaaaaaaacdd.....",
3980 "...#aaaaaaaaa#c#aaaaaaaabcdd....",
3981 "...#aaaaaaaaabcbaaaaaaaaacdd....",
3982 "..#aaaaaaaaaaacaaaaaaaaaabcdd...",
3983 "..#aaaaaaaaaaaaaaaaaaaaaaacdd...",
3984 ".#aaaaaaaaaaabccbaaaaaaaaabcdd..",
3985 ".#aaaaaaaaaaaccccaaaaaaaaaacdd..",
3986 "#aaaaaaaaaaaaccccaaaaaaaaaabcdd.",
3987 "#aaaaaaaaaaaabccbaaaaaaaaaaacdd.",
3988 "#aaaaaaaaaaaaaaaaaaaaaaaaaaacddd",
3989 "#aaaaaaaaaaaaaaaaaaaaaaaaaabcddd",
3990 ".#aaaaaaaaaaaaaaaaaaaaaaaabcdddd",
3991 "..#ccccccccccccccccccccccccddddd",
3992 "....ddddddddddddddddddddddddddd.",
3993 ".....ddddddddddddddddddddddddd.."};
3994
3995 wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
3996                                           const wxArtClient& WXUNUSED(client),
3997                                           const wxSize& WXUNUSED(size))
3998 {
3999     if ( id == wxART_INFORMATION )
4000         return wxBitmap(info_xpm);
4001     if ( id == wxART_ERROR )
4002         return wxBitmap(error_xpm);
4003     if ( id == wxART_WARNING )
4004         return wxBitmap(warning_xpm);
4005     if ( id == wxART_QUESTION )
4006         return wxBitmap(question_xpm);
4007     return wxNullBitmap;
4008 }
4009
4010
4011 // ----------------------------------------------------------------------------
4012 // text control geometry
4013 // ----------------------------------------------------------------------------
4014
4015 static inline int GetTextBorderWidth()
4016 {
4017     return 1;
4018 }
4019
4020 wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
4021                                          const wxRect& rect) const
4022 {
4023     wxRect rectTotal = rect;
4024
4025     wxCoord widthBorder = GetTextBorderWidth();
4026     rectTotal.Inflate(widthBorder);
4027
4028     // this is what Windows does
4029     rectTotal.height++;
4030
4031     return rectTotal;
4032 }
4033
4034 wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
4035                                           const wxRect& rect,
4036                                           wxCoord *extraSpaceBeyond) const
4037 {
4038     wxRect rectText = rect;
4039
4040     // undo GetTextTotalArea()
4041     if ( rectText.height > 0 )
4042         rectText.height--;
4043
4044     wxCoord widthBorder = GetTextBorderWidth();
4045     rectText.Inflate(-widthBorder);
4046
4047     if ( extraSpaceBeyond )
4048         *extraSpaceBeyond = 0;
4049
4050     return rectText;
4051 }
4052
4053 // ----------------------------------------------------------------------------
4054 // size adjustments
4055 // ----------------------------------------------------------------------------
4056
4057 void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
4058 {
4059 #if wxUSE_SCROLLBAR
4060     if ( wxDynamicCast(window, wxScrollBar) )
4061     {
4062         // we only set the width of vert scrollbars and height of the
4063         // horizontal ones
4064         if ( window->GetWindowStyle() & wxSB_HORIZONTAL )
4065             size->y = m_sizeScrollbarArrow.y;
4066         else
4067             size->x = m_sizeScrollbarArrow.x;
4068
4069         // skip border width adjustments, they don't make sense for us
4070         return;
4071     }
4072 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
4073
4074 #if wxUSE_BUTTON
4075     if ( wxDynamicCast(window, wxButton) )
4076     {
4077         if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
4078         {
4079             // TODO: don't harcode all this
4080             size->x += 3*window->GetCharWidth();
4081
4082             wxCoord heightBtn = (11*(window->GetCharHeight() + 8))/10;
4083             if ( size->y < heightBtn - 8 )
4084                 size->y = heightBtn;
4085             else
4086                 size->y += 9;
4087         }
4088
4089         // for compatibility with other ports, the buttons default size is never
4090         // less than the standard one, but not when display not PDAs.
4091         if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
4092         {
4093         if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
4094             {
4095                         wxSize szDef = wxButton::GetDefaultSize();
4096                 if ( size->x < szDef.x )
4097                     size->x = szDef.x;
4098             }
4099         }
4100
4101         // no border width adjustments for buttons
4102         return;
4103     }
4104 #endif // wxUSE_BUTTON
4105
4106     // take into account the border width
4107     wxRect rectBorder = GetBorderDimensions(window->GetBorder());
4108     size->x += rectBorder.x + rectBorder.width;
4109     size->y += rectBorder.y + rectBorder.height;
4110 }
4111
4112 // ============================================================================
4113 // wxInputHandler
4114 // ============================================================================
4115
4116 // ----------------------------------------------------------------------------
4117 // wxWin32InputHandler
4118 // ----------------------------------------------------------------------------
4119
4120 wxWin32InputHandler::wxWin32InputHandler(wxWin32Renderer *renderer)
4121 {
4122     m_renderer = renderer;
4123 }
4124
4125 bool wxWin32InputHandler::HandleKey(wxInputConsumer *control,
4126                                     const wxKeyEvent& event,
4127                                     bool pressed)
4128 {
4129     return FALSE;
4130 }
4131
4132 bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
4133                                       const wxMouseEvent& event)
4134 {
4135     // clicking on the control gives it focus
4136     if ( event.ButtonDown() )
4137     {
4138         wxWindow *win = control->GetInputWindow();
4139
4140         if (( wxWindow::FindFocus() != control->GetInputWindow() ) &&
4141             ( win->AcceptsFocus() ) )
4142         {
4143             win->SetFocus();
4144
4145             return TRUE;
4146         }
4147     }
4148
4149     return FALSE;
4150 }
4151
4152 // ----------------------------------------------------------------------------
4153 // wxWin32ScrollBarInputHandler
4154 // ----------------------------------------------------------------------------
4155
4156 wxWin32ScrollBarInputHandler::
4157 wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
4158                              wxInputHandler *handler)
4159         : wxStdScrollBarInputHandler(renderer, handler)
4160 {
4161     m_scrollPaused = FALSE;
4162     m_interval = 0;
4163 }
4164
4165 bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
4166                                                  const wxControlAction& action)
4167 {
4168     // stop if went beyond the position of the original click (this can only
4169     // happen when we scroll by pages)
4170     bool stop = FALSE;
4171     if ( action == wxACTION_SCROLL_PAGE_DOWN )
4172     {
4173         stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
4174                 != wxHT_SCROLLBAR_BAR_2;
4175     }
4176     else if ( action == wxACTION_SCROLL_PAGE_UP )
4177     {
4178         stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
4179                 != wxHT_SCROLLBAR_BAR_1;
4180     }
4181
4182     if ( stop )
4183     {
4184         StopScrolling(scrollbar);
4185
4186         scrollbar->Refresh();
4187
4188         return FALSE;
4189     }
4190
4191     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
4192 }
4193
4194 bool wxWin32ScrollBarInputHandler::HandleMouse(wxInputConsumer *control,
4195                                                const wxMouseEvent& event)
4196 {
4197     // remember the current state
4198     bool wasDraggingThumb = m_htLast == wxHT_SCROLLBAR_THUMB;
4199
4200     // do process the message
4201     bool rc = wxStdScrollBarInputHandler::HandleMouse(control, event);
4202
4203     // analyse the changes
4204     if ( !wasDraggingThumb && (m_htLast == wxHT_SCROLLBAR_THUMB) )
4205     {
4206         // we just started dragging the thumb, remember its initial position to
4207         // be able to restore it if the drag is cancelled later
4208         m_eventStartDrag = event;
4209     }
4210
4211     return rc;
4212 }
4213
4214 bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
4215                                                    const wxMouseEvent& event)
4216 {
4217     // we don't highlight scrollbar elements, so there is no need to process
4218     // mouse move events normally - only do it while mouse is captured (i.e.
4219     // when we're dragging the thumb or pressing on something)
4220     if ( !m_winCapture )
4221         return FALSE;
4222
4223     if ( event.Entering() )
4224     {
4225         // we're not interested in this at all
4226         return FALSE;
4227     }
4228
4229     wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
4230     wxHitTest ht;
4231     if ( m_scrollPaused )
4232     {
4233         // check if the mouse returned to its original location
4234
4235         if ( event.Leaving() )
4236         {
4237             // it surely didn't
4238             return FALSE;
4239         }
4240
4241         ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
4242         if ( ht == m_htLast )
4243         {
4244             // yes it did, resume scrolling
4245             m_scrollPaused = FALSE;
4246             if ( m_timerScroll )
4247             {
4248                 // we were scrolling by line/page, restart timer
4249                 m_timerScroll->Start(m_interval);
4250
4251                 Press(scrollbar, TRUE);
4252             }
4253             else // we were dragging the thumb
4254             {
4255                 // restore its last location
4256                 HandleThumbMove(scrollbar, m_eventLastDrag);
4257             }
4258
4259             return TRUE;
4260         }
4261     }
4262     else // normal case, scrolling hasn't been paused
4263     {
4264         // if we're scrolling the scrollbar because the arrow or the shaft was
4265         // pressed, check that the mouse stays on the same scrollbar element
4266
4267 #if 0
4268         // Always let thumb jump back if we leave the scrollbar
4269         if ( event.Moving() )
4270         {
4271             ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
4272         }
4273         else // event.Leaving()
4274         {
4275             ht = wxHT_NOWHERE;
4276         }
4277 #else
4278         // Jump back only if we get far away from it
4279         wxPoint pos = event.GetPosition();
4280         if (scrollbar->HasFlag( wxVERTICAL ))
4281         {
4282             if (pos.x > -40 && pos.x < scrollbar->GetSize().x+40)
4283                pos.x = 5;
4284         }
4285         else
4286         {
4287             if (pos.y > -40 && pos.y < scrollbar->GetSize().y+40)
4288                pos.y = 5;
4289         }
4290         ht = m_renderer->HitTestScrollbar(scrollbar, pos );
4291 #endif
4292
4293         // if we're dragging the thumb and the mouse stays in the scrollbar, it
4294         // is still ok - we only want to catch the case when the mouse leaves
4295         // the scrollbar here
4296         if ( m_htLast == wxHT_SCROLLBAR_THUMB && ht != wxHT_NOWHERE )
4297         {
4298             ht = wxHT_SCROLLBAR_THUMB;
4299         }
4300
4301         if ( ht != m_htLast )
4302         {
4303             // what were we doing? 2 possibilities: either an arrow/shaft was
4304             // pressed in which case we have a timer and so we just stop it or
4305             // we were dragging the thumb
4306             if ( m_timerScroll )
4307             {
4308                 // pause scrolling
4309                 m_interval = m_timerScroll->GetInterval();
4310                 m_timerScroll->Stop();
4311                 m_scrollPaused = TRUE;
4312
4313                 // unpress the arrow
4314                 Press(scrollbar, FALSE);
4315             }
4316             else // we were dragging the thumb
4317             {
4318                 // remember the current thumb position to be able to restore it
4319                 // if the mouse returns to it later
4320                 m_eventLastDrag = event;
4321
4322                 // and restore the original position (before dragging) of the
4323                 // thumb for now
4324                 HandleThumbMove(scrollbar, m_eventStartDrag);
4325             }
4326
4327             return TRUE;
4328         }
4329     }
4330
4331     return wxStdScrollBarInputHandler::HandleMouseMove(control, event);
4332 }
4333
4334 // ----------------------------------------------------------------------------
4335 // wxWin32CheckboxInputHandler
4336 // ----------------------------------------------------------------------------
4337
4338 bool wxWin32CheckboxInputHandler::HandleKey(wxInputConsumer *control,
4339                                             const wxKeyEvent& event,
4340                                             bool pressed)
4341 {
4342     if ( pressed )
4343     {
4344         wxControlAction action;
4345         int keycode = event.GetKeyCode();
4346         switch ( keycode )
4347         {
4348             case WXK_SPACE:
4349                 action = wxACTION_CHECKBOX_TOGGLE;
4350                 break;
4351
4352             case WXK_SUBTRACT:
4353             case WXK_NUMPAD_SUBTRACT:
4354                 action = wxACTION_CHECKBOX_CHECK;
4355                 break;
4356
4357             case WXK_ADD:
4358             case WXK_NUMPAD_ADD:
4359             case WXK_NUMPAD_EQUAL:
4360                 action = wxACTION_CHECKBOX_CLEAR;
4361                 break;
4362         }
4363
4364         if ( !!action )
4365         {
4366             control->PerformAction(action);
4367
4368             return TRUE;
4369         }
4370     }
4371
4372     return FALSE;
4373 }
4374
4375 // ----------------------------------------------------------------------------
4376 // wxWin32TextCtrlInputHandler
4377 // ----------------------------------------------------------------------------
4378
4379 bool wxWin32TextCtrlInputHandler::HandleKey(wxInputConsumer *control,
4380                                             const wxKeyEvent& event,
4381                                             bool pressed)
4382 {
4383     // handle only MSW-specific text bindings here, the others are handled in
4384     // the base class
4385     if ( pressed )
4386     {
4387         int keycode = event.GetKeyCode();
4388
4389         wxControlAction action;
4390         if ( keycode == WXK_DELETE && event.ShiftDown() )
4391         {
4392             action = wxACTION_TEXT_CUT;
4393         }
4394         else if ( keycode == WXK_INSERT )
4395         {
4396             if ( event.ControlDown() )
4397                 action = wxACTION_TEXT_COPY;
4398             else if ( event.ShiftDown() )
4399                 action = wxACTION_TEXT_PASTE;
4400         }
4401
4402         if ( action != wxACTION_NONE )
4403         {
4404             control->PerformAction(action);
4405
4406             return TRUE;
4407         }
4408     }
4409
4410     return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
4411 }
4412
4413 // ----------------------------------------------------------------------------
4414 // wxWin32StatusBarInputHandler
4415 // ----------------------------------------------------------------------------
4416
4417 wxWin32StatusBarInputHandler::
4418 wxWin32StatusBarInputHandler(wxInputHandler *handler)
4419     : wxStdInputHandler(handler)
4420 {
4421     m_isOnGrip = FALSE;
4422 }
4423
4424 bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
4425                                             const wxPoint& pt) const
4426 {
4427     if ( statbar->HasFlag(wxST_SIZEGRIP) &&
4428          statbar->GetParent()->HasFlag(wxRESIZE_BORDER) )
4429     {
4430         wxTopLevelWindow *
4431             parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
4432
4433         wxCHECK_MSG( parentTLW, FALSE,
4434                      _T("the status bar should be a child of a TLW") );
4435
4436         // a maximized window can't be resized anyhow
4437         if ( !parentTLW->IsMaximized() )
4438         {
4439             // VZ: I think that the standard Windows behaviour is to only
4440             //     show the resizing cursor when the mouse is on top of the
4441             //     grip itself but apparently different Windows versions behave
4442             //     differently (?) and it seems a better UI to allow resizing
4443             //     the status bar even when the mouse is above the grip
4444             wxSize sizeSbar = statbar->GetSize();
4445
4446             int diff = sizeSbar.x - pt.x;
4447             return diff >= 0 && diff < (wxCoord)STATUSBAR_GRIP_SIZE;
4448         }
4449     }
4450
4451     return FALSE;
4452 }
4453
4454 bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
4455                                                const wxMouseEvent& event)
4456 {
4457     if ( event.Button(1) )
4458     {
4459         if ( event.ButtonDown(1) )
4460         {
4461             wxWindow *statbar = consumer->GetInputWindow();
4462
4463             if ( IsOnGrip(statbar, event.GetPosition()) )
4464             {
4465                 wxTopLevelWindow *tlw = wxDynamicCast(statbar->GetParent(),
4466                                                       wxTopLevelWindow);
4467                 if ( tlw )
4468                 {
4469                     tlw->PerformAction(wxACTION_TOPLEVEL_RESIZE,
4470                                        wxHT_TOPLEVEL_BORDER_SE);
4471
4472                     statbar->SetCursor(m_cursorOld);
4473
4474                     return TRUE;
4475                 }
4476             }
4477         }
4478     }
4479
4480     return wxStdInputHandler::HandleMouse(consumer, event);
4481 }
4482
4483 bool wxWin32StatusBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
4484                                                    const wxMouseEvent& event)
4485 {
4486     wxWindow *statbar = consumer->GetInputWindow();
4487
4488     bool isOnGrip = IsOnGrip(statbar, event.GetPosition());
4489     if ( isOnGrip != m_isOnGrip )
4490     {
4491         m_isOnGrip = isOnGrip;
4492         if ( isOnGrip )
4493         {
4494             m_cursorOld = statbar->GetCursor();
4495             statbar->SetCursor(wxCURSOR_SIZENWSE);
4496         }
4497         else
4498         {
4499             statbar->SetCursor(m_cursorOld);
4500         }
4501     }
4502
4503     return wxStdInputHandler::HandleMouseMove(consumer, event);
4504 }
4505
4506 // ----------------------------------------------------------------------------
4507 // wxWin32FrameInputHandler
4508 // ----------------------------------------------------------------------------
4509
4510 class wxWin32SystemMenuEvtHandler : public wxEvtHandler
4511 {
4512 public:
4513     wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);
4514
4515     void Attach(wxInputConsumer *consumer);
4516     void Detach();
4517
4518 private:
4519     DECLARE_EVENT_TABLE()
4520     void OnSystemMenu(wxCommandEvent &event);
4521     void OnCloseFrame(wxCommandEvent &event);
4522     void OnClose(wxCloseEvent &event);
4523
4524     wxWin32FrameInputHandler *m_inputHnd;
4525     wxTopLevelWindow         *m_wnd;
4526     wxAcceleratorTable        m_oldAccelTable;
4527 };
4528
4529 wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(
4530                                 wxWin32FrameInputHandler *handler)
4531 {
4532     m_inputHnd = handler;
4533     m_wnd = NULL;
4534 }
4535
4536 void wxWin32SystemMenuEvtHandler::Attach(wxInputConsumer *consumer)
4537 {
4538     wxASSERT_MSG( m_wnd == NULL, _T("can't attach the handler twice!") );
4539
4540     m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
4541     m_wnd->PushEventHandler(this);
4542
4543     // VS: This code relies on using generic implementation of
4544     //     wxAcceleratorTable in wxUniv!
4545     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
4546     m_oldAccelTable = table;
4547     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_SPACE, wxID_SYSTEM_MENU));
4548     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_F4, wxID_CLOSE_FRAME));
4549     m_wnd->SetAcceleratorTable(table);
4550 }
4551
4552 void wxWin32SystemMenuEvtHandler::Detach()
4553 {
4554     if ( m_wnd )
4555     {
4556         m_wnd->SetAcceleratorTable(m_oldAccelTable);
4557         m_wnd->RemoveEventHandler(this);
4558         m_wnd = NULL;
4559     }
4560 }
4561
4562 BEGIN_EVENT_TABLE(wxWin32SystemMenuEvtHandler, wxEvtHandler)
4563     EVT_MENU(wxID_SYSTEM_MENU, wxWin32SystemMenuEvtHandler::OnSystemMenu)
4564     EVT_MENU(wxID_CLOSE_FRAME, wxWin32SystemMenuEvtHandler::OnCloseFrame)
4565     EVT_CLOSE(wxWin32SystemMenuEvtHandler::OnClose)
4566 END_EVENT_TABLE()
4567
4568 void wxWin32SystemMenuEvtHandler::OnSystemMenu(wxCommandEvent &WXUNUSED(event))
4569 {
4570     int border = ((m_wnd->GetWindowStyle() & wxRESIZE_BORDER) &&
4571                   !m_wnd->IsMaximized()) ?
4572                       RESIZEABLE_FRAME_BORDER_THICKNESS :
4573                       FRAME_BORDER_THICKNESS;
4574     wxPoint pt = m_wnd->GetClientAreaOrigin();
4575     pt.x = -pt.x + border;
4576     pt.y = -pt.y + border + FRAME_TITLEBAR_HEIGHT;
4577
4578     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
4579     m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);
4580     m_inputHnd->PopupSystemMenu(m_wnd, pt);
4581     m_wnd->SetAcceleratorTable(table);
4582 }
4583
4584 void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
4585 {
4586     m_wnd->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
4587                          wxTOPLEVEL_BUTTON_CLOSE);
4588 }
4589
4590 void wxWin32SystemMenuEvtHandler::OnClose(wxCloseEvent &event)
4591 {
4592     m_wnd = NULL;
4593     event.Skip();
4594 }
4595
4596
4597 wxWin32FrameInputHandler::wxWin32FrameInputHandler(wxInputHandler *handler)
4598         : wxStdFrameInputHandler(handler)
4599 {
4600     m_menuHandler = new wxWin32SystemMenuEvtHandler(this);
4601 }
4602
4603 wxWin32FrameInputHandler::~wxWin32FrameInputHandler()
4604 {
4605     if ( m_menuHandler )
4606     {
4607         m_menuHandler->Detach();
4608         delete m_menuHandler;
4609     }
4610 }
4611
4612 bool wxWin32FrameInputHandler::HandleMouse(wxInputConsumer *consumer,
4613                                            const wxMouseEvent& event)
4614 {
4615     if ( event.LeftDClick() || event.LeftDown() || event.RightDown() )
4616     {
4617         wxTopLevelWindow *tlw =
4618             wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
4619
4620         long hit = tlw->HitTest(event.GetPosition());
4621
4622         if ( event.LeftDClick() && hit == wxHT_TOPLEVEL_TITLEBAR )
4623         {
4624             tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
4625                                tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
4626                                                   : wxTOPLEVEL_BUTTON_MAXIMIZE);
4627             return TRUE;
4628         }
4629         else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
4630         {
4631             if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
4632                  (event.RightDown() &&
4633                       (hit == wxHT_TOPLEVEL_TITLEBAR ||
4634                        hit == wxHT_TOPLEVEL_ICON)) )
4635             {
4636                 PopupSystemMenu(tlw, event.GetPosition());
4637                 return TRUE;
4638             }
4639         }
4640     }
4641
4642     return wxStdFrameInputHandler::HandleMouse(consumer, event);
4643 }
4644
4645 void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,
4646                                                const wxPoint& pos) const
4647 {
4648     wxMenu *menu = new wxMenu;
4649
4650     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
4651         menu->Append(wxID_RESTORE_FRAME , _("&Restore"));
4652     menu->Append(wxID_MOVE_FRAME , _("&Move"));
4653     if ( window->GetWindowStyle() & wxRESIZE_BORDER )
4654         menu->Append(wxID_RESIZE_FRAME , _("&Size"));
4655     if ( wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME) )
4656         menu->Append(wxID_ICONIZE_FRAME , _("Mi&nimize"));
4657     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
4658         menu->Append(wxID_MAXIMIZE_FRAME , _("Ma&ximize"));
4659     menu->AppendSeparator();
4660     menu->Append(wxID_CLOSE_FRAME, _("Close\tAlt-F4"));
4661
4662     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
4663     {
4664         if ( window->IsMaximized() )
4665         {
4666             menu->Enable(wxID_MAXIMIZE_FRAME, FALSE);
4667             menu->Enable(wxID_MOVE_FRAME, FALSE);
4668             if ( window->GetWindowStyle() & wxRESIZE_BORDER )
4669                 menu->Enable(wxID_RESIZE_FRAME, FALSE);
4670         }
4671         else
4672             menu->Enable(wxID_RESTORE_FRAME, FALSE);
4673     }
4674
4675     window->PopupMenu(menu, pos);
4676     delete menu;
4677 }
4678
4679 bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
4680                                                 bool activated)
4681 {
4682     if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
4683     {
4684         // always detach if active frame changed:
4685         m_menuHandler->Detach();
4686
4687         if ( activated )
4688         {
4689             m_menuHandler->Attach(consumer);
4690         }
4691     }
4692
4693     return wxStdFrameInputHandler::HandleActivation(consumer, activated);
4694 }