include/wx/renderer.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/renderer.h
   3 // Purpose:     wxRendererNative class declaration
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     20.07.2003
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13    Renderers are used in wxWidgets for two similar but different things:
  14     (a) wxUniversal uses them to draw everything, i.e. all the control
  15     (b) all the native ports use them to draw generic controls only
  16
  17    wxUniversal needs more functionality than what is included in the base class
  18    as it needs to draw stuff like scrollbars which are never going to be
  19    generic. So we put the bare minimum needed by the native ports here and the
  20    full wxRenderer class is declared in wx/univ/renderer.h and is only used by
  21    wxUniveral (although note that native ports can load wxRenderer objects from
  22    theme DLLs and use them as wxRendererNative ones, of course).
  23  */
  24
  25 #ifndef _WX_RENDERER_H_
  26 #define _WX_RENDERER_H_
  27
  28 class WXDLLIMPEXP_FWD_CORE wxDC;
  29 class WXDLLIMPEXP_FWD_CORE wxWindow;
  30
  31 #include "wx/gdicmn.h" // for wxPoint, wxSize
  32 #include "wx/colour.h"
  33 #include "wx/font.h"
  34 #include "wx/bitmap.h"
  35 #include "wx/string.h"
  36
  37 // some platforms have their own renderers, others use the generic one
  38 #if defined(__WXMSW__) || ( defined(__WXMAC__) && wxOSX_USE_COCOA_OR_CARBON ) || defined(__WXGTK__)
  39     #define wxHAS_NATIVE_RENDERER
  40 #else
  41     #undef wxHAS_NATIVE_RENDERER
  42 #endif
  43
  44 // only MSW and OS X currently provides DrawTitleBarBitmap() method
  45 #if defined(__WXMSW__) || (defined(__WXMAC__) && wxUSE_LIBPNG && wxUSE_IMAGE)
  46     #define wxHAS_DRAW_TITLE_BAR_BITMAP
  47 #endif
  48
  49 // ----------------------------------------------------------------------------
  50 // constants
  51 // ----------------------------------------------------------------------------
  52
  53 // control state flags used in wxRenderer and wxColourScheme
  54 enum
  55 {
  56     wxCONTROL_DISABLED   = 0x00000001,  // control is disabled
  57     wxCONTROL_FOCUSED    = 0x00000002,  // currently has keyboard focus
  58     wxCONTROL_PRESSED    = 0x00000004,  // (button) is pressed
  59     wxCONTROL_SPECIAL    = 0x00000008,  // control-specific bit:
  60     wxCONTROL_ISDEFAULT  = wxCONTROL_SPECIAL, // only for the buttons
  61     wxCONTROL_ISSUBMENU  = wxCONTROL_SPECIAL, // only for the menu items
  62     wxCONTROL_EXPANDED   = wxCONTROL_SPECIAL, // only for the tree items
  63     wxCONTROL_SIZEGRIP   = wxCONTROL_SPECIAL, // only for the status bar panes
  64     wxCONTROL_FLAT       = wxCONTROL_SPECIAL, // checkboxes only: flat border
  65     wxCONTROL_CURRENT    = 0x00000010,  // mouse is currently over the control
  66     wxCONTROL_SELECTED   = 0x00000020,  // selected item in e.g. listbox
  67     wxCONTROL_CHECKED    = 0x00000040,  // (check/radio button) is checked
  68     wxCONTROL_CHECKABLE  = 0x00000080,  // (menu) item can be checked
  69     wxCONTROL_UNDETERMINED = wxCONTROL_CHECKABLE, // (check) undetermined state
  70
  71     wxCONTROL_FLAGS_MASK = 0x000000ff,
  72
  73     // this is a pseudo flag not used directly by wxRenderer but rather by some
  74     // controls internally
  75     wxCONTROL_DIRTY      = 0x80000000
  76 };
  77
  78 // title bar buttons supported by DrawTitleBarBitmap()
  79 //
  80 // NB: they have the same values as wxTOPLEVEL_BUTTON_XXX constants in
  81 //     wx/univ/toplevel.h as they really represent the same things
  82 enum wxTitleBarButton
  83 {
  84     wxTITLEBAR_BUTTON_CLOSE    = 0x01000000,
  85     wxTITLEBAR_BUTTON_MAXIMIZE = 0x02000000,
  86     wxTITLEBAR_BUTTON_ICONIZE  = 0x04000000,
  87     wxTITLEBAR_BUTTON_RESTORE  = 0x08000000,
  88     wxTITLEBAR_BUTTON_HELP     = 0x10000000
  89 };
  90
  91 // ----------------------------------------------------------------------------
  92 // helper structs
  93 // ----------------------------------------------------------------------------
  94
  95 // wxSplitterWindow parameters
  96 struct WXDLLIMPEXP_CORE wxSplitterRenderParams
  97 {
  98     // the only way to initialize this struct is by using this ctor
  99     wxSplitterRenderParams(wxCoord widthSash_, wxCoord border_, bool isSens_)
 100         : widthSash(widthSash_), border(border_), isHotSensitive(isSens_)
 101         {
 102         }
 103
 104     // the width of the splitter sash
 105     const wxCoord widthSash;
 106
 107     // the width of the border of the splitter window
 108     const wxCoord border;
 109
 110     // true if the splitter changes its appearance when the mouse is over it
 111     const bool isHotSensitive;
 112 };
 113
 114
 115 // extra optional parameters for DrawHeaderButton
 116 struct WXDLLIMPEXP_CORE wxHeaderButtonParams
 117 {
 118     wxHeaderButtonParams()
 119         : m_labelAlignment(wxALIGN_LEFT)
 120     { }
 121
 122     wxColour    m_arrowColour;
 123     wxColour    m_selectionColour;
 124     wxString    m_labelText;
 125     wxFont      m_labelFont;
 126     wxColour    m_labelColour;
 127     wxBitmap    m_labelBitmap;
 128     int         m_labelAlignment;
 129 };
 130
 131 enum wxHeaderSortIconType
 132 {
 133     wxHDR_SORT_ICON_NONE,        // Header button has no sort arrow
 134     wxHDR_SORT_ICON_UP,          // Header button an up sort arrow icon
 135     wxHDR_SORT_ICON_DOWN         // Header button a down sort arrow icon
 136 };
 137
 138
 139 // wxRendererNative interface version
 140 struct WXDLLIMPEXP_CORE wxRendererVersion
 141 {
 142     wxRendererVersion(int version_, int age_) : version(version_), age(age_) { }
 143
 144     // default copy ctor, assignment operator and dtor are ok
 145
 146     // the current version and age of wxRendererNative interface: different
 147     // versions are incompatible (in both ways) while the ages inside the same
 148     // version are upwards compatible, i.e. the version of the renderer must
 149     // match the version of the main program exactly while the age may be
 150     // highergreater or equal to it
 151     //
 152     // NB: don't forget to increment age after adding any new virtual function!
 153     enum
 154     {
 155         Current_Version = 1,
 156         Current_Age = 5
 157     };
 158
 159
 160     // check if the given version is compatible with the current one
 161     static bool IsCompatible(const wxRendererVersion& ver)
 162     {
 163         return ver.version == Current_Version && ver.age >= Current_Age;
 164     }
 165
 166     const int version;
 167     const int age;
 168 };
 169
 170 // ----------------------------------------------------------------------------
 171 // wxRendererNative: abstracts drawing methods needed by the native controls
 172 // ----------------------------------------------------------------------------
 173
 174 class WXDLLIMPEXP_CORE wxRendererNative
 175 {
 176 public:
 177     // drawing functions
 178     // -----------------
 179
 180     // draw the header control button (used by wxListCtrl) Returns optimal
 181     // width for the label contents.
 182     virtual int  DrawHeaderButton(wxWindow *win,
 183                                   wxDC& dc,
 184                                   const wxRect& rect,
 185                                   int flags = 0,
 186                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 187                                   wxHeaderButtonParams* params=NULL) = 0;
 188
 189
 190     // Draw the contents of a header control button (label, sort arrows, etc.)
 191     // Normally only called by DrawHeaderButton.
 192     virtual int  DrawHeaderButtonContents(wxWindow *win,
 193                                           wxDC& dc,
 194                                           const wxRect& rect,
 195                                           int flags = 0,
 196                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 197                                           wxHeaderButtonParams* params=NULL) = 0;
 198
 199     // Returns the default height of a header button, either a fixed platform
 200     // height if available, or a generic height based on the window's font.
 201     virtual int GetHeaderButtonHeight(wxWindow *win) = 0;
 202
 203
 204     // draw the expanded/collapsed icon for a tree control item
 205     virtual void DrawTreeItemButton(wxWindow *win,
 206                                     wxDC& dc,
 207                                     const wxRect& rect,
 208                                     int flags = 0) = 0;
 209
 210     // draw the border for sash window: this border must be such that the sash
 211     // drawn by DrawSash() blends into it well
 212     virtual void DrawSplitterBorder(wxWindow *win,
 213                                     wxDC& dc,
 214                                     const wxRect& rect,
 215                                     int flags = 0) = 0;
 216
 217     // draw a (vertical) sash
 218     virtual void DrawSplitterSash(wxWindow *win,
 219                                   wxDC& dc,
 220                                   const wxSize& size,
 221                                   wxCoord position,
 222                                   wxOrientation orient,
 223                                   int flags = 0) = 0;
 224
 225     // draw a combobox dropdown button
 226     //
 227     // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
 228     virtual void DrawComboBoxDropButton(wxWindow *win,
 229                                         wxDC& dc,
 230                                         const wxRect& rect,
 231                                         int flags = 0) = 0;
 232
 233     // draw a dropdown arrow
 234     //
 235     // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
 236     virtual void DrawDropArrow(wxWindow *win,
 237                                wxDC& dc,
 238                                const wxRect& rect,
 239                                int flags = 0) = 0;
 240
 241     // draw check button
 242     //
 243     // flags may use wxCONTROL_CHECKED, wxCONTROL_UNDETERMINED and wxCONTROL_CURRENT
 244     virtual void DrawCheckBox(wxWindow *win,
 245                               wxDC& dc,
 246                               const wxRect& rect,
 247                               int flags = 0) = 0;
 248
 249     // Returns the default size of a check box.
 250     virtual wxSize GetCheckBoxSize(wxWindow *win) = 0;
 251
 252     // draw blank button
 253     //
 254     // flags may use wxCONTROL_PRESSED, wxCONTROL_CURRENT and wxCONTROL_ISDEFAULT
 255     virtual void DrawPushButton(wxWindow *win,
 256                                 wxDC& dc,
 257                                 const wxRect& rect,
 258                                 int flags = 0) = 0;
 259
 260     // draw rectangle indicating that an item in e.g. a list control
 261     // has been selected or focused
 262     //
 263     // flags may use
 264     // wxCONTROL_SELECTED (item is selected, e.g. draw background)
 265     // wxCONTROL_CURRENT (item is the current item, e.g. dotted border)
 266     // wxCONTROL_FOCUSED (the whole control has focus, e.g. blue background vs. grey otherwise)
 267     virtual void DrawItemSelectionRect(wxWindow *win,
 268                                        wxDC& dc,
 269                                        const wxRect& rect,
 270                                        int flags = 0) = 0;
 271
 272     // draw the focus rectangle around the label contained in the given rect
 273     //
 274     // only wxCONTROL_SELECTED makes sense in flags here
 275     virtual void DrawFocusRect(wxWindow* win,
 276                                wxDC& dc,
 277                                const wxRect& rect,
 278                                int flags = 0) = 0;
 279
 280     // Draw a native wxChoice
 281     virtual void DrawChoice(wxWindow* win,
 282                             wxDC& dc,
 283                             const wxRect& rect,
 284                             int flags = 0) = 0;
 285
 286     // Draw a native wxComboBox
 287     virtual void DrawComboBox(wxWindow* win,
 288                               wxDC& dc,
 289                               const wxRect& rect,
 290                               int flags = 0) = 0;
 291
 292     // Draw a native wxTextCtrl frame
 293     virtual void DrawTextCtrl(wxWindow* win,
 294                               wxDC& dc,
 295                               const wxRect& rect,
 296                               int flags = 0) = 0;
 297
 298     // Draw a native wxRadioButton bitmap
 299     virtual void DrawRadioBitmap(wxWindow* win,
 300                                  wxDC& dc,
 301                                  const wxRect& rect,
 302                                  int flags = 0) = 0;
 303
 304 #ifdef wxHAS_DRAW_TITLE_BAR_BITMAP
 305     // Draw one of the standard title bar buttons
 306     //
 307     // This is currently implemented only for MSW and OS X (for the close
 308     // button only) because there is no way to render standard title bar
 309     // buttons under the other platforms, the best can be done is to use normal
 310     // (only) images which wxArtProvider provides for wxART_HELP and
 311     // wxART_CLOSE (but not any other title bar buttons)
 312     //
 313     // NB: make sure PNG handler is enabled if using this function under OS X
 314     virtual void DrawTitleBarBitmap(wxWindow *win,
 315                                     wxDC& dc,
 316                                     const wxRect& rect,
 317                                     wxTitleBarButton button,
 318                                     int flags = 0) = 0;
 319 #endif // wxHAS_DRAW_TITLE_BAR_BITMAP
 320
 321
 322     // geometry functions
 323     // ------------------
 324
 325     // get the splitter parameters: the x field of the returned point is the
 326     // sash width and the y field is the border width
 327     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win) = 0;
 328
 329
 330     // pseudo constructors
 331     // -------------------
 332
 333     // return the currently used renderer
 334     static wxRendererNative& Get();
 335
 336     // return the generic implementation of the renderer
 337     static wxRendererNative& GetGeneric();
 338
 339     // return the default (native) implementation for this platform
 340     static wxRendererNative& GetDefault();
 341
 342
 343     // changing the global renderer
 344     // ----------------------------
 345
 346 #if wxUSE_DYNLIB_CLASS
 347     // load the renderer from the specified DLL, the returned pointer must be
 348     // deleted by caller if not NULL when it is not used any more
 349     static wxRendererNative *Load(const wxString& name);
 350 #endif // wxUSE_DYNLIB_CLASS
 351
 352     // set the renderer to use, passing NULL reverts to using the default
 353     // renderer
 354     //
 355     // return the previous renderer used with Set() or NULL if none
 356     static wxRendererNative *Set(wxRendererNative *renderer);
 357
 358
 359     // miscellaneous stuff
 360     // -------------------
 361
 362     // this function is used for version checking: Load() refuses to load any
 363     // DLLs implementing an older or incompatible version; it should be
 364     // implemented simply by returning wxRendererVersion::Current_XXX values
 365     virtual wxRendererVersion GetVersion() const = 0;
 366
 367     // virtual dtor for any base class
 368     virtual ~wxRendererNative();
 369 };
 370
 371 // ----------------------------------------------------------------------------
 372 // wxDelegateRendererNative: allows reuse of renderers code
 373 // ----------------------------------------------------------------------------
 374
 375 class WXDLLIMPEXP_CORE wxDelegateRendererNative : public wxRendererNative
 376 {
 377 public:
 378     wxDelegateRendererNative()
 379         : m_rendererNative(GetGeneric()) { }
 380
 381     wxDelegateRendererNative(wxRendererNative& rendererNative)
 382         : m_rendererNative(rendererNative) { }
 383
 384
 385     virtual int  DrawHeaderButton(wxWindow *win,
 386                                   wxDC& dc,
 387                                   const wxRect& rect,
 388                                   int flags = 0,
 389                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 390                                   wxHeaderButtonParams* params = NULL)
 391         { return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params); }
 392
 393     virtual int  DrawHeaderButtonContents(wxWindow *win,
 394                                           wxDC& dc,
 395                                           const wxRect& rect,
 396                                           int flags = 0,
 397                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 398                                           wxHeaderButtonParams* params = NULL)
 399         { return m_rendererNative.DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }
 400
 401     virtual int GetHeaderButtonHeight(wxWindow *win)
 402         { return m_rendererNative.GetHeaderButtonHeight(win); }
 403
 404     virtual void DrawTreeItemButton(wxWindow *win,
 405                                     wxDC& dc,
 406                                     const wxRect& rect,
 407                                     int flags = 0)
 408         { m_rendererNative.DrawTreeItemButton(win, dc, rect, flags); }
 409
 410     virtual void DrawSplitterBorder(wxWindow *win,
 411                                     wxDC& dc,
 412                                     const wxRect& rect,
 413                                     int flags = 0)
 414         { m_rendererNative.DrawSplitterBorder(win, dc, rect, flags); }
 415
 416     virtual void DrawSplitterSash(wxWindow *win,
 417                                   wxDC& dc,
 418                                   const wxSize& size,
 419                                   wxCoord position,
 420                                   wxOrientation orient,
 421                                   int flags = 0)
 422         { m_rendererNative.DrawSplitterSash(win, dc, size,
 423                                             position, orient, flags); }
 424
 425     virtual void DrawComboBoxDropButton(wxWindow *win,
 426                                         wxDC& dc,
 427                                         const wxRect& rect,
 428                                         int flags = 0)
 429         { m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags); }
 430
 431     virtual void DrawDropArrow(wxWindow *win,
 432                                wxDC& dc,
 433                                const wxRect& rect,
 434                                int flags = 0)
 435         { m_rendererNative.DrawDropArrow(win, dc, rect, flags); }
 436
 437     virtual void DrawCheckBox(wxWindow *win,
 438                               wxDC& dc,
 439                               const wxRect& rect,
 440                               int flags = 0)
 441         { m_rendererNative.DrawCheckBox( win, dc, rect, flags ); }
 442
 443     virtual wxSize GetCheckBoxSize(wxWindow *win)
 444         { return m_rendererNative.GetCheckBoxSize(win); }
 445
 446     virtual void DrawPushButton(wxWindow *win,
 447                                 wxDC& dc,
 448                                 const wxRect& rect,
 449                                 int flags = 0)
 450         { m_rendererNative.DrawPushButton( win, dc, rect, flags ); }
 451
 452     virtual void DrawItemSelectionRect(wxWindow *win,
 453                                        wxDC& dc,
 454                                        const wxRect& rect,
 455                                        int flags = 0)
 456         { m_rendererNative.DrawItemSelectionRect( win, dc, rect, flags ); }
 457
 458     virtual void DrawFocusRect(wxWindow* win,
 459                                wxDC& dc,
 460                                const wxRect& rect,
 461                                int flags = 0)
 462         { m_rendererNative.DrawFocusRect( win, dc, rect, flags ); }
 463
 464     virtual void DrawChoice(wxWindow* win,
 465                             wxDC& dc,
 466                             const wxRect& rect,
 467                             int flags = 0)
 468         { m_rendererNative.DrawChoice( win, dc, rect, flags); }
 469
 470     virtual void DrawComboBox(wxWindow* win,
 471                               wxDC& dc,
 472                               const wxRect& rect,
 473                               int flags = 0)
 474         { m_rendererNative.DrawComboBox( win, dc, rect, flags); }
 475
 476     virtual void DrawTextCtrl(wxWindow* win,
 477                               wxDC& dc,
 478                               const wxRect& rect,
 479                               int flags = 0)
 480         { m_rendererNative.DrawTextCtrl( win, dc, rect, flags); }
 481
 482     virtual void DrawRadioBitmap(wxWindow* win,
 483                                  wxDC& dc,
 484                                  const wxRect& rect,
 485                                  int flags = 0)
 486         { m_rendererNative.DrawRadioBitmap(win, dc, rect, flags); }
 487
 488 #ifdef wxHAS_DRAW_TITLE_BAR_BITMAP
 489     virtual void DrawTitleBarBitmap(wxWindow *win,
 490                                     wxDC& dc,
 491                                     const wxRect& rect,
 492                                     wxTitleBarButton button,
 493                                     int flags = 0)
 494         { m_rendererNative.DrawTitleBarBitmap(win, dc, rect, button, flags); }
 495 #endif // wxHAS_DRAW_TITLE_BAR_BITMAP
 496
 497     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win)
 498         { return m_rendererNative.GetSplitterParams(win); }
 499
 500     virtual wxRendererVersion GetVersion() const
 501         { return m_rendererNative.GetVersion(); }
 502
 503 protected:
 504     wxRendererNative& m_rendererNative;
 505
 506     wxDECLARE_NO_COPY_CLASS(wxDelegateRendererNative);
 507 };
 508
 509 // ----------------------------------------------------------------------------
 510 // inline functions implementation
 511 // ----------------------------------------------------------------------------
 512
 513 #ifndef wxHAS_NATIVE_RENDERER
 514
 515 // default native renderer is the generic one then
 516 /* static */ inline
 517 wxRendererNative& wxRendererNative::GetDefault()
 518 {
 519     return GetGeneric();
 520 }
 521
 522 #endif // !wxHAS_NATIVE_RENDERER
 523
 524 #endif // _WX_RENDERER_H_