include/wx/univ/renderer.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/univ/renderer.h
   3 // Purpose:     wxRenderer class declaration
   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 #ifndef _WX_UNIV_RENDERER_H_
  13 #define _WX_UNIV_RENDERER_H_
  14
  15 /*
  16    wxRenderer class is used to draw all wxWidgets controls. This is an ABC and
  17    the look of the application is determined by the concrete derivation of
  18    wxRenderer used in the program.
  19
  20    It also contains a few static methods which may be used by the concrete
  21    renderers and provide the functionality which is often similar or identical
  22    in all renderers (using inheritance here would be more restrictive as the
  23    given concrete renderer may need an arbitrary subset of the base class
  24    methods).
  25
  26    Finally note that wxRenderer supersedes wxRendererNative in wxUniv build and
  27    includes the latters functionality (which it may delegate to the generic
  28    implementation of the latter or reimplement itself).
  29  */
  30
  31 #include "wx/renderer.h"
  32
  33 class WXDLLEXPORT wxWindow;
  34 class WXDLLEXPORT wxDC;
  35 class WXDLLEXPORT wxCheckListBox;
  36
  37 #if wxUSE_LISTBOX
  38     class WXDLLEXPORT wxListBox;
  39 #endif // wxUSE_LISTBOX
  40
  41 #if wxUSE_MENUS
  42    class WXDLLEXPORT wxMenu;
  43    class WXDLLEXPORT wxMenuGeometryInfo;
  44 #endif // wxUSE_MENUS
  45
  46 class WXDLLEXPORT wxScrollBar;
  47
  48 #if wxUSE_TEXTCTRL
  49     class WXDLLEXPORT wxTextCtrl;
  50 #endif
  51
  52 #if wxUSE_GAUGE
  53     class WXDLLEXPORT wxGauge;
  54 #endif // wxUSE_GAUGE
  55
  56 #include "wx/string.h"
  57 #include "wx/gdicmn.h"
  58 #include "wx/icon.h"
  59 #include "wx/scrolbar.h"            // for wxScrollBar::Element
  60
  61 // helper class used by wxMenu-related functions
  62 class WXDLLEXPORT wxMenuGeometryInfo
  63 {
  64 public:
  65     // get the total size of the menu
  66     virtual wxSize GetSize() const = 0;
  67
  68     virtual ~wxMenuGeometryInfo();
  69 };
  70
  71 // ----------------------------------------------------------------------------
  72 // wxRenderer: abstract renderers interface
  73 // ----------------------------------------------------------------------------
  74
  75 class WXDLLEXPORT wxRenderer : public wxDelegateRendererNative
  76 {
  77 public:
  78     // drawing functions
  79     // -----------------
  80
  81     // draw the controls background
  82     virtual void DrawBackground(wxDC& dc,
  83                                 const wxColour& col,
  84                                 const wxRect& rect,
  85                                 int flags,
  86                                 wxWindow *window = NULL) = 0;
  87
  88     // draw the button surface
  89     virtual void DrawButtonSurface(wxDC& dc,
  90                                    const wxColour& col,
  91                                    const wxRect& rect,
  92                                    int flags) = 0;
  93
  94
  95     // draw the focus rectangle around the label contained in the given rect
  96     virtual void DrawFocusRect(wxDC& dc, const wxRect& rect) = 0;
  97
  98     // draw the label inside the given rectangle with the specified alignment
  99     // and optionally emphasize the character with the given index
 100     virtual void DrawLabel(wxDC& dc,
 101                            const wxString& label,
 102                            const wxRect& rect,
 103                            int flags = 0,
 104                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 105                            int indexAccel = -1,
 106                            wxRect *rectBounds = NULL) = 0;
 107
 108     // same but also draw a bitmap if it is valid
 109     virtual void DrawButtonLabel(wxDC& dc,
 110                                  const wxString& label,
 111                                  const wxBitmap& image,
 112                                  const wxRect& rect,
 113                                  int flags = 0,
 114                                  int alignment = wxALIGN_LEFT | wxALIGN_TOP,
 115                                  int indexAccel = -1,
 116                                  wxRect *rectBounds = NULL) = 0;
 117
 118
 119     // draw the border and optionally return the rectangle containing the
 120     // region inside the border
 121     virtual void DrawBorder(wxDC& dc,
 122                             wxBorder border,
 123                             const wxRect& rect,
 124                             int flags = 0,
 125                             wxRect *rectIn = (wxRect *)NULL) = 0;
 126
 127     // draw text control border (I hate to have a separate method for this but
 128     // it is needed to accommodate GTK+)
 129     virtual void DrawTextBorder(wxDC& dc,
 130                                 wxBorder border,
 131                                 const wxRect& rect,
 132                                 int flags = 0,
 133                                 wxRect *rectIn = (wxRect *)NULL) = 0;
 134
 135     // draw push button border and return the rectangle left for the label
 136     virtual void DrawButtonBorder(wxDC& dc,
 137                                   const wxRect& rect,
 138                                   int flags = 0,
 139                                   wxRect *rectIn = (wxRect *)NULL) = 0;
 140
 141     // draw a horizontal line
 142     virtual void DrawHorizontalLine(wxDC& dc,
 143                                     wxCoord y, wxCoord x1, wxCoord x2) = 0;
 144
 145     // draw a vertical line
 146     virtual void DrawVerticalLine(wxDC& dc,
 147                                   wxCoord x, wxCoord y1, wxCoord y2) = 0;
 148
 149     // draw a frame with the label (horizontal alignment can be specified)
 150     virtual void DrawFrame(wxDC& dc,
 151                            const wxString& label,
 152                            const wxRect& rect,
 153                            int flags = 0,
 154                            int alignment = wxALIGN_LEFT,
 155                            int indexAccel = -1) = 0;
 156
 157     // draw an arrow in the given direction
 158     virtual void DrawArrow(wxDC& dc,
 159                            wxDirection dir,
 160                            const wxRect& rect,
 161                            int flags = 0) = 0;
 162
 163     // draw a scrollbar arrow (may be the same as arrow but may be not)
 164     virtual void DrawScrollbarArrow(wxDC& dc,
 165                                     wxDirection dir,
 166                                     const wxRect& rect,
 167                                     int flags = 0) = 0;
 168
 169     // draw the scrollbar thumb
 170     virtual void DrawScrollbarThumb(wxDC& dc,
 171                                     wxOrientation orient,
 172                                     const wxRect& rect,
 173                                     int flags = 0) = 0;
 174
 175     // draw a (part of) scrollbar shaft
 176     virtual void DrawScrollbarShaft(wxDC& dc,
 177                                     wxOrientation orient,
 178                                     const wxRect& rect,
 179                                     int flags = 0) = 0;
 180
 181     // draw the rectangle in the corner between two scrollbars
 182     virtual void DrawScrollCorner(wxDC& dc,
 183                                   const wxRect& rect) = 0;
 184
 185     // draw an item of a wxListBox
 186     virtual void DrawItem(wxDC& dc,
 187                           const wxString& label,
 188                           const wxRect& rect,
 189                           int flags = 0) = 0;
 190
 191     // draw an item of a wxCheckListBox
 192     virtual void DrawCheckItem(wxDC& dc,
 193                                const wxString& label,
 194                                const wxBitmap& bitmap,
 195                                const wxRect& rect,
 196                                int flags = 0) = 0;
 197
 198     // draw a checkbutton (bitmap may be invalid to use default one)
 199     virtual void DrawCheckButton(wxDC& dc,
 200                                  const wxString& label,
 201                                  const wxBitmap& bitmap,
 202                                  const wxRect& rect,
 203                                  int flags = 0,
 204                                  wxAlignment align = wxALIGN_LEFT,
 205                                  int indexAccel = -1) = 0;
 206
 207     // draw a radio button
 208     virtual void DrawRadioButton(wxDC& dc,
 209                                  const wxString& label,
 210                                  const wxBitmap& bitmap,
 211                                  const wxRect& rect,
 212                                  int flags = 0,
 213                                  wxAlignment align = wxALIGN_LEFT,
 214                                  int indexAccel = -1) = 0;
 215
 216 #if wxUSE_TOOLBAR
 217     // draw a toolbar button (label may be empty, bitmap may be invalid, if
 218     // both conditions are true this function draws a separator)
 219     virtual void DrawToolBarButton(wxDC& dc,
 220                                    const wxString& label,
 221                                    const wxBitmap& bitmap,
 222                                    const wxRect& rect,
 223                                    int flags = 0,
 224                                    long style = 0,
 225                                    int tbarStyle = 0) = 0;
 226 #endif // wxUSE_TOOLBAR
 227
 228 #if wxUSE_TEXTCTRL
 229     // draw a (part of) line in the text control
 230     virtual void DrawTextLine(wxDC& dc,
 231                               const wxString& text,
 232                               const wxRect& rect,
 233                               int selStart = -1,
 234                               int selEnd = -1,
 235                               int flags = 0) = 0;
 236
 237     // draw a line wrap indicator
 238     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect) = 0;
 239 #endif // wxUSE_TEXTCTRL
 240
 241 #if wxUSE_NOTEBOOK
 242     // draw a notebook tab
 243     virtual void DrawTab(wxDC& dc,
 244                          const wxRect& rect,
 245                          wxDirection dir,
 246                          const wxString& label,
 247                          const wxBitmap& bitmap = wxNullBitmap,
 248                          int flags = 0,
 249                          int indexAccel = -1) = 0;
 250 #endif // wxUSE_NOTEBOOK
 251
 252 #if wxUSE_SLIDER
 253
 254     // draw the slider shaft
 255     virtual void DrawSliderShaft(wxDC& dc,
 256                                  const wxRect& rect,
 257                                  int lenThumb,
 258                                  wxOrientation orient,
 259                                  int flags = 0,
 260                                  long style = 0,
 261                                  wxRect *rectShaft = NULL) = 0;
 262
 263     // draw the slider thumb
 264     virtual void DrawSliderThumb(wxDC& dc,
 265                                  const wxRect& rect,
 266                                  wxOrientation orient,
 267                                  int flags = 0,
 268                                  long style = 0) = 0;
 269
 270     // draw the slider ticks
 271     virtual void DrawSliderTicks(wxDC& dc,
 272                                  const wxRect& rect,
 273                                  int lenThumb,
 274                                  wxOrientation orient,
 275                                  int start,
 276                                  int end,
 277                                  int step = 1,
 278                                  int flags = 0,
 279                                  long style = 0) = 0;
 280 #endif // wxUSE_SLIDER
 281
 282 #if wxUSE_MENUS
 283     // draw a menu bar item
 284     virtual void DrawMenuBarItem(wxDC& dc,
 285                                  const wxRect& rect,
 286                                  const wxString& label,
 287                                  int flags = 0,
 288                                  int indexAccel = -1) = 0;
 289
 290     // draw a menu item (also used for submenus if flags has ISSUBMENU flag)
 291     //
 292     // the geometryInfo is calculated by GetMenuGeometry() function from below
 293     virtual void DrawMenuItem(wxDC& dc,
 294                               wxCoord y,
 295                               const wxMenuGeometryInfo& geometryInfo,
 296                               const wxString& label,
 297                               const wxString& accel,
 298                               const wxBitmap& bitmap = wxNullBitmap,
 299                               int flags = 0,
 300                               int indexAccel = -1) = 0;
 301
 302     // draw a menu bar separator
 303     virtual void DrawMenuSeparator(wxDC& dc,
 304                                    wxCoord y,
 305                                    const wxMenuGeometryInfo& geomInfo) = 0;
 306 #endif // wxUSE_MENUS
 307
 308 #if wxUSE_STATUSBAR
 309     // draw a status bar field: wxCONTROL_ISDEFAULT bit in the flags is
 310     // interpreted specially and means "draw the status bar grip" here
 311     virtual void DrawStatusField(wxDC& dc,
 312                                  const wxRect& rect,
 313                                  const wxString& label,
 314                                  int flags = 0, int style = 0) = 0;
 315 #endif // wxUSE_STATUSBAR
 316
 317     // draw complete frame/dialog titlebar
 318     virtual void DrawFrameTitleBar(wxDC& dc,
 319                                    const wxRect& rect,
 320                                    const wxString& title,
 321                                    const wxIcon& icon,
 322                                    int flags,
 323                                    int specialButton = 0,
 324                                    int specialButtonFlags = 0) = 0;
 325
 326     // draw frame borders
 327     virtual void DrawFrameBorder(wxDC& dc,
 328                                  const wxRect& rect,
 329                                  int flags) = 0;
 330
 331     // draw frame titlebar background
 332     virtual void DrawFrameBackground(wxDC& dc,
 333                                      const wxRect& rect,
 334                                      int flags) = 0;
 335
 336     // draw frame title
 337     virtual void DrawFrameTitle(wxDC& dc,
 338                                 const wxRect& rect,
 339                                 const wxString& title,
 340                                 int flags) = 0;
 341
 342     // draw frame icon
 343     virtual void DrawFrameIcon(wxDC& dc,
 344                                const wxRect& rect,
 345                                const wxIcon& icon,
 346                                int flags) = 0;
 347
 348     // draw frame buttons
 349     virtual void DrawFrameButton(wxDC& dc,
 350                                  wxCoord x, wxCoord y,
 351                                  int button,
 352                                  int flags = 0) = 0;
 353
 354     // misc functions
 355     // --------------
 356
 357 #if wxUSE_COMBOBOX
 358     // return the bitmaps to use for combobox button
 359     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
 360                                  wxBitmap *bmpFocus,
 361                                  wxBitmap *bmpPressed,
 362                                  wxBitmap *bmpDisabled) = 0;
 363 #endif // wxUSE_COMBOBOX
 364
 365     // geometry functions
 366     // ------------------
 367
 368     // get the dimensions of the border: rect.x/y contain the width/height of
 369     // the left/top side, width/heigh - of the right/bottom one
 370     virtual wxRect GetBorderDimensions(wxBorder border) const = 0;
 371
 372     // the scrollbars may be drawn either inside the window border or outside
 373     // it - this function is used to decide how to draw them
 374     virtual bool AreScrollbarsInsideBorder() const = 0;
 375
 376     // adjust the size of the control of the given class: for most controls,
 377     // this just takes into account the border, but for some (buttons, for
 378     // example) it is more complicated - the result being, in any case, that
 379     // the control looks "nice" if it uses the adjusted rectangle
 380     virtual void AdjustSize(wxSize *size, const wxWindow *window) = 0;
 381
 382 #if wxUSE_SCROLLBAR
 383
 384     // get the size of a scrollbar arrow
 385     virtual wxSize GetScrollbarArrowSize() const = 0;
 386
 387     // gets the bounding box for a scrollbar element for the given (by default
 388     // - current) thumb position
 389     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
 390                                     wxScrollBar::Element elem,
 391                                     int thumbPos = -1) const = 0;
 392
 393     // returns the size of the scrollbar shaft excluding the arrows
 394     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar) = 0;
 395
 396     // returns one of wxHT_SCROLLBAR_XXX constants
 397     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
 398                                        const wxPoint& pt) const = 0;
 399
 400     // translate the scrollbar position (in logical units) into physical
 401     // coordinate (in pixels) and the other way round
 402     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
 403                                      int thumbPos = -1) = 0;
 404     virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
 405                                  wxCoord coord) = 0;
 406
 407 #endif // wxUSE_SCROLLBAR
 408
 409     // get the height of a listbox item from the base font height
 410     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight) = 0;
 411
 412     // get the size of a checkbox/radio button bitmap
 413     virtual wxSize GetCheckBitmapSize() const = 0;
 414     virtual wxSize GetRadioBitmapSize() const = 0;
 415     virtual wxCoord GetCheckItemMargin() const = 0;
 416
 417 #if wxUSE_TOOLBAR
 418     // get the standard size of a toolbar button and also return the size of
 419     // a toolbar separator in the provided pointer
 420     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const = 0;
 421
 422     // get the margins between/around the toolbar buttons
 423     virtual wxSize GetToolBarMargin() const = 0;
 424 #endif // wxUSE_TOOLBAR
 425
 426 #if wxUSE_TEXTCTRL
 427     // convert between text rectangle and client rectangle for text controls:
 428     // the former is typicall smaller to leave margins around text
 429     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
 430                                     const wxRect& rectText) const = 0;
 431
 432     // extra space is for line indicators
 433     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
 434                                      const wxRect& rectTotal,
 435                                      wxCoord *extraSpaceBeyond) const = 0;
 436 #endif // wxUSE_TEXTCTRL
 437
 438 #if wxUSE_NOTEBOOK
 439     // get the overhang of a selected tab
 440     virtual wxSize GetTabIndent() const = 0;
 441
 442     // get the padding around the text in a tab
 443     virtual wxSize GetTabPadding() const = 0;
 444 #endif // wxUSE_NOTEBOOK
 445
 446 #if wxUSE_SLIDER
 447     // get the default size of the slider in lesser dimension (i.e. height of a
 448     // horizontal slider or width of a vertical one)
 449     virtual wxCoord GetSliderDim() const = 0;
 450
 451     // get the length of the slider ticks displayed along side slider
 452     virtual wxCoord GetSliderTickLen() const = 0;
 453
 454     // get the slider shaft rect from the total slider rect
 455     virtual wxRect GetSliderShaftRect(const wxRect& rect,
 456                                       int lenThumb,
 457                                       wxOrientation orient,
 458                                       long style = 0) const = 0;
 459
 460     // get the size of the slider thumb for the given total slider rect
 461     virtual wxSize GetSliderThumbSize(const wxRect& rect,
 462                                       int lenThumb,
 463                                       wxOrientation orient) const = 0;
 464 #endif // wxUSE_SLIDER
 465
 466     // get the size of one progress bar step (in horz and vertical directions)
 467     virtual wxSize GetProgressBarStep() const = 0;
 468
 469 #if wxUSE_MENUS
 470     // get the size of rectangle to use in the menubar for the given text rect
 471     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const = 0;
 472
 473     // get the struct storing all layout info needed to draw all menu items
 474     // (this can't be calculated for each item separately as they should be
 475     // aligned)
 476     //
 477     // the returned pointer must be deleted by the caller
 478     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
 479                                                 const wxMenu& menu) const = 0;
 480 #endif // wxUSE_MENUS
 481
 482 #if wxUSE_STATUSBAR
 483     // get the borders around the status bar fields (x and y fields of the
 484     // return value) and also, optionally, the border between the fields
 485     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const = 0;
 486 #endif // wxUSE_STATUSBAR
 487
 488     // get client area rectangle of top level window (i.e. subtract
 489     // decorations from given rectangle)
 490     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const = 0;
 491
 492     // get size of whole top level window, given size of its client area size
 493     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const = 0;
 494
 495     // get the minimal size of top level window
 496     virtual wxSize GetFrameMinSize(int flags) const = 0;
 497
 498     // get titlebar icon size
 499     virtual wxSize GetFrameIconSize() const = 0;
 500
 501     // returns one of wxHT_TOPLEVEL_XXX constants
 502     virtual int HitTestFrame(const wxRect& rect,
 503                              const wxPoint& pt,
 504                              int flags = 0) const = 0;
 505
 506     // virtual dtor for any base class
 507     virtual ~wxRenderer();
 508 };
 509
 510 // ----------------------------------------------------------------------------
 511 // wxDelegateRenderer: it is impossible to inherit from any of standard
 512 // renderers as their declarations are in private code, but you can use this
 513 // class to override only some of the Draw() functions - all the other ones
 514 // will be left to the original renderer
 515 // ----------------------------------------------------------------------------
 516
 517 class WXDLLEXPORT wxDelegateRenderer : public wxRenderer
 518 {
 519 public:
 520     wxDelegateRenderer(wxRenderer *renderer) : m_renderer(renderer) { }
 521
 522     virtual void DrawBackground(wxDC& dc,
 523                                 const wxColour& col,
 524                                 const wxRect& rect,
 525                                 int flags,
 526                                 wxWindow *window = NULL )
 527         { m_renderer->DrawBackground(dc, col, rect, flags, window ); }
 528     virtual void DrawButtonSurface(wxDC& dc,
 529                                    const wxColour& col,
 530                                    const wxRect& rect,
 531                                    int flags)
 532         { m_renderer->DrawButtonSurface(dc, col, rect, flags); }
 533     virtual void DrawFocusRect(wxDC& dc, const wxRect& rect)
 534         { m_renderer->DrawFocusRect(dc, rect); }
 535     virtual void DrawLabel(wxDC& dc,
 536                            const wxString& label,
 537                            const wxRect& rect,
 538                            int flags = 0,
 539                            int align = wxALIGN_LEFT | wxALIGN_TOP,
 540                            int indexAccel = -1,
 541                            wxRect *rectBounds = NULL)
 542         { m_renderer->DrawLabel(dc, label, rect,
 543                                 flags, align, indexAccel, rectBounds); }
 544     virtual void DrawButtonLabel(wxDC& dc,
 545                                  const wxString& label,
 546                                  const wxBitmap& image,
 547                                  const wxRect& rect,
 548                                  int flags = 0,
 549                                  int align = wxALIGN_LEFT | wxALIGN_TOP,
 550                                  int indexAccel = -1,
 551                                  wxRect *rectBounds = NULL)
 552         { m_renderer->DrawButtonLabel(dc, label, image, rect,
 553                                       flags, align, indexAccel, rectBounds); }
 554     virtual void DrawBorder(wxDC& dc,
 555                             wxBorder border,
 556                             const wxRect& rect,
 557                             int flags = 0,
 558                             wxRect *rectIn = (wxRect *)NULL)
 559         { m_renderer->DrawBorder(dc, border, rect, flags, rectIn); }
 560     virtual void DrawTextBorder(wxDC& dc,
 561                                 wxBorder border,
 562                                 const wxRect& rect,
 563                                 int flags = 0,
 564                                 wxRect *rectIn = (wxRect *)NULL)
 565         { m_renderer->DrawTextBorder(dc, border, rect, flags, rectIn); }
 566     virtual void DrawButtonBorder(wxDC& dc,
 567                                   const wxRect& rect,
 568                                   int flags = 0,
 569                                   wxRect *rectIn = (wxRect *)NULL)
 570         { m_renderer->DrawButtonBorder(dc, rect, flags, rectIn); }
 571     virtual void DrawFrame(wxDC& dc,
 572                            const wxString& label,
 573                            const wxRect& rect,
 574                            int flags = 0,
 575                            int align = wxALIGN_LEFT,
 576                            int indexAccel = -1)
 577         { m_renderer->DrawFrame(dc, label, rect, flags, align, indexAccel); }
 578     virtual void DrawHorizontalLine(wxDC& dc,
 579                                     wxCoord y, wxCoord x1, wxCoord x2)
 580         { m_renderer->DrawHorizontalLine(dc, y, x1, x2); }
 581     virtual void DrawVerticalLine(wxDC& dc,
 582                                   wxCoord x, wxCoord y1, wxCoord y2)
 583         { m_renderer->DrawVerticalLine(dc, x, y1, y2); }
 584     virtual void DrawArrow(wxDC& dc,
 585                            wxDirection dir,
 586                            const wxRect& rect,
 587                            int flags = 0)
 588         { m_renderer->DrawArrow(dc, dir, rect, flags); }
 589     virtual void DrawScrollbarArrow(wxDC& dc,
 590                            wxDirection dir,
 591                            const wxRect& rect,
 592                            int flags = 0)
 593         { m_renderer->DrawScrollbarArrow(dc, dir, rect, flags); }
 594     virtual void DrawScrollbarThumb(wxDC& dc,
 595                                     wxOrientation orient,
 596                                     const wxRect& rect,
 597                                     int flags = 0)
 598         { m_renderer->DrawScrollbarThumb(dc, orient, rect, flags); }
 599     virtual void DrawScrollbarShaft(wxDC& dc,
 600                                     wxOrientation orient,
 601                                     const wxRect& rect,
 602                                     int flags = 0)
 603         { m_renderer->DrawScrollbarShaft(dc, orient, rect, flags); }
 604     virtual void DrawScrollCorner(wxDC& dc,
 605                                   const wxRect& rect)
 606         { m_renderer->DrawScrollCorner(dc, rect); }
 607     virtual void DrawItem(wxDC& dc,
 608                           const wxString& label,
 609                           const wxRect& rect,
 610                           int flags = 0)
 611         { m_renderer->DrawItem(dc, label, rect, flags); }
 612     virtual void DrawCheckItem(wxDC& dc,
 613                                const wxString& label,
 614                                const wxBitmap& bitmap,
 615                                const wxRect& rect,
 616                                int flags = 0)
 617         { m_renderer->DrawCheckItem(dc, label, bitmap, rect, flags); }
 618     virtual void DrawCheckButton(wxDC& dc,
 619                                  const wxString& label,
 620                                  const wxBitmap& bitmap,
 621                                  const wxRect& rect,
 622                                  int flags = 0,
 623                                  wxAlignment align = wxALIGN_LEFT,
 624                                  int indexAccel = -1)
 625         { m_renderer->DrawCheckButton(dc, label, bitmap, rect,
 626                                       flags, align, indexAccel); }
 627     virtual void DrawRadioButton(wxDC& dc,
 628                                  const wxString& label,
 629                                  const wxBitmap& bitmap,
 630                                  const wxRect& rect,
 631                                  int flags = 0,
 632                                  wxAlignment align = wxALIGN_LEFT,
 633                                  int indexAccel = -1)
 634         { m_renderer->DrawRadioButton(dc, label, bitmap, rect,
 635                                       flags, align, indexAccel); }
 636 #if wxUSE_TOOLBAR
 637     virtual void DrawToolBarButton(wxDC& dc,
 638                                    const wxString& label,
 639                                    const wxBitmap& bitmap,
 640                                    const wxRect& rect,
 641                                    int flags = 0,
 642                                    long style = 0,
 643                                    int tbarStyle = 0)
 644         { m_renderer->DrawToolBarButton(dc, label, bitmap, rect, flags, style, tbarStyle); }
 645 #endif // wxUSE_TOOLBAR
 646
 647 #if wxUSE_TEXTCTRL
 648     virtual void DrawTextLine(wxDC& dc,
 649                               const wxString& text,
 650                               const wxRect& rect,
 651                               int selStart = -1,
 652                               int selEnd = -1,
 653                               int flags = 0)
 654         { m_renderer->DrawTextLine(dc, text, rect, selStart, selEnd, flags); }
 655     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect)
 656         { m_renderer->DrawLineWrapMark(dc, rect); }
 657 #endif // wxUSE_TEXTCTRL
 658
 659 #if wxUSE_NOTEBOOK
 660     virtual void DrawTab(wxDC& dc,
 661                          const wxRect& rect,
 662                          wxDirection dir,
 663                          const wxString& label,
 664                          const wxBitmap& bitmap = wxNullBitmap,
 665                          int flags = 0,
 666                          int accel = -1)
 667         { m_renderer->DrawTab(dc, rect, dir, label, bitmap, flags, accel); }
 668 #endif // wxUSE_NOTEBOOK
 669
 670 #if wxUSE_SLIDER
 671
 672     virtual void DrawSliderShaft(wxDC& dc,
 673                                  const wxRect& rect,
 674                                  int lenThumb,
 675                                  wxOrientation orient,
 676                                  int flags = 0,
 677                                  long style = 0,
 678                                  wxRect *rectShaft = NULL)
 679         { m_renderer->DrawSliderShaft(dc, rect, lenThumb, orient, flags, style, rectShaft); }
 680     virtual void DrawSliderThumb(wxDC& dc,
 681                                  const wxRect& rect,
 682                                  wxOrientation orient,
 683                                  int flags = 0,
 684                                  long style = 0)
 685         { m_renderer->DrawSliderThumb(dc, rect, orient, flags, style); }
 686     virtual void DrawSliderTicks(wxDC& dc,
 687                                  const wxRect& rect,
 688                                  int lenThumb,
 689                                  wxOrientation orient,
 690                                  int start,
 691                                  int end,
 692                                  int WXUNUSED(step) = 1,
 693                                  int flags = 0,
 694                                  long style = 0)
 695         { m_renderer->DrawSliderTicks(dc, rect, lenThumb, orient,
 696                                       start, end, start, flags, style); }
 697 #endif // wxUSE_SLIDER
 698
 699 #if wxUSE_MENUS
 700     virtual void DrawMenuBarItem(wxDC& dc,
 701                                  const wxRect& rect,
 702                                  const wxString& label,
 703                                  int flags = 0,
 704                                  int indexAccel = -1)
 705         { m_renderer->DrawMenuBarItem(dc, rect, label, flags, indexAccel); }
 706     virtual void DrawMenuItem(wxDC& dc,
 707                               wxCoord y,
 708                               const wxMenuGeometryInfo& gi,
 709                               const wxString& label,
 710                               const wxString& accel,
 711                               const wxBitmap& bitmap = wxNullBitmap,
 712                               int flags = 0,
 713                               int indexAccel = -1)
 714         { m_renderer->DrawMenuItem(dc, y, gi, label, accel,
 715                                    bitmap, flags, indexAccel); }
 716     virtual void DrawMenuSeparator(wxDC& dc,
 717                                    wxCoord y,
 718                                    const wxMenuGeometryInfo& geomInfo)
 719         { m_renderer->DrawMenuSeparator(dc, y, geomInfo); }
 720 #endif // wxUSE_MENUS
 721
 722 #if wxUSE_STATUSBAR
 723     virtual void DrawStatusField(wxDC& dc,
 724                                  const wxRect& rect,
 725                                  const wxString& label,
 726                                  int flags = 0, int style = 0)
 727         { m_renderer->DrawStatusField(dc, rect, label, flags, style); }
 728 #endif // wxUSE_STATUSBAR
 729
 730     virtual void DrawFrameTitleBar(wxDC& dc,
 731                                    const wxRect& rect,
 732                                    const wxString& title,
 733                                    const wxIcon& icon,
 734                                    int flags,
 735                                    int specialButton = 0,
 736                                    int specialButtonFlag = 0)
 737         { m_renderer->DrawFrameTitleBar(dc, rect, title, icon, flags,
 738                                         specialButton, specialButtonFlag); }
 739     virtual void DrawFrameBorder(wxDC& dc,
 740                                  const wxRect& rect,
 741                                  int flags)
 742         { m_renderer->DrawFrameBorder(dc, rect, flags); }
 743     virtual void DrawFrameBackground(wxDC& dc,
 744                                      const wxRect& rect,
 745                                      int flags)
 746         { m_renderer->DrawFrameBackground(dc, rect, flags); }
 747     virtual void DrawFrameTitle(wxDC& dc,
 748                                 const wxRect& rect,
 749                                 const wxString& title,
 750                                 int flags)
 751         { m_renderer->DrawFrameTitle(dc, rect, title, flags); }
 752     virtual void DrawFrameIcon(wxDC& dc,
 753                                const wxRect& rect,
 754                                const wxIcon& icon,
 755                                int flags)
 756         { m_renderer->DrawFrameIcon(dc, rect, icon, flags); }
 757     virtual void DrawFrameButton(wxDC& dc,
 758                                  wxCoord x, wxCoord y,
 759                                  int button,
 760                                  int flags = 0)
 761         { m_renderer->DrawFrameButton(dc, x, y, button, flags); }
 762
 763 #if wxUSE_COMBOBOX
 764     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
 765                                  wxBitmap *bmpFocus,
 766                                  wxBitmap *bmpPressed,
 767                                  wxBitmap *bmpDisabled)
 768         { m_renderer->GetComboBitmaps(bmpNormal, bmpFocus,
 769                                       bmpPressed, bmpDisabled); }
 770 #endif // wxUSE_COMBOBOX
 771
 772     virtual void AdjustSize(wxSize *size, const wxWindow *window)
 773         { m_renderer->AdjustSize(size, window); }
 774     virtual wxRect GetBorderDimensions(wxBorder border) const
 775         { return m_renderer->GetBorderDimensions(border); }
 776     virtual bool AreScrollbarsInsideBorder() const
 777         { return m_renderer->AreScrollbarsInsideBorder(); }
 778
 779 #if wxUSE_SCROLLBAR
 780     virtual wxSize GetScrollbarArrowSize() const
 781         { return m_renderer->GetScrollbarArrowSize(); }
 782     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
 783                                     wxScrollBar::Element elem,
 784                                     int thumbPos = -1) const
 785         { return m_renderer->GetScrollbarRect(scrollbar, elem, thumbPos); }
 786     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar)
 787         { return m_renderer->GetScrollbarSize(scrollbar); }
 788     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
 789                                        const wxPoint& pt) const
 790         { return m_renderer->HitTestScrollbar(scrollbar, pt); }
 791     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
 792                                      int thumbPos = -1)
 793         { return m_renderer->ScrollbarToPixel(scrollbar, thumbPos); }
 794     virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
 795                                  wxCoord coord)
 796         { return m_renderer->PixelToScrollbar(scrollbar, coord); }
 797 #endif // wxUSE_SCROLLBAR
 798
 799     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
 800         { return m_renderer->GetListboxItemHeight(fontHeight); }
 801     virtual wxSize GetCheckBitmapSize() const
 802         { return m_renderer->GetCheckBitmapSize(); }
 803     virtual wxSize GetRadioBitmapSize() const
 804         { return m_renderer->GetRadioBitmapSize(); }
 805     virtual wxCoord GetCheckItemMargin() const
 806         { return m_renderer->GetCheckItemMargin(); }
 807
 808 #if wxUSE_TOOLBAR
 809     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
 810         { return m_renderer->GetToolBarButtonSize(separator); }
 811     virtual wxSize GetToolBarMargin() const
 812         { return m_renderer->GetToolBarMargin(); }
 813 #endif // wxUSE_TOOLBAR
 814
 815 #if wxUSE_TEXTCTRL
 816     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
 817                                     const wxRect& rect) const
 818         { return m_renderer->GetTextTotalArea(text, rect); }
 819     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
 820                                      const wxRect& rect,
 821                                      wxCoord *extraSpaceBeyond) const
 822         { return m_renderer->GetTextClientArea(text, rect, extraSpaceBeyond); }
 823 #endif // wxUSE_TEXTCTRL
 824
 825 #if wxUSE_NOTEBOOK
 826     virtual wxSize GetTabIndent() const { return m_renderer->GetTabIndent(); }
 827     virtual wxSize GetTabPadding() const { return m_renderer->GetTabPadding(); }
 828 #endif // wxUSE_NOTEBOOK
 829
 830 #if wxUSE_SLIDER
 831     virtual wxCoord GetSliderDim() const
 832         { return m_renderer->GetSliderDim(); }
 833     virtual wxCoord GetSliderTickLen() const
 834         { return m_renderer->GetSliderTickLen(); }
 835
 836     virtual wxRect GetSliderShaftRect(const wxRect& rect,
 837                                       int lenThumb,
 838                                       wxOrientation orient,
 839                                       long style = 0) const
 840         { return m_renderer->GetSliderShaftRect(rect, lenThumb, orient, style); }
 841     virtual wxSize GetSliderThumbSize(const wxRect& rect,
 842                                       int lenThumb,
 843                                       wxOrientation orient) const
 844         { return m_renderer->GetSliderThumbSize(rect, lenThumb, orient); }
 845 #endif // wxUSE_SLIDER
 846
 847     virtual wxSize GetProgressBarStep() const
 848         { return m_renderer->GetProgressBarStep(); }
 849
 850 #if wxUSE_MENUS
 851     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const
 852         { return m_renderer->GetMenuBarItemSize(sizeText); }
 853     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
 854                                                 const wxMenu& menu) const
 855         { return m_renderer->GetMenuGeometry(win, menu); }
 856 #endif // wxUSE_MENUS
 857
 858 #if wxUSE_STATUSBAR
 859     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const
 860         { return m_renderer->GetStatusBarBorders(borderBetweenFields); }
 861 #endif // wxUSE_STATUSBAR
 862     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const
 863         { return m_renderer->GetFrameClientArea(rect, flags); }
 864     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const
 865         { return m_renderer->GetFrameTotalSize(clientSize, flags); }
 866     virtual wxSize GetFrameMinSize(int flags) const
 867         { return m_renderer->GetFrameMinSize(flags); }
 868     virtual wxSize GetFrameIconSize() const
 869         { return m_renderer->GetFrameIconSize(); }
 870     virtual int HitTestFrame(const wxRect& rect,
 871                              const wxPoint& pt,
 872                              int flags) const
 873         { return m_renderer->HitTestFrame(rect, pt, flags); }
 874
 875     virtual void DrawHeaderButton(wxWindow *win,
 876                                   wxDC& dc,
 877                                   const wxRect& rect,
 878                                   int flags = 0,
 879                                   wxHeaderSortIconType sortIcon = wxHDR_SORT_ICON_NONE,
 880                                   wxHeaderButtonParams* params = NULL)
 881         { m_renderer->DrawHeaderButton(win, dc, rect, flags, sortIcon, params); }
 882     virtual void DrawTreeItemButton(wxWindow *win,
 883                                     wxDC& dc,
 884                                     const wxRect& rect,
 885                                     int flags = 0)
 886         { m_renderer->DrawTreeItemButton(win, dc, rect, flags); }
 887
 888 protected:
 889     wxRenderer *m_renderer;
 890 };
 891
 892 // ----------------------------------------------------------------------------
 893 // wxControlRenderer: wraps the wxRenderer functions in a form easy to use from
 894 // OnPaint()
 895 // ----------------------------------------------------------------------------
 896
 897 class WXDLLEXPORT wxControlRenderer
 898 {
 899 public:
 900     // create a renderer for this dc with this "fundamental" renderer
 901     wxControlRenderer(wxWindow *control, wxDC& dc, wxRenderer *renderer);
 902
 903     // operations
 904     void DrawLabel(const wxBitmap& bitmap = wxNullBitmap,
 905                    wxCoord marginX = 0, wxCoord marginY = 0);
 906 #if wxUSE_LISTBOX
 907     void DrawItems(const wxListBox *listbox,
 908                    size_t itemFirst, size_t itemLast);
 909 #endif // wxUSE_LISTBOX
 910 #if wxUSE_CHECKLISTBOX
 911     void DrawCheckItems(const wxCheckListBox *listbox,
 912                         size_t itemFirst, size_t itemLast);
 913 #endif // wxUSE_CHECKLISTBOX
 914     void DrawButtonBorder();
 915     // the line must be either horizontal or vertical
 916     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
 917     void DrawFrame();
 918     void DrawBitmap(const wxBitmap& bitmap);
 919     void DrawBackgroundBitmap();
 920     void DrawScrollbar(const wxScrollBar *scrollbar, int thumbPosOld);
 921 #if wxUSE_GAUGE
 922     void DrawProgressBar(const wxGauge *gauge);
 923 #endif // wxUSE_GAUGE
 924
 925     // accessors
 926     wxWindow *GetWindow() const { return m_window; }
 927     wxRenderer *GetRenderer() const { return m_renderer; }
 928
 929     wxDC& GetDC() { return m_dc; }
 930
 931     const wxRect& GetRect() const { return m_rect; }
 932     wxRect& GetRect() { return m_rect; }
 933
 934     // static helpers
 935     static void DrawBitmap(wxDC &dc,
 936                            const wxBitmap& bitmap,
 937                            const wxRect& rect,
 938                            int alignment = wxALIGN_CENTRE |
 939                                            wxALIGN_CENTRE_VERTICAL,
 940                            wxStretch stretch = wxSTRETCH_NOT);
 941
 942 private:
 943
 944 #if wxUSE_LISTBOX
 945     // common part of DrawItems() and DrawCheckItems()
 946     void DoDrawItems(const wxListBox *listbox,
 947                      size_t itemFirst, size_t itemLast,
 948                      bool isCheckLbox = false);
 949 #endif // wxUSE_LISTBOX
 950
 951     wxWindow *m_window;
 952     wxRenderer *m_renderer;
 953     wxDC& m_dc;
 954     wxRect m_rect;
 955 };
 956
 957 #endif // _WX_UNIV_RENDERER_H_