src/univ/themes/mono.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/univ/themes/mono.cpp
   3 // Purpose:     wxUniversal theme for monochrome displays
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     2006-08-27
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2006 REA Elektronik GmbH
   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 #include "wx/univ/theme.h"
  28
  29 #if wxUSE_THEME_MONO
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/dc.h"
  33 #endif // WX_PRECOMP
  34
  35 #include "wx/artprov.h"
  36 #include "wx/univ/stdrend.h"
  37 #include "wx/univ/inphand.h"
  38 #include "wx/univ/colschem.h"
  39
  40 class wxMonoColourScheme;
  41
  42 #define wxMONO_BG_COL   (*wxWHITE)
  43 #define wxMONO_FG_COL   (*wxBLACK)
  44
  45 // ----------------------------------------------------------------------------
  46 // wxMonoRenderer: draw the GUI elements in simplest possible way
  47 // ----------------------------------------------------------------------------
  48
  49 // Warning: many of the methods here are not implemented, the code won't work
  50 // if any but a few wxUSE_XXXs are on
  51 class wxMonoRenderer : public wxStdRenderer
  52 {
  53 public:
  54     wxMonoRenderer(const wxColourScheme *scheme);
  55
  56     virtual void DrawButtonLabel(wxDC& dc,
  57                                  const wxString& label,
  58                                  const wxBitmap& image,
  59                                  const wxRect& rect,
  60                                  int flags = 0,
  61                                  int alignment = wxALIGN_LEFT | wxALIGN_TOP,
  62                                  int indexAccel = -1,
  63                                  wxRect *rectBounds = NULL);
  64
  65     virtual void DrawButtonBorder(wxDC& dc,
  66                                   const wxRect& rect,
  67                                   int flags = 0,
  68                                   wxRect *rectIn = NULL);
  69
  70     virtual void DrawHorizontalLine(wxDC& dc,
  71                                     wxCoord y, wxCoord x1, wxCoord x2);
  72
  73     virtual void DrawVerticalLine(wxDC& dc,
  74                                   wxCoord x, wxCoord y1, wxCoord y2);
  75
  76     virtual void DrawArrow(wxDC& dc,
  77                            wxDirection dir,
  78                            const wxRect& rect,
  79                            int flags = 0);
  80     virtual void DrawScrollbarThumb(wxDC& dc,
  81                                     wxOrientation orient,
  82                                     const wxRect& rect,
  83                                     int flags = 0);
  84     virtual void DrawScrollbarShaft(wxDC& dc,
  85                                     wxOrientation orient,
  86                                     const wxRect& rect,
  87                                     int flags = 0);
  88
  89 #if wxUSE_TOOLBAR
  90     virtual void DrawToolBarButton(wxDC& dc,
  91                                    const wxString& label,
  92                                    const wxBitmap& bitmap,
  93                                    const wxRect& rect,
  94                                    int flags = 0,
  95                                    long style = 0,
  96                                    int tbarStyle = 0);
  97 #endif // wxUSE_TOOLBAR
  98
  99 #if wxUSE_NOTEBOOK
 100     virtual void DrawTab(wxDC& dc,
 101                          const wxRect& rect,
 102                          wxDirection dir,
 103                          const wxString& label,
 104                          const wxBitmap& bitmap = wxNullBitmap,
 105                          int flags = 0,
 106                          int indexAccel = -1);
 107 #endif // wxUSE_NOTEBOOK
 108
 109 #if wxUSE_SLIDER
 110     virtual void DrawSliderShaft(wxDC& dc,
 111                                  const wxRect& rect,
 112                                  int lenThumb,
 113                                  wxOrientation orient,
 114                                  int flags = 0,
 115                                  long style = 0,
 116                                  wxRect *rectShaft = NULL);
 117
 118     virtual void DrawSliderThumb(wxDC& dc,
 119                                  const wxRect& rect,
 120                                  wxOrientation orient,
 121                                  int flags = 0,
 122                                  long style = 0);
 123
 124     virtual void DrawSliderTicks(wxDC& dc,
 125                                  const wxRect& rect,
 126                                  int lenThumb,
 127                                  wxOrientation orient,
 128                                  int start,
 129                                  int end,
 130                                  int step = 1,
 131                                  int flags = 0,
 132                                  long style = 0);
 133 #endif // wxUSE_SLIDER
 134
 135 #if wxUSE_MENUS
 136     virtual void DrawMenuBarItem(wxDC& dc,
 137                                  const wxRect& rect,
 138                                  const wxString& label,
 139                                  int flags = 0,
 140                                  int indexAccel = -1);
 141
 142     virtual void DrawMenuItem(wxDC& dc,
 143                               wxCoord y,
 144                               const wxMenuGeometryInfo& geometryInfo,
 145                               const wxString& label,
 146                               const wxString& accel,
 147                               const wxBitmap& bitmap = wxNullBitmap,
 148                               int flags = 0,
 149                               int indexAccel = -1);
 150
 151     virtual void DrawMenuSeparator(wxDC& dc,
 152                                    wxCoord y,
 153                                    const wxMenuGeometryInfo& geomInfo);
 154 #endif // wxUSE_MENUS
 155
 156 #if wxUSE_COMBOBOX
 157     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
 158                                  wxBitmap *bmpFocus,
 159                                  wxBitmap *bmpPressed,
 160                                  wxBitmap *bmpDisabled);
 161 #endif // wxUSE_COMBOBOX
 162
 163
 164     virtual wxRect GetBorderDimensions(wxBorder border) const;
 165
 166 #if wxUSE_SCROLLBAR
 167     virtual wxSize GetScrollbarArrowSize() const { return GetStdBmpSize(); }
 168 #endif // wxUSE_SCROLLBAR
 169
 170     virtual wxSize GetCheckBitmapSize() const { return GetStdBmpSize(); }
 171     virtual wxSize GetRadioBitmapSize() const { return GetStdBmpSize(); }
 172
 173 #if wxUSE_TOOLBAR
 174     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const;
 175
 176     virtual wxSize GetToolBarMargin() const;
 177 #endif // wxUSE_TOOLBAR
 178
 179 #if wxUSE_NOTEBOOK
 180     virtual wxSize GetTabIndent() const;
 181
 182     virtual wxSize GetTabPadding() const;
 183 #endif // wxUSE_NOTEBOOK
 184
 185 #if wxUSE_SLIDER
 186     virtual wxCoord GetSliderDim() const;
 187
 188     virtual wxCoord GetSliderTickLen() const;
 189
 190     virtual wxRect GetSliderShaftRect(const wxRect& rect,
 191                                       int lenThumb,
 192                                       wxOrientation orient,
 193                                       long style = 0) const;
 194
 195     virtual wxSize GetSliderThumbSize(const wxRect& rect,
 196                                       int lenThumb,
 197                                       wxOrientation orient) const;
 198 #endif // wxUSE_SLIDER
 199
 200     virtual wxSize GetProgressBarStep() const;
 201
 202 #if wxUSE_MENUS
 203     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
 204
 205     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
 206                                                 const wxMenu& menu) const;
 207 #endif // wxUSE_MENUS
 208
 209 #if wxUSE_STATUSBAR
 210     virtual wxCoord GetStatusBarBorderBetweenFields() const;
 211
 212     virtual wxSize GetStatusBarFieldMargins() const;
 213 #endif // wxUSE_STATUSBAR
 214
 215 protected:
 216     // override base class border drawing routines: we always draw just a
 217     // single simple border
 218     void DrawSimpleBorder(wxDC& dc, wxRect *rect)
 219         { DrawRect(dc, rect, m_penFg); }
 220
 221     virtual void DrawRaisedBorder(wxDC& dc, wxRect *rect)
 222         { DrawSimpleBorder(dc, rect); }
 223     virtual void DrawSunkenBorder(wxDC& dc, wxRect *rect)
 224         { DrawSimpleBorder(dc, rect); }
 225     virtual void DrawAntiSunkenBorder(wxDC& dc, wxRect *rect)
 226         { DrawSimpleBorder(dc, rect); }
 227     virtual void DrawBoxBorder(wxDC& dc, wxRect *rect)
 228         { DrawSimpleBorder(dc, rect); }
 229     virtual void DrawStaticBorder(wxDC& dc, wxRect *rect)
 230         { DrawSimpleBorder(dc, rect); }
 231     virtual void DrawExtraBorder(wxDC& WXUNUSED(dc), wxRect * WXUNUSED(rect))
 232         { /* no extra borders for us */ }
 233
 234     // all our XPMs are of this size
 235     static wxSize GetStdBmpSize() { return wxSize(8, 8); }
 236
 237     wxBitmap GetIndicator(IndicatorType indType, int flags);
 238     virtual wxBitmap GetCheckBitmap(int flags)
 239         { return GetIndicator(IndicatorType_Check, flags); }
 240     virtual wxBitmap GetRadioBitmap(int flags)
 241         { return GetIndicator(IndicatorType_Radio, flags); }
 242
 243     virtual wxBitmap GetFrameButtonBitmap(FrameButtonType type);
 244     virtual int GetFrameBorderWidth(int flags) const;
 245
 246 private:
 247     // the bitmaps returned by GetIndicator()
 248     wxBitmap m_bmpIndicators[IndicatorType_MaxCtrl]
 249                             [IndicatorState_MaxCtrl]
 250                             [IndicatorStatus_Max];
 251
 252     static const char **ms_xpmIndicators[IndicatorType_MaxCtrl]
 253                                         [IndicatorState_MaxCtrl]
 254                                         [IndicatorStatus_Max];
 255
 256     // the arrow bitmaps used by DrawArrow()
 257     wxBitmap m_bmpArrows[Arrow_Max];
 258
 259     static const char **ms_xpmArrows[Arrow_Max];
 260
 261     // the close bitmap for the frame for GetFrameButtonBitmap()
 262     wxBitmap m_bmpFrameClose;
 263
 264     // pen used for foreground drawing
 265     wxPen m_penFg;
 266 };
 267
 268 // ----------------------------------------------------------------------------
 269 // standard bitmaps
 270 // ----------------------------------------------------------------------------
 271
 272 static const char *xpmUnchecked[] = {
 273 /* columns rows colors chars-per-pixel */
 274 "8 8 2 1",
 275 "  c white",
 276 "X c black",
 277 /* pixels */
 278 "XXXXXXXX",
 279 "X      X",
 280 "X      X",
 281 "X      X",
 282 "X      X",
 283 "X      X",
 284 "X      X",
 285 "XXXXXXXX",
 286 };
 287
 288 static const char *xpmChecked[] = {
 289 /* columns rows colors chars-per-pixel */
 290 "8 8 2 1",
 291 "  c white",
 292 "X c black",
 293 /* pixels */
 294 "XXXXXXXX",
 295 "X      X",
 296 "X X  X X",
 297 "X  XX  X",
 298 "X  XX  X",
 299 "X X  X X",
 300 "X      X",
 301 "XXXXXXXX",
 302 };
 303
 304 static const char *xpmUndeterminate[] = {
 305 /* columns rows colors chars-per-pixel */
 306 "8 8 2 1",
 307 "  c white",
 308 "X c black",
 309 /* pixels */
 310 "XXXXXXXX",
 311 "X X X XX",
 312 "XX X X X",
 313 "X X X XX",
 314 "XX X X X",
 315 "X X X XX",
 316 "XX X X X",
 317 "XXXXXXXX",
 318 };
 319
 320 static const char *xpmRadioUnchecked[] = {
 321 /* columns rows colors chars-per-pixel */
 322 "8 8 2 1",
 323 "  c white",
 324 "X c black",
 325 /* pixels */
 326 "XXXXXXXX",
 327 "X      X",
 328 "X  XX  X",
 329 "X X  X X",
 330 "X X  X X",
 331 "X  XX  X",
 332 "X      X",
 333 "XXXXXXXX",
 334 };
 335
 336 static const char *xpmRadioChecked[] = {
 337 /* columns rows colors chars-per-pixel */
 338 "8 8 2 1",
 339 "  c white",
 340 "X c black",
 341 /* pixels */
 342 "XXXXXXXX",
 343 "X      X",
 344 "X  XX  X",
 345 "X XXXX X",
 346 "X XXXX X",
 347 "X  XX  X",
 348 "X      X",
 349 "XXXXXXXX",
 350 };
 351
 352 const char **wxMonoRenderer::ms_xpmIndicators[IndicatorType_MaxCtrl]
 353                                              [IndicatorState_MaxCtrl]
 354                                              [IndicatorStatus_Max] =
 355 {
 356     // checkboxes first
 357     {
 358         // normal state
 359         { xpmChecked, xpmUnchecked, xpmUndeterminate },
 360
 361         // pressed state
 362         { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
 363
 364         // disabled state
 365         { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
 366     },
 367
 368     // radio
 369     {
 370         // normal state
 371         { xpmRadioChecked, xpmRadioUnchecked, xpmUndeterminate },
 372
 373         // pressed state
 374         { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
 375
 376         // disabled state
 377         { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
 378     },
 379 };
 380
 381 static const char *xpmLeftArrow[] = {
 382 /* columns rows colors chars-per-pixel */
 383 "8 8 2 1",
 384 "  c white",
 385 "X c black",
 386 /* pixels */
 387 "   X    ",
 388 "  XX    ",
 389 " XXX    ",
 390 "XXXX    ",
 391 "XXXX    ",
 392 " XXX    ",
 393 "  XX    ",
 394 "   X    ",
 395 };
 396
 397 static const char *xpmRightArrow[] = {
 398 /* columns rows colors chars-per-pixel */
 399 "8 8 2 1",
 400 "  c white",
 401 "X c black",
 402 /* pixels */
 403 "    X   ",
 404 "    XX  ",
 405 "    XXX ",
 406 "    XXXX",
 407 "    XXXX",
 408 "    XXX ",
 409 "    XX  ",
 410 "    X   ",
 411 };
 412
 413 static const char *xpmUpArrow[] = {
 414 /* columns rows colors chars-per-pixel */
 415 "8 8 2 1",
 416 "  c white",
 417 "X c black",
 418 /* pixels */
 419 "        ",
 420 "   XX   ",
 421 "  XXXX  ",
 422 " XXXXXX ",
 423 "XXXXXXXX",
 424 "        ",
 425 "        ",
 426 "        ",
 427 };
 428
 429 static const char *xpmDownArrow[] = {
 430 /* columns rows colors chars-per-pixel */
 431 "8 8 2 1",
 432 "  c white",
 433 "X c black",
 434 /* pixels */
 435 "        ",
 436 "        ",
 437 "        ",
 438 "XXXXXXXX",
 439 " XXXXXX ",
 440 "  XXXX  ",
 441 "   XX   ",
 442 "        ",
 443 };
 444
 445 const char **wxMonoRenderer::ms_xpmArrows[Arrow_Max] =
 446 {
 447     xpmLeftArrow, xpmRightArrow, xpmUpArrow, xpmDownArrow,
 448 };
 449
 450 // ----------------------------------------------------------------------------
 451 // wxMonoColourScheme: uses just white and black
 452 // ----------------------------------------------------------------------------
 453
 454 class wxMonoColourScheme : public wxColourScheme
 455 {
 456 public:
 457     // we use only 2 colours, white and black, but we avoid referring to them
 458     // like this, instead use the functions below
 459     wxColour GetFg() const { return wxMONO_FG_COL; }
 460     wxColour GetBg() const { return wxMONO_BG_COL; }
 461
 462     // implement base class pure virtuals
 463     virtual wxColour Get(StdColour col) const;
 464     virtual wxColour GetBackground(wxWindow *win) const;
 465 };
 466
 467 // ----------------------------------------------------------------------------
 468 // wxMonoArtProvider
 469 // ----------------------------------------------------------------------------
 470
 471 class wxMonoArtProvider : public wxArtProvider
 472 {
 473 protected:
 474     virtual wxBitmap CreateBitmap(const wxArtID& id,
 475                                   const wxArtClient& client,
 476                                   const wxSize& size);
 477 };
 478
 479 // ----------------------------------------------------------------------------
 480 // wxMonoTheme
 481 // ----------------------------------------------------------------------------
 482
 483 class wxMonoTheme : public wxTheme
 484 {
 485 public:
 486     wxMonoTheme();
 487     virtual ~wxMonoTheme();
 488
 489     virtual wxRenderer *GetRenderer();
 490     virtual wxArtProvider *GetArtProvider();
 491     virtual wxInputHandler *GetInputHandler(const wxString& control,
 492                                             wxInputConsumer *consumer);
 493     virtual wxColourScheme *GetColourScheme();
 494
 495 private:
 496     wxMonoRenderer *m_renderer;
 497     wxMonoArtProvider *m_artProvider;
 498     wxMonoColourScheme *m_scheme;
 499
 500     WX_DECLARE_THEME(mono)
 501 };
 502
 503 // ============================================================================
 504 // implementation
 505 // ============================================================================
 506
 507 WX_IMPLEMENT_THEME(wxMonoTheme, mono, wxTRANSLATE("Simple monochrome theme"));
 508
 509 // ----------------------------------------------------------------------------
 510 // wxMonoTheme
 511 // ----------------------------------------------------------------------------
 512
 513 wxMonoTheme::wxMonoTheme()
 514 {
 515     m_scheme = NULL;
 516     m_renderer = NULL;
 517     m_artProvider = NULL;
 518 }
 519
 520 wxMonoTheme::~wxMonoTheme()
 521 {
 522     delete m_renderer;
 523     delete m_scheme;
 524     delete m_artProvider;
 525 }
 526
 527 wxRenderer *wxMonoTheme::GetRenderer()
 528 {
 529     if ( !m_renderer )
 530     {
 531         m_renderer = new wxMonoRenderer(GetColourScheme());
 532     }
 533
 534     return m_renderer;
 535 }
 536
 537 wxArtProvider *wxMonoTheme::GetArtProvider()
 538 {
 539     if ( !m_artProvider )
 540     {
 541         m_artProvider = new wxMonoArtProvider;
 542     }
 543
 544     return m_artProvider;
 545 }
 546
 547 wxColourScheme *wxMonoTheme::GetColourScheme()
 548 {
 549     if ( !m_scheme )
 550     {
 551         m_scheme = new wxMonoColourScheme;
 552     }
 553
 554     return m_scheme;
 555 }
 556
 557 wxInputHandler *wxMonoTheme::GetInputHandler(const wxString& WXUNUSED(control),
 558                                              wxInputConsumer *consumer)
 559 {
 560     // no special input handlers so far
 561     return consumer->DoGetStdInputHandler(NULL);
 562 }
 563
 564 // ============================================================================
 565 // wxMonoColourScheme
 566 // ============================================================================
 567
 568 wxColour wxMonoColourScheme::GetBackground(wxWindow *win) const
 569 {
 570     wxColour col;
 571     if ( win->UseBgCol() )
 572     {
 573         // use the user specified colour
 574         col = win->GetBackgroundColour();
 575     }
 576
 577     // doesn't depend on the state
 578     if ( !col.Ok() )
 579     {
 580         col = GetBg();
 581     }
 582
 583     return col;
 584 }
 585
 586 wxColour wxMonoColourScheme::Get(wxMonoColourScheme::StdColour col) const
 587 {
 588     switch ( col )
 589     {
 590         case WINDOW:
 591         case CONTROL:
 592         case CONTROL_PRESSED:
 593         case CONTROL_CURRENT:
 594         case SCROLLBAR:
 595         case SCROLLBAR_PRESSED:
 596         case GAUGE:
 597         case TITLEBAR:
 598         case TITLEBAR_ACTIVE:
 599         case HIGHLIGHT_TEXT:
 600         case DESKTOP:
 601             return GetBg();
 602
 603         case MAX:
 604         default:
 605             wxFAIL_MSG(_T("invalid standard colour"));
 606             // fall through
 607
 608         case SHADOW_DARK:
 609         case SHADOW_HIGHLIGHT:
 610         case SHADOW_IN:
 611         case SHADOW_OUT:
 612         case CONTROL_TEXT:
 613         case CONTROL_TEXT_DISABLED:
 614         case CONTROL_TEXT_DISABLED_SHADOW:
 615         case TITLEBAR_TEXT:
 616         case TITLEBAR_ACTIVE_TEXT:
 617         case HIGHLIGHT:
 618             return GetFg();
 619
 620     }
 621 }
 622
 623 // ============================================================================
 624 // wxMonoRenderer
 625 // ============================================================================
 626
 627 // ----------------------------------------------------------------------------
 628 // construction
 629 // ----------------------------------------------------------------------------
 630
 631 wxMonoRenderer::wxMonoRenderer(const wxColourScheme *scheme)
 632               : wxStdRenderer(scheme)
 633 {
 634     m_penFg = wxPen(wxMONO_FG_COL);
 635 }
 636
 637 // ----------------------------------------------------------------------------
 638 // borders
 639 // ----------------------------------------------------------------------------
 640
 641 wxRect wxMonoRenderer::GetBorderDimensions(wxBorder border) const
 642 {
 643     wxCoord width;
 644     switch ( border )
 645     {
 646         case wxBORDER_SIMPLE:
 647         case wxBORDER_STATIC:
 648         case wxBORDER_RAISED:
 649         case wxBORDER_SUNKEN:
 650             width = 1;
 651             break;
 652
 653         case wxBORDER_DOUBLE:
 654             width = 2;
 655             break;
 656
 657         default:
 658             wxFAIL_MSG(_T("unknown border type"));
 659             // fall through
 660
 661         case wxBORDER_DEFAULT:
 662         case wxBORDER_NONE:
 663             width = 0;
 664             break;
 665     }
 666
 667     wxRect rect;
 668     rect.x =
 669     rect.y =
 670     rect.width =
 671     rect.height = width;
 672
 673     return rect;
 674 }
 675
 676 void wxMonoRenderer::DrawButtonBorder(wxDC& dc,
 677                                      const wxRect& rect,
 678                                      int flags,
 679                                      wxRect *rectIn)
 680 {
 681     DrawBorder(dc, wxBORDER_SIMPLE, rect, flags, rectIn);
 682 }
 683
 684 // ----------------------------------------------------------------------------
 685 // lines and frames
 686 // ----------------------------------------------------------------------------
 687
 688 void
 689 wxMonoRenderer::DrawHorizontalLine(wxDC& dc, wxCoord y, wxCoord x1, wxCoord x2)
 690 {
 691     dc.SetPen(m_penFg);
 692     dc.DrawLine(x1, y, x2 + 1, y);
 693 }
 694
 695 void
 696 wxMonoRenderer::DrawVerticalLine(wxDC& dc, wxCoord x, wxCoord y1, wxCoord y2)
 697 {
 698     dc.SetPen(m_penFg);
 699     dc.DrawLine(x, y1, x, y2 + 1);
 700 }
 701
 702 // ----------------------------------------------------------------------------
 703 // label
 704 // ----------------------------------------------------------------------------
 705
 706 void wxMonoRenderer::DrawButtonLabel(wxDC& dc,
 707                                      const wxString& label,
 708                                      const wxBitmap& image,
 709                                      const wxRect& rect,
 710                                      int flags,
 711                                      int alignment,
 712                                      int indexAccel,
 713                                      wxRect *rectBounds)
 714 {
 715     dc.SetTextForeground(m_penFg.GetColour());
 716     dc.DrawLabel(label, image, rect, alignment, indexAccel, rectBounds);
 717
 718     if ( flags & wxCONTROL_DISABLED )
 719     {
 720         // this is ugly but I don't know how to show disabled button visually
 721         // in monochrome theme otherwise, so cross it out
 722         dc.SetPen(m_penFg);
 723         dc.DrawLine(rect.GetTopLeft(), rect.GetBottomRight());
 724         dc.DrawLine(rect.GetTopRight(), rect.GetBottomLeft());
 725     }
 726 }
 727
 728 // ----------------------------------------------------------------------------
 729 // bitmaps
 730 // ----------------------------------------------------------------------------
 731
 732 wxBitmap wxMonoRenderer::GetIndicator(IndicatorType indType, int flags)
 733 {
 734     IndicatorState indState;
 735     IndicatorStatus indStatus;
 736     GetIndicatorsFromFlags(flags, indState, indStatus);
 737
 738     wxBitmap& bmp = m_bmpIndicators[indType][indState][indStatus];
 739     if ( !bmp.Ok() )
 740     {
 741         const char **xpm = ms_xpmIndicators[indType][indState][indStatus];
 742         if ( xpm )
 743         {
 744             // create and cache it
 745             bmp = wxBitmap(xpm);
 746         }
 747     }
 748
 749     return bmp;
 750 }
 751
 752 wxBitmap wxMonoRenderer::GetFrameButtonBitmap(FrameButtonType type)
 753 {
 754     if ( type == FrameButton_Close )
 755     {
 756         if ( !m_bmpFrameClose.Ok() )
 757         {
 758             static const char *xpmFrameClose[] = {
 759             /* columns rows colors chars-per-pixel */
 760             "8 8 2 1",
 761             "  c white",
 762             "X c black",
 763             /* pixels */
 764             "        ",
 765             " XX  XX ",
 766             "  X  X  ",
 767             "   XX   ",
 768             "   XX   ",
 769             "  X  X  ",
 770             " XX  XX ",
 771             "        ",
 772             };
 773
 774             m_bmpFrameClose = wxBitmap(xpmFrameClose);
 775         }
 776
 777         return m_bmpFrameClose;
 778     }
 779
 780     // we don't show any other buttons than close
 781     return wxNullBitmap;
 782 }
 783
 784 // ----------------------------------------------------------------------------
 785 // toolbar
 786 // ----------------------------------------------------------------------------
 787
 788 #if wxUSE_TOOLBAR
 789
 790 void wxMonoRenderer::DrawToolBarButton(wxDC& dc,
 791                                        const wxString& label,
 792                                        const wxBitmap& bitmap,
 793                                        const wxRect& rect,
 794                                        int flags,
 795                                        long style,
 796                                        int tbarStyle)
 797 {
 798     wxFAIL_MSG(_T("TODO"));
 799 }
 800
 801 wxSize wxMonoRenderer::GetToolBarButtonSize(wxCoord *separator) const
 802 {
 803     wxFAIL_MSG(_T("TODO"));
 804
 805     return wxSize();
 806 }
 807
 808 wxSize wxMonoRenderer::GetToolBarMargin() const
 809 {
 810     wxFAIL_MSG(_T("TODO"));
 811
 812     return wxSize();
 813 }
 814
 815 #endif // wxUSE_TOOLBAR
 816
 817 // ----------------------------------------------------------------------------
 818 // notebook
 819 // ----------------------------------------------------------------------------
 820
 821 #if wxUSE_NOTEBOOK
 822
 823 void wxMonoRenderer::DrawTab(wxDC& dc,
 824                              const wxRect& rect,
 825                              wxDirection dir,
 826                              const wxString& label,
 827                              const wxBitmap& bitmap,
 828                              int flags,
 829                              int indexAccel)
 830 {
 831     wxFAIL_MSG(_T("TODO"));
 832 }
 833
 834 wxSize wxMonoRenderer::GetTabIndent() const
 835 {
 836     wxFAIL_MSG(_T("TODO"));
 837
 838     return wxSize();
 839 }
 840
 841 wxSize wxMonoRenderer::GetTabPadding() const
 842 {
 843     wxFAIL_MSG(_T("TODO"));
 844
 845     return wxSize();
 846 }
 847
 848 #endif // wxUSE_NOTEBOOK
 849
 850 // ----------------------------------------------------------------------------
 851 // combobox
 852 // ----------------------------------------------------------------------------
 853
 854 #if wxUSE_COMBOBOX
 855
 856 void wxMonoRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
 857                                      wxBitmap *bmpFocus,
 858                                      wxBitmap *bmpPressed,
 859                                      wxBitmap *bmpDisabled)
 860 {
 861     wxFAIL_MSG(_T("TODO"));
 862 }
 863
 864 #endif // wxUSE_COMBOBOX
 865
 866 // ----------------------------------------------------------------------------
 867 // menus
 868 // ----------------------------------------------------------------------------
 869
 870 #if wxUSE_MENUS
 871
 872 void wxMonoRenderer::DrawMenuBarItem(wxDC& dc,
 873                                      const wxRect& rect,
 874                                      const wxString& label,
 875                                      int flags,
 876                                      int indexAccel)
 877 {
 878     wxFAIL_MSG(_T("TODO"));
 879 }
 880
 881 void wxMonoRenderer::DrawMenuItem(wxDC& dc,
 882                                   wxCoord y,
 883                                   const wxMenuGeometryInfo& geometryInfo,
 884                                   const wxString& label,
 885                                   const wxString& accel,
 886                                   const wxBitmap& bitmap,
 887                                   int flags,
 888                                   int indexAccel)
 889 {
 890     wxFAIL_MSG(_T("TODO"));
 891 }
 892
 893 void wxMonoRenderer::DrawMenuSeparator(wxDC& dc,
 894                                        wxCoord y,
 895                                        const wxMenuGeometryInfo& geomInfo)
 896 {
 897     wxFAIL_MSG(_T("TODO"));
 898 }
 899
 900 wxSize wxMonoRenderer::GetMenuBarItemSize(const wxSize& sizeText) const
 901 {
 902     wxFAIL_MSG(_T("TODO"));
 903
 904     return wxSize();
 905 }
 906
 907 wxMenuGeometryInfo *wxMonoRenderer::GetMenuGeometry(wxWindow *win,
 908                                                     const wxMenu& menu) const
 909 {
 910     wxFAIL_MSG(_T("TODO"));
 911
 912     return NULL;
 913 }
 914
 915 #endif // wxUSE_MENUS
 916
 917 // ----------------------------------------------------------------------------
 918 // slider
 919 // ----------------------------------------------------------------------------
 920
 921 #if wxUSE_SLIDER
 922
 923 void wxMonoRenderer::DrawSliderShaft(wxDC& dc,
 924                                      const wxRect& rect,
 925                                      int lenThumb,
 926                                      wxOrientation orient,
 927                                      int flags,
 928                                      long style,
 929                                      wxRect *rectShaft)
 930 {
 931     wxFAIL_MSG(_T("TODO"));
 932 }
 933
 934
 935 void wxMonoRenderer::DrawSliderThumb(wxDC& dc,
 936                                      const wxRect& rect,
 937                                      wxOrientation orient,
 938                                      int flags,
 939                                      long style)
 940 {
 941     wxFAIL_MSG(_T("TODO"));
 942 }
 943
 944 void wxMonoRenderer::DrawSliderTicks(wxDC& dc,
 945                                      const wxRect& rect,
 946                                      int lenThumb,
 947                                      wxOrientation orient,
 948                                      int start,
 949                                      int end,
 950                                      int step,
 951                                      int flags,
 952                                      long style)
 953 {
 954     wxFAIL_MSG(_T("TODO"));
 955 }
 956
 957 wxCoord wxMonoRenderer::GetSliderDim() const
 958 {
 959     wxFAIL_MSG(_T("TODO"));
 960
 961     return 0;
 962 }
 963
 964 wxCoord wxMonoRenderer::GetSliderTickLen() const
 965 {
 966     wxFAIL_MSG(_T("TODO"));
 967
 968     return 0;
 969 }
 970
 971
 972 wxRect wxMonoRenderer::GetSliderShaftRect(const wxRect& rect,
 973                                           int lenThumb,
 974                                           wxOrientation orient,
 975                                           long style) const
 976 {
 977     wxFAIL_MSG(_T("TODO"));
 978
 979     return wxRect();
 980 }
 981
 982 wxSize wxMonoRenderer::GetSliderThumbSize(const wxRect& rect,
 983                                           int lenThumb,
 984                                           wxOrientation orient) const
 985 {
 986     wxFAIL_MSG(_T("TODO"));
 987
 988     return wxSize();
 989 }
 990
 991 #endif // wxUSE_SLIDER
 992
 993 wxSize wxMonoRenderer::GetProgressBarStep() const
 994 {
 995     wxFAIL_MSG(_T("TODO"));
 996
 997     return wxSize();
 998 }
 999
1000
1001 // ----------------------------------------------------------------------------
1002 // scrollbar
1003 // ----------------------------------------------------------------------------
1004
1005 void wxMonoRenderer::DrawArrow(wxDC& dc,
1006                                wxDirection dir,
1007                                const wxRect& rect,
1008                                int WXUNUSED(flags))
1009 {
1010     ArrowDirection arrowDir = GetArrowDirection(dir);
1011     wxCHECK_RET( arrowDir != Arrow_Max, _T("invalid arrow direction") );
1012
1013     wxBitmap& bmp = m_bmpArrows[arrowDir];
1014     if ( !bmp.Ok() )
1015     {
1016         bmp = wxBitmap(ms_xpmArrows[arrowDir]);
1017     }
1018
1019     wxRect rectArrow(0, 0, bmp.GetWidth(), bmp.GetHeight());
1020     dc.DrawBitmap(bmp, rectArrow.CentreIn(rect).GetPosition(), true /* use mask */);
1021 }
1022
1023 void wxMonoRenderer::DrawScrollbarThumb(wxDC& dc,
1024                                         wxOrientation WXUNUSED(orient),
1025                                         const wxRect& rect,
1026                                         int WXUNUSED(flags))
1027 {
1028     DrawSolidRect(dc, wxMONO_FG_COL, rect);
1029 }
1030
1031 void wxMonoRenderer::DrawScrollbarShaft(wxDC& dc,
1032                                         wxOrientation WXUNUSED(orient),
1033                                         const wxRect& rect,
1034                                         int WXUNUSED(flags))
1035 {
1036     DrawSolidRect(dc, wxMONO_BG_COL, rect);
1037 }
1038
1039 // ----------------------------------------------------------------------------
1040 // status bar
1041 // ----------------------------------------------------------------------------
1042
1043 #if wxUSE_STATUSBAR
1044
1045 wxCoord wxMonoRenderer::GetStatusBarBorderBetweenFields() const
1046 {
1047     return 1;
1048 }
1049
1050 wxSize wxMonoRenderer::GetStatusBarFieldMargins() const
1051 {
1052     return wxSize(1, 1);
1053 }
1054
1055 #endif // wxUSE_STATUSBAR
1056
1057 // ----------------------------------------------------------------------------
1058 // top level windows
1059 // ----------------------------------------------------------------------------
1060
1061 int wxMonoRenderer::GetFrameBorderWidth(int WXUNUSED(flags)) const
1062 {
1063     // all our borders are simple
1064     return 1;
1065 }
1066
1067 // ----------------------------------------------------------------------------
1068 // wxMonoArtProvider
1069 // ----------------------------------------------------------------------------
1070
1071 wxBitmap wxMonoArtProvider::CreateBitmap(const wxArtID& WXUNUSED(id),
1072                                          const wxArtClient& WXUNUSED(client),
1073                                          const wxSize& WXUNUSED(size))
1074 {
1075     return wxNullBitmap;
1076 }
1077
1078 #endif // wxUSE_THEME_MONO