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 (part of) line in the text control
 192     virtual void DrawTextLine(wxDC& dc,
 193                               const wxString& text,
 194                               const wxRect& rect,
 195                               int selStart = -1,
 196                               int selEnd = -1,
 197                               int flags = 0) = 0;
 198
 199     // draw a line wrap indicator
 200     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect) = 0;
 201
 202     // draw a notebook tab
 203     virtual void DrawTab(wxDC& dc,
 204                          const wxRect& rect,
 205                          wxDirection dir,
 206                          const wxString& label,
 207                          const wxBitmap& bitmap = wxNullBitmap,
 208                          int flags = 0,
 209                          int indexAccel = -1) = 0;
 210
 211     // draw the slider shaft
 212     virtual void DrawSliderShaft(wxDC& dc,
 213                                  const wxRect& rect,
 214                                  wxOrientation orient,
 215                                  int flags = 0,
 216                                  wxRect *rectShaft = NULL) = 0;
 217
 218     // draw the slider thumb
 219     virtual void DrawSliderThumb(wxDC& dc,
 220                                  const wxRect& rect,
 221                                  wxOrientation orient,
 222                                  int flags = 0) = 0;
 223
 224     // draw the slider ticks
 225     virtual void DrawSliderTicks(wxDC& dc,
 226                                  const wxRect& rect,
 227                                  const wxSize& sizeThumb,
 228                                  wxOrientation orient,
 229                                  int start,
 230                                  int end,
 231                                  int step = 1,
 232                                  int flags = 0) = 0;
 233
 234     // draw a menu bar item
 235     virtual void DrawMenuBarItem(wxDC& dc,
 236                                  const wxRect& rect,
 237                                  const wxString& label,
 238                                  int flags = 0,
 239                                  int indexAccel = -1) = 0;
 240
 241     // draw a menu item (also used for submenus if flags has ISSUBMENU flag)
 242     //
 243     // the geometryInfo is calculated by GetMenuGeometry() function from below
 244     virtual void DrawMenuItem(wxDC& dc,
 245                               wxCoord y,
 246                               const wxMenuGeometryInfo& geometryInfo,
 247                               const wxString& label,
 248                               const wxString& accel,
 249                               const wxBitmap& bitmap = wxNullBitmap,
 250                               int flags = 0,
 251                               int indexAccel = -1) = 0;
 252
 253     // draw a menu bar separator
 254     virtual void DrawMenuSeparator(wxDC& dc,
 255                                    wxCoord y,
 256                                    const wxMenuGeometryInfo& geomInfo) = 0;
 257
 258     // draw a status bar field: wxCONTROL_ISDEFAULT bit in the flags is
 259     // interpreted specially and means "draw the status bar grip" here
 260     virtual void DrawStatusField(wxDC& dc,
 261                                  const wxRect& rect,
 262                                  const wxString& label,
 263                                  int flags = 0) = 0;
 264
 265     // draw complete frame/dialog titlebar
 266     virtual void DrawFrameTitleBar(wxDC& dc,
 267                                    const wxRect& rect,
 268                                    const wxString& title,
 269                                    const wxIcon& icon,
 270                                    int flags,
 271                                    int specialButton = 0,
 272                                    int specialButtonFlags = 0) = 0;
 273
 274     // draw frame borders
 275     virtual void DrawFrameBorder(wxDC& dc,
 276                                  const wxRect& rect,
 277                                  int flags) = 0;
 278
 279     // draw frame titlebar background
 280     virtual void DrawFrameBackground(wxDC& dc,
 281                                      const wxRect& rect,
 282                                      int flags) = 0;
 283
 284     // draw frame title
 285     virtual void DrawFrameTitle(wxDC& dc,
 286                                 const wxRect& rect,
 287                                 const wxString& title,
 288                                 int flags) = 0;
 289
 290     // draw frame icon
 291     virtual void DrawFrameIcon(wxDC& dc,
 292                                const wxRect& rect,
 293                                const wxIcon& icon,
 294                                int flags) = 0;
 295
 296     // draw frame buttons
 297     virtual void DrawFrameButton(wxDC& dc,
 298                                  wxCoord x, wxCoord y,
 299                                  int button,
 300                                  int flags = 0) = 0;
 301
 302     // misc functions
 303     // --------------
 304
 305     // return the bitmaps to use for combobox button
 306     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
 307                                  wxBitmap *bmpFocus,
 308                                  wxBitmap *bmpPressed,
 309                                  wxBitmap *bmpDisabled) = 0;
 310
 311     // geometry functions
 312     // ------------------
 313
 314     // get the dimensions of the border: rect.x/y contain the width/height of
 315     // the left/top side, width/heigh - of the right/bottom one
 316     virtual wxRect GetBorderDimensions(wxBorder border) const = 0;
 317
 318     // the scrollbars may be drawn either inside the window border or outside
 319     // it - this function is used to decide how to draw them
 320     virtual bool AreScrollbarsInsideBorder() const = 0;
 321
 322     // adjust the size of the control of the given class: for most controls,
 323     // this just takes into account the border, but for some (buttons, for
 324     // example) it is more complicated - the result being, in any case, that
 325     // the control looks "nice" if it uses the adjusted rectangle
 326     virtual void AdjustSize(wxSize *size, const wxWindow *window) = 0;
 327
 328     // get the size of a scrollbar arrow
 329     virtual wxSize GetScrollbarArrowSize() const = 0;
 330
 331     // gets the bounding box for a scrollbar element for the given (by default
 332     // - current) thumb position
 333     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
 334                                     wxScrollBar::Element elem,
 335                                     int thumbPos = -1) const = 0;
 336
 337     // returns the size of the scrollbar shaft excluding the arrows
 338     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar) = 0;
 339
 340     // returns one of wxHT_SCROLLBAR_XXX constants
 341     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
 342                                        const wxPoint& pt) const = 0;
 343
 344     // translate the scrollbar position (in logical units) into physical
 345     // coordinate (in pixels) and the other way round
 346     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
 347                                      int thumbPos = -1) = 0;
 348     virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
 349                                  wxCoord coord) = 0;
 350
 351     // get the height of a listbox item from the base font height
 352     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight) = 0;
 353
 354     // get the size of a checkbox/radio button bitmap
 355     virtual wxSize GetCheckBitmapSize() const = 0;
 356     virtual wxSize GetRadioBitmapSize() const = 0;
 357     virtual wxCoord GetCheckItemMargin() const = 0;
 358
 359     // convert between text rectangle and client rectangle for text controls:
 360     // the former is typicall smaller to leave margins around text
 361     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
 362                                     const wxRect& rectText) = 0;
 363
 364     // extra space is for line indicators
 365     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
 366                                      const wxRect& rectTotal,
 367                                      wxCoord *extraSpaceBeyond) = 0;
 368
 369     // get the overhang of a selected tab
 370     virtual wxSize GetTabIndent() const = 0;
 371
 372     // get the padding around the text in a tab
 373     virtual wxSize GetTabPadding() const = 0;
 374
 375     // get the default size of the slider in lesser dimension (i.e. height of a
 376     // horizontal slider or width of a vertical one)
 377     virtual wxCoord GetSliderDim() const = 0;
 378
 379     // get the length of the slider ticks displayed along side slider
 380     virtual wxCoord GetSliderTickLen() const = 0;
 381
 382     // get the slider shaft rect from the total slider rect
 383     virtual wxRect GetSliderShaftRect(const wxRect& rect,
 384                                       wxOrientation orient) const = 0;
 385
 386     // get the size of the slider thumb for the given total slider rect
 387     virtual wxSize GetSliderThumbSize(const wxRect& rect,
 388                                       wxOrientation orient) const = 0;
 389
 390     // get the size of one progress bar step (in horz and vertical directions)
 391     virtual wxSize GetProgressBarStep() const = 0;
 392
 393     // get the size of rectangle to use in the menubar for the given text rect
 394     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const = 0;
 395
 396     // get the struct storing all layout info needed to draw all menu items
 397     // (this can't be calculated for each item separately as they should be
 398     // aligned)
 399     //
 400     // the returned pointer must be deleted by the caller
 401     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
 402                                                 const wxMenu& menu) const = 0;
 403
 404     // get the borders around the status bar fields (x and y fields of the
 405     // return value) and also, optionally, the border between the fields
 406     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const = 0;
 407
 408     // get client area rectangle of top level window (i.e. subtract
 409     // decorations from given rectangle)
 410     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const = 0;
 411
 412     // get size of whole top level window, given size of its client area size
 413     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const = 0;
 414
 415     // get titlebar icon size
 416     virtual wxSize GetFrameIconSize() const = 0;
 417
 418     // returns one of wxHT_TOPLEVEL_XXX constants
 419     virtual int HitTestFrame(const wxRect& rect,
 420                              const wxPoint& pt,
 421                              int flags = 0) const = 0;
 422
 423
 424     // get the standard icon used by wxWin dialogs - this allows the user
 425     // to customize the standard dialogs. The 'which' parameter is one of
 426     // wxICON_XXX values
 427     virtual wxIcon GetStdIcon(int which) const = 0;
 428
 429     // virtual dtor for any base class
 430     virtual ~wxRenderer();
 431
 432 protected:
 433     // draw a frame around rectFrame rectangle but not touching the rectLabel
 434     // one: this is used by DrawFrame()
 435     void StandardDrawFrame(wxDC& dc,
 436                            const wxRect& rectFrame,
 437                            const wxRect& rectLabel);
 438
 439     // standard text line drawing: just use DrawText() and highlight the
 440     // selected part
 441     static void StandardDrawTextLine(wxDC& dc,
 442                                      const wxString& text,
 443                                      const wxRect& rect,
 444                                      int selStart, int selEnd,
 445                                      int flags);
 446
 447     // standard scrollbar hit testing: this assumes that it only has 2 arrows
 448     // and a thumb, so the themes which have more complicated scrollbars (e.g.
 449     // BeOS) can't use this method
 450     static wxRect StandardGetScrollbarRect(const wxScrollBar *scrollbar,
 451                                            wxScrollBar::Element elem,
 452                                            int thumbPos,
 453                                            const wxSize& sizeArrow);
 454     static wxHitTest StandardHitTestScrollbar(const wxScrollBar *scrollbar,
 455                                               const wxPoint& pt,
 456                                               const wxSize& sizeArrow);
 457     static wxCoord StandardScrollbarToPixel(const wxScrollBar *scrollbar,
 458                                             int thumbPos,
 459                                             const wxSize& sizeArrow);
 460     static int StandardPixelToScrollbar(const wxScrollBar *scrollbar,
 461                                         wxCoord coord,
 462                                         const wxSize& sizeArrow);
 463     static wxCoord StandardScrollBarSize(const wxScrollBar *scrollbar,
 464                                          const wxSize& sizeArrow);
 465     static void StandardScrollBarThumbSize(wxCoord lenBar,
 466                                            int thumbPos,
 467                                            int thumbSize,
 468                                            int range,
 469                                            wxCoord *thumbStart,
 470                                            wxCoord *thumbEnd);
 471 };
 472
 473 // ----------------------------------------------------------------------------
 474 // wxDelegateRenderer: it is impossible to inherit from any of standard
 475 // renderers as their declarations are in private code, but you can use this
 476 // class to override only some of the Draw() functions - all the other ones
 477 // will be left to the original renderer
 478 // ----------------------------------------------------------------------------
 479
 480 class WXDLLEXPORT wxDelegateRenderer : public wxRenderer
 481 {
 482 public:
 483     wxDelegateRenderer(wxRenderer *renderer) : m_renderer(renderer) { }
 484
 485     virtual void DrawBackground(wxDC& dc,
 486                                 const wxColour& col,
 487                                 const wxRect& rect,
 488                                 int flags)
 489         { m_renderer->DrawBackground(dc, col, rect, flags); }
 490     virtual void DrawLabel(wxDC& dc,
 491                            const wxString& label,
 492                            const wxRect& rect,
 493                            int flags = 0,
 494                            int align = wxALIGN_LEFT | wxALIGN_TOP,
 495                            int indexAccel = -1,
 496                            wxRect *rectBounds = NULL)
 497         { m_renderer->DrawLabel(dc, label, rect,
 498                                 flags, align, indexAccel, rectBounds); }
 499     virtual void DrawButtonLabel(wxDC& dc,
 500                                  const wxString& label,
 501                                  const wxBitmap& image,
 502                                  const wxRect& rect,
 503                                  int flags = 0,
 504                                  int align = wxALIGN_LEFT | wxALIGN_TOP,
 505                                  int indexAccel = -1,
 506                                  wxRect *rectBounds = NULL)
 507         { m_renderer->DrawButtonLabel(dc, label, image, rect,
 508                                       flags, align, indexAccel, rectBounds); }
 509     virtual void DrawBorder(wxDC& dc,
 510                             wxBorder border,
 511                             const wxRect& rect,
 512                             int flags = 0,
 513                             wxRect *rectIn = (wxRect *)NULL)
 514         { m_renderer->DrawBorder(dc, border, rect, flags, rectIn); }
 515     virtual void DrawTextBorder(wxDC& dc,
 516                                 wxBorder border,
 517                                 const wxRect& rect,
 518                                 int flags = 0,
 519                                 wxRect *rectIn = (wxRect *)NULL)
 520         { m_renderer->DrawTextBorder(dc, border, rect, flags, rectIn); }
 521     virtual void DrawButtonBorder(wxDC& dc,
 522                                   const wxRect& rect,
 523                                   int flags = 0,
 524                                   wxRect *rectIn = (wxRect *)NULL)
 525         { m_renderer->DrawButtonBorder(dc, rect, flags, rectIn); }
 526     virtual void DrawFrame(wxDC& dc,
 527                            const wxString& label,
 528                            const wxRect& rect,
 529                            int flags = 0,
 530                            int align = wxALIGN_LEFT,
 531                            int indexAccel = -1)
 532         { m_renderer->DrawFrame(dc, label, rect, flags, align, indexAccel); }
 533     virtual void DrawHorizontalLine(wxDC& dc,
 534                                     wxCoord y, wxCoord x1, wxCoord x2)
 535         { m_renderer->DrawHorizontalLine(dc, y, x1, x2); }
 536     virtual void DrawVerticalLine(wxDC& dc,
 537                                   wxCoord x, wxCoord y1, wxCoord y2)
 538         { m_renderer->DrawVerticalLine(dc, x, y1, y2); }
 539     virtual void DrawArrow(wxDC& dc,
 540                            wxDirection dir,
 541                            const wxRect& rect,
 542                            int flags = 0)
 543         { m_renderer->DrawArrow(dc, dir, rect, flags); }
 544     virtual void DrawScrollbarArrow(wxDC& dc,
 545                            wxDirection dir,
 546                            const wxRect& rect,
 547                            int flags = 0)
 548         { m_renderer->DrawScrollbarArrow(dc, dir, rect, flags); }
 549     virtual void DrawScrollbarThumb(wxDC& dc,
 550                                     wxOrientation orient,
 551                                     const wxRect& rect,
 552                                     int flags = 0)
 553         { m_renderer->DrawScrollbarThumb(dc, orient, rect, flags); }
 554     virtual void DrawScrollbarShaft(wxDC& dc,
 555                                     wxOrientation orient,
 556                                     const wxRect& rect,
 557                                     int flags = 0)
 558         { m_renderer->DrawScrollbarShaft(dc, orient, rect, flags); }
 559     virtual void DrawScrollCorner(wxDC& dc,
 560                                   const wxRect& rect)
 561         { m_renderer->DrawScrollCorner(dc, rect); }
 562     virtual void DrawItem(wxDC& dc,
 563                           const wxString& label,
 564                           const wxRect& rect,
 565                           int flags = 0)
 566         { m_renderer->DrawItem(dc, label, rect, flags); }
 567     virtual void DrawCheckItem(wxDC& dc,
 568                                const wxString& label,
 569                                const wxBitmap& bitmap,
 570                                const wxRect& rect,
 571                                int flags = 0)
 572         { m_renderer->DrawCheckItem(dc, label, bitmap, rect, flags); }
 573     virtual void DrawCheckButton(wxDC& dc,
 574                                  const wxString& label,
 575                                  const wxBitmap& bitmap,
 576                                  const wxRect& rect,
 577                                  int flags = 0,
 578                                  wxAlignment align = wxALIGN_LEFT,
 579                                  int indexAccel = -1)
 580         { m_renderer->DrawCheckButton(dc, label, bitmap, rect,
 581                                       flags, align, indexAccel); }
 582     virtual void DrawRadioButton(wxDC& dc,
 583                                  const wxString& label,
 584                                  const wxBitmap& bitmap,
 585                                  const wxRect& rect,
 586                                  int flags = 0,
 587                                  wxAlignment align = wxALIGN_LEFT,
 588                                  int indexAccel = -1)
 589         { m_renderer->DrawRadioButton(dc, label, bitmap, rect,
 590                                       flags, align, indexAccel); }
 591     virtual void DrawTextLine(wxDC& dc,
 592                               const wxString& text,
 593                               const wxRect& rect,
 594                               int selStart = -1,
 595                               int selEnd = -1)
 596         { m_renderer->DrawTextLine(dc, text, rect, selStart, selEnd); }
 597     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect)
 598         { m_renderer->DrawLineWrapMark(dc, rect); }
 599
 600     virtual void DrawTab(wxDC& dc,
 601                          const wxRect& rect,
 602                          wxDirection dir,
 603                          const wxString& label,
 604                          const wxBitmap& bitmap = wxNullBitmap,
 605                          int flags = 0,
 606                          int accel = -1)
 607         { m_renderer->DrawTab(dc, rect, dir, label, bitmap, flags, accel); }
 608
 609     virtual void DrawSliderShaft(wxDC& dc,
 610                                  const wxRect& rect,
 611                                  wxOrientation orient,
 612                                  int flags = 0,
 613                                  wxRect *rectShaft = NULL)
 614         { m_renderer->DrawSliderShaft(dc, rect, orient, flags, rectShaft); }
 615     virtual void DrawSliderThumb(wxDC& dc,
 616                                  const wxRect& rect,
 617                                  wxOrientation orient,
 618                                  int flags = 0)
 619         { m_renderer->DrawSliderThumb(dc, rect, orient, flags); }
 620     virtual void DrawSliderTicks(wxDC& dc,
 621                                  const wxRect& rect,
 622                                  const wxSize& sizeThumb,
 623                                  wxOrientation orient,
 624                                  int start,
 625                                  int end,
 626                                  int step = 1,
 627                                  int flags = 0)
 628         { m_renderer->DrawSliderTicks(dc, rect, sizeThumb, orient,
 629                                       start, end, start, flags); }
 630
 631     virtual void DrawMenuBarItem(wxDC& dc,
 632                                  const wxRect& rect,
 633                                  const wxString& label,
 634                                  int flags = 0,
 635                                  int indexAccel = -1)
 636         { m_renderer->DrawMenuBarItem(dc, rect, label, flags, indexAccel); }
 637     virtual void DrawMenuItem(wxDC& dc,
 638                               wxCoord y,
 639                               const wxMenuGeometryInfo& gi,
 640                               const wxString& label,
 641                               const wxString& accel,
 642                               const wxBitmap& bitmap = wxNullBitmap,
 643                               int flags = 0,
 644                               int indexAccel = -1)
 645         { m_renderer->DrawMenuItem(dc, y, gi, label, accel,
 646                                    bitmap, flags, indexAccel); }
 647     virtual void DrawMenuSeparator(wxDC& dc,
 648                                    wxCoord y,
 649                                    const wxMenuGeometryInfo& geomInfo)
 650         { m_renderer->DrawMenuSeparator(dc, y, geomInfo); }
 651
 652     virtual void DrawStatusField(wxDC& dc,
 653                                  const wxRect& rect,
 654                                  const wxString& label,
 655                                  int flags = 0)
 656         { m_renderer->DrawStatusField(dc, rect, label, flags); }
 657
 658     virtual void DrawFrameTitleBar(wxDC& dc,
 659                                    const wxRect& rect,
 660                                    const wxString& title,
 661                                    const wxIcon& icon,
 662                                    int flags,
 663                                    int specialButton = 0,
 664                                    int specialButtonFlag = 0)
 665         { m_renderer->DrawFrameTitleBar(dc, rect, title, icon, flags,
 666                                         specialButton, specialButtonFlag); }
 667     virtual void DrawFrameBorder(wxDC& dc,
 668                                  const wxRect& rect,
 669                                  int flags)
 670         { m_renderer->DrawFrameBorder(dc, rect, flags); }
 671     virtual void DrawFrameBackground(wxDC& dc,
 672                                      const wxRect& rect,
 673                                      int flags)
 674         { m_renderer->DrawFrameBackground(dc, rect, flags); }
 675     virtual void DrawFrameTitle(wxDC& dc,
 676                                 const wxRect& rect,
 677                                 const wxString& title,
 678                                 int flags)
 679         { m_renderer->DrawFrameTitle(dc, rect, title, flags); }
 680     virtual void DrawFrameIcon(wxDC& dc,
 681                                const wxRect& rect,
 682                                const wxIcon& icon,
 683                                int flags)
 684         { m_renderer->DrawFrameIcon(dc, rect, icon, flags); }
 685     virtual void DrawFrameButton(wxDC& dc,
 686                                  wxCoord x, wxCoord y,
 687                                  int button,
 688                                  int flags = 0)
 689         { m_renderer->DrawFrameButton(dc, x, y, button, flags); }
 690
 691     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
 692                                  wxBitmap *bmpFocus,
 693                                  wxBitmap *bmpPressed,
 694                                  wxBitmap *bmpDisabled) const
 695         { m_renderer->GetComboBitmaps(bmpNormal, bmpFocus,
 696                                       bmpPressed, bmpDisabled); }
 697
 698     virtual void AdjustSize(wxSize *size, const wxWindow *window)
 699         { m_renderer->AdjustSize(size, window); }
 700     virtual wxRect GetBorderDimensions(wxBorder border) const
 701         { return m_renderer->GetBorderDimensions(border); }
 702     virtual bool AreScrollbarsInsideBorder() const
 703         { return m_renderer->AreScrollbarsInsideBorder(); }
 704
 705     virtual wxSize GetScrollbarArrowSize() const
 706         { return m_renderer->GetScrollbarArrowSize(); }
 707     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
 708                                     wxScrollBar::Element elem,
 709                                     int thumbPos = -1) const
 710         { return m_renderer->GetScrollbarRect(scrollbar, elem, thumbPos); }
 711     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar)
 712         { return m_renderer->GetScrollbarSize(scrollbar); }
 713     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
 714                                        const wxPoint& pt) const
 715         { return m_renderer->HitTestScrollbar(scrollbar, pt); }
 716     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
 717                                      int thumbPos = -1)
 718         { return m_renderer->ScrollbarToPixel(scrollbar, thumbPos); }
 719     virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
 720                                  wxCoord coord)
 721         { return m_renderer->PixelToScrollbar(scrollbar, coord); }
 722     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
 723         { return m_renderer->GetListboxItemHeight(fontHeight); }
 724     virtual wxSize GetCheckBitmapSize() const
 725         { return m_renderer->GetCheckBitmapSize(); }
 726     virtual wxSize GetRadioBitmapSize() const
 727         { return m_renderer->GetRadioBitmapSize(); }
 728     virtual wxCoord GetCheckItemMargin() const
 729         { return m_renderer->GetCheckItemMargin(); }
 730
 731     virtual wxRect GetTextTotalArea(const wxTextCtrl *text, const wxRect& rect)
 732         { return m_renderer->GetTextTotalArea(text, rect); }
 733     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
 734                                      const wxRect& rect,
 735                                      wxCoord *extraSpaceBeyond)
 736         { return m_renderer->GetTextClientArea(text, rect, extraSpaceBeyond); }
 737
 738     virtual wxSize GetTabIndent() const { return m_renderer->GetTabIndent(); }
 739     virtual wxSize GetTabPadding() const { return m_renderer->GetTabPadding(); }
 740
 741     virtual wxCoord GetSliderDim() const
 742         { return m_renderer->GetSliderDim(); }
 743     virtual wxCoord GetSliderTickLen() const
 744         { return m_renderer->GetSliderTickLen(); }
 745     virtual wxRect GetSliderShaftRect(const wxRect& rect,
 746                                       wxOrientation orient) const
 747         { return GetSliderShaftRect(rect, orient); }
 748     virtual wxSize GetSliderThumbSize(const wxRect& rect,
 749                                       wxOrientation orient) const
 750         { return m_renderer->GetSliderThumbSize(rect, orient); }
 751     virtual wxSize GetProgressBarStep() const
 752         { return m_renderer->GetProgressBarStep(); }
 753     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const
 754         { return m_renderer->GetMenuBarItemSize(sizeText); }
 755     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
 756                                                 const wxMenu& menu) const
 757         { return m_renderer->GetMenuGeometry(win, menu); }
 758     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const
 759         { return m_renderer->GetStatusBarBorders(borderBetweenFields); }
 760     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const
 761         { return m_renderer->GetFrameClientArea(rect, flags); }
 762     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const
 763         { return m_renderer->GetFrameTotalSize(clientSize, flags); }
 764     virtual wxSize GetFrameIconSize() const
 765         { return m_renderer->GetFrameIconSize(); }
 766     virtual int HitTestFrame(const wxRect& rect,
 767                              const wxPoint& pt,
 768                              int flags) const
 769         { return m_renderer->HitTestFrame(rect, pt, flags); }
 770     virtual wxIcon GetStdIcon(int which) const
 771         { return m_renderer->GetStdIcon(which); }
 772
 773 protected:
 774     wxRenderer *m_renderer;
 775 };
 776
 777 // ----------------------------------------------------------------------------
 778 // wxControlRenderer: wraps the wxRenderer functions in a form easy to use from
 779 // OnPaint()
 780 // ----------------------------------------------------------------------------
 781
 782 class WXDLLEXPORT wxControlRenderer
 783 {
 784 public:
 785     // create a renderer for this dc with this "fundamental" renderer
 786     wxControlRenderer(wxWindow *control, wxDC& dc, wxRenderer *renderer);
 787
 788     // operations
 789     void DrawLabel(const wxBitmap& bitmap = wxNullBitmap,
 790                    wxCoord marginX = 0, wxCoord marginY = 0);
 791 #if wxUSE_LISTBOX
 792     void DrawItems(const wxListBox *listbox,
 793                    size_t itemFirst, size_t itemLast);
 794 #endif // wxUSE_LISTBOX
 795 #if wxUSE_CHECKLISTBOX
 796     void DrawCheckItems(const wxCheckListBox *listbox,
 797                         size_t itemFirst, size_t itemLast);
 798 #endif // wxUSE_CHECKLISTBOX
 799     void DrawButtonBorder();
 800     // the line must be either horizontal or vertical
 801     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
 802     void DrawFrame();
 803     void DrawBitmap(const wxBitmap& bitmap);
 804     void DrawBackgroundBitmap();
 805     void DrawScrollbar(const wxScrollBar *scrollbar, int thumbPosOld);
 806 #if wxUSE_GAUGE
 807     void DrawProgressBar(const wxGauge *gauge);
 808 #endif // wxUSE_GAUGE
 809
 810     // accessors
 811     wxWindow *GetWindow() const { return m_window; }
 812     wxRenderer *GetRenderer() const { return m_renderer; }
 813
 814     wxDC& GetDC() { return m_dc; }
 815
 816     const wxRect& GetRect() const { return m_rect; }
 817     wxRect& GetRect() { return m_rect; }
 818
 819     // static helpers
 820     static void DrawBitmap(wxDC &dc,
 821                            const wxBitmap& bitmap,
 822                            const wxRect& rect,
 823                            int alignment = wxALIGN_CENTRE |
 824                                            wxALIGN_CENTRE_VERTICAL,
 825                            wxStretch stretch = wxSTRETCH_NOT);
 826
 827 private:
 828     // common part of DrawItems() and DrawCheckItems()
 829     void DoDrawItems(const wxListBox *listbox,
 830                      size_t itemFirst, size_t itemLast,
 831                      bool isCheckLbox = FALSE);
 832
 833     wxWindow *m_window;
 834     wxRenderer *m_renderer;
 835     wxDC& m_dc;
 836     wxRect m_rect;
 837 };
 838
 839 #endif // _WX_UNIV_RENDERER_H_
 840