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