src/univ/themes/win32.cpp

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