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 because there is no way to
 308     // render standard title bar buttons under the other platforms, the best
 309     // can be done is to use normal (only) images which wxArtProvider provides
 310     // for wxART_HELP and wxART_CLOSE (but not any other title bar buttons)
 311     virtual void DrawTitleBarBitmap(wxWindow *win,
 312                                     wxDC& dc,
 313                                     const wxRect& rect,
 314                                     wxTitleBarButton button,
 315                                     int flags = 0) = 0;
 316 #endif // wxHAS_DRAW_TITLE_BAR_BITMAP
 317
 318
 319     // geometry functions
 320     // ------------------
 321
 322     // get the splitter parameters: the x field of the returned point is the
 323     // sash width and the y field is the border width
 324     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win) = 0;
 325
 326
 327     // pseudo constructors
 328     // -------------------
 329
 330     // return the currently used renderer
 331     static wxRendererNative& Get();
 332
 333     // return the generic implementation of the renderer
 334     static wxRendererNative& GetGeneric();
 335
 336     // return the default (native) implementation for this platform
 337     static wxRendererNative& GetDefault();
 338
 339
 340     // changing the global renderer
 341     // ----------------------------
 342
 343 #if wxUSE_DYNLIB_CLASS
 344     // load the renderer from the specified DLL, the returned pointer must be
 345     // deleted by caller if not NULL when it is not used any more
 346     static wxRendererNative *Load(const wxString& name);
 347 #endif // wxUSE_DYNLIB_CLASS
 348
 349     // set the renderer to use, passing NULL reverts to using the default
 350     // renderer
 351     //
 352     // return the previous renderer used with Set() or NULL if none
 353     static wxRendererNative *Set(wxRendererNative *renderer);
 354
 355
 356     // miscellaneous stuff
 357     // -------------------
 358
 359     // this function is used for version checking: Load() refuses to load any
 360     // DLLs implementing an older or incompatible version; it should be
 361     // implemented simply by returning wxRendererVersion::Current_XXX values
 362     virtual wxRendererVersion GetVersion() const = 0;
 363
 364     // virtual dtor for any base class
 365     virtual ~wxRendererNative();
 366 };
 367
 368 // ----------------------------------------------------------------------------
 369 // wxDelegateRendererNative: allows reuse of renderers code
 370 // ----------------------------------------------------------------------------
 371
 372 class WXDLLIMPEXP_CORE wxDelegateRendererNative : public wxRendererNative
 373 {
 374 public:
 375     wxDelegateRendererNative()
 376         : m_rendererNative(GetGeneric()) { }
 377
 378     wxDelegateRendererNative(wxRendererNative& rendererNative)
 379         : m_rendererNative(rendererNative) { }
 380
 381
 382     virtual int  DrawHeaderButton(wxWindow *win,
 383                                   wxDC& dc,
 384                                   const wxRect& rect,
 385                                   int flags = 0,
 386                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 387                                   wxHeaderButtonParams* params = NULL)
 388         { return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params); }
 389
 390     virtual int  DrawHeaderButtonContents(wxWindow *win,
 391                                           wxDC& dc,
 392                                           const wxRect& rect,
 393                                           int flags = 0,
 394                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 395                                           wxHeaderButtonParams* params = NULL)
 396         { return m_rendererNative.DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }
 397
 398     virtual int GetHeaderButtonHeight(wxWindow *win)
 399         { return m_rendererNative.GetHeaderButtonHeight(win); }
 400
 401     virtual void DrawTreeItemButton(wxWindow *win,
 402                                     wxDC& dc,
 403                                     const wxRect& rect,
 404                                     int flags = 0)
 405         { m_rendererNative.DrawTreeItemButton(win, dc, rect, flags); }
 406
 407     virtual void DrawSplitterBorder(wxWindow *win,
 408                                     wxDC& dc,
 409                                     const wxRect& rect,
 410                                     int flags = 0)
 411         { m_rendererNative.DrawSplitterBorder(win, dc, rect, flags); }
 412
 413     virtual void DrawSplitterSash(wxWindow *win,
 414                                   wxDC& dc,
 415                                   const wxSize& size,
 416                                   wxCoord position,
 417                                   wxOrientation orient,
 418                                   int flags = 0)
 419         { m_rendererNative.DrawSplitterSash(win, dc, size,
 420                                             position, orient, flags); }
 421
 422     virtual void DrawComboBoxDropButton(wxWindow *win,
 423                                         wxDC& dc,
 424                                         const wxRect& rect,
 425                                         int flags = 0)
 426         { m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags); }
 427
 428     virtual void DrawDropArrow(wxWindow *win,
 429                                wxDC& dc,
 430                                const wxRect& rect,
 431                                int flags = 0)
 432         { m_rendererNative.DrawDropArrow(win, dc, rect, flags); }
 433
 434     virtual void DrawCheckBox(wxWindow *win,
 435                               wxDC& dc,
 436                               const wxRect& rect,
 437                               int flags = 0)
 438         { m_rendererNative.DrawCheckBox( win, dc, rect, flags ); }
 439
 440     virtual wxSize GetCheckBoxSize(wxWindow *win)
 441         { return m_rendererNative.GetCheckBoxSize(win); }
 442
 443     virtual void DrawPushButton(wxWindow *win,
 444                                 wxDC& dc,
 445                                 const wxRect& rect,
 446                                 int flags = 0)
 447         { m_rendererNative.DrawPushButton( win, dc, rect, flags ); }
 448
 449     virtual void DrawItemSelectionRect(wxWindow *win,
 450                                        wxDC& dc,
 451                                        const wxRect& rect,
 452                                        int flags = 0)
 453         { m_rendererNative.DrawItemSelectionRect( win, dc, rect, flags ); }
 454
 455     virtual void DrawFocusRect(wxWindow* win,
 456                                wxDC& dc,
 457                                const wxRect& rect,
 458                                int flags = 0)
 459         { m_rendererNative.DrawFocusRect( win, dc, rect, flags ); }
 460
 461     virtual void DrawChoice(wxWindow* win,
 462                             wxDC& dc,
 463                             const wxRect& rect,
 464                             int flags = 0)
 465         { m_rendererNative.DrawChoice( win, dc, rect, flags); }
 466
 467     virtual void DrawComboBox(wxWindow* win,
 468                               wxDC& dc,
 469                               const wxRect& rect,
 470                               int flags = 0)
 471         { m_rendererNative.DrawComboBox( win, dc, rect, flags); }
 472
 473     virtual void DrawTextCtrl(wxWindow* win,
 474                               wxDC& dc,
 475                               const wxRect& rect,
 476                               int flags = 0)
 477         { m_rendererNative.DrawTextCtrl( win, dc, rect, flags); }
 478
 479     virtual void DrawRadioBitmap(wxWindow* win,
 480                                  wxDC& dc,
 481                                  const wxRect& rect,
 482                                  int flags = 0)
 483         { m_rendererNative.DrawRadioBitmap(win, dc, rect, flags); }
 484
 485 #ifdef wxHAS_DRAW_TITLE_BAR_BITMAP
 486     virtual void DrawTitleBarBitmap(wxWindow *win,
 487                                     wxDC& dc,
 488                                     const wxRect& rect,
 489                                     wxTitleBarButton button,
 490                                     int flags = 0)
 491         { m_rendererNative.DrawTitleBarBitmap(win, dc, rect, button, flags); }
 492 #endif // wxHAS_DRAW_TITLE_BAR_BITMAP
 493
 494     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win)
 495         { return m_rendererNative.GetSplitterParams(win); }
 496
 497     virtual wxRendererVersion GetVersion() const
 498         { return m_rendererNative.GetVersion(); }
 499
 500 protected:
 501     wxRendererNative& m_rendererNative;
 502
 503     wxDECLARE_NO_COPY_CLASS(wxDelegateRendererNative);
 504 };
 505
 506 // ----------------------------------------------------------------------------
 507 // inline functions implementation
 508 // ----------------------------------------------------------------------------
 509
 510 #ifndef wxHAS_NATIVE_RENDERER
 511
 512 // default native renderer is the generic one then
 513 /* static */ inline
 514 wxRendererNative& wxRendererNative::GetDefault()
 515 {
 516     return GetGeneric();
 517 }
 518
 519 #endif // !wxHAS_NATIVE_RENDERER
 520
 521 #endif // _WX_RENDERER_H_