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 // ----------------------------------------------------------------------------
  45 // constants
  46 // ----------------------------------------------------------------------------
  47
  48 // control state flags used in wxRenderer and wxColourScheme
  49 enum
  50 {
  51     wxCONTROL_DISABLED   = 0x00000001,  // control is disabled
  52     wxCONTROL_FOCUSED    = 0x00000002,  // currently has keyboard focus
  53     wxCONTROL_PRESSED    = 0x00000004,  // (button) is pressed
  54     wxCONTROL_SPECIAL    = 0x00000008,  // control-specific bit:
  55     wxCONTROL_ISDEFAULT  = wxCONTROL_SPECIAL, // only for the buttons
  56     wxCONTROL_ISSUBMENU  = wxCONTROL_SPECIAL, // only for the menu items
  57     wxCONTROL_EXPANDED   = wxCONTROL_SPECIAL, // only for the tree items
  58     wxCONTROL_SIZEGRIP   = wxCONTROL_SPECIAL, // only for the status bar panes
  59     wxCONTROL_FLAT       = wxCONTROL_SPECIAL, // checkboxes only: flat border
  60     wxCONTROL_CURRENT    = 0x00000010,  // mouse is currently over the control
  61     wxCONTROL_SELECTED   = 0x00000020,  // selected item in e.g. listbox
  62     wxCONTROL_CHECKED    = 0x00000040,  // (check/radio button) is checked
  63     wxCONTROL_CHECKABLE  = 0x00000080,  // (menu) item can be checked
  64     wxCONTROL_UNDETERMINED = wxCONTROL_CHECKABLE, // (check) undetermined state
  65
  66     wxCONTROL_FLAGS_MASK = 0x000000ff,
  67
  68     // this is a pseudo flag not used directly by wxRenderer but rather by some
  69     // controls internally
  70     wxCONTROL_DIRTY      = 0x80000000
  71 };
  72
  73 // ----------------------------------------------------------------------------
  74 // helper structs
  75 // ----------------------------------------------------------------------------
  76
  77 // wxSplitterWindow parameters
  78 struct WXDLLIMPEXP_CORE wxSplitterRenderParams
  79 {
  80     // the only way to initialize this struct is by using this ctor
  81     wxSplitterRenderParams(wxCoord widthSash_, wxCoord border_, bool isSens_)
  82         : widthSash(widthSash_), border(border_), isHotSensitive(isSens_)
  83         {
  84         }
  85
  86     // the width of the splitter sash
  87     const wxCoord widthSash;
  88
  89     // the width of the border of the splitter window
  90     const wxCoord border;
  91
  92     // true if the splitter changes its appearance when the mouse is over it
  93     const bool isHotSensitive;
  94 };
  95
  96
  97 // extra optional parameters for DrawHeaderButton
  98 struct WXDLLIMPEXP_CORE wxHeaderButtonParams
  99 {
 100     wxHeaderButtonParams()
 101         : m_labelAlignment(wxALIGN_LEFT)
 102     { }
 103
 104     wxColour    m_arrowColour;
 105     wxColour    m_selectionColour;
 106     wxString    m_labelText;
 107     wxFont      m_labelFont;
 108     wxColour    m_labelColour;
 109     wxBitmap    m_labelBitmap;
 110     int         m_labelAlignment;
 111 };
 112
 113 enum wxHeaderSortIconType
 114 {
 115     wxHDR_SORT_ICON_NONE,        // Header button has no sort arrow
 116     wxHDR_SORT_ICON_UP,          // Header button an up sort arrow icon
 117     wxHDR_SORT_ICON_DOWN         // Header button a down sort arrow icon
 118 };
 119
 120
 121 // wxRendererNative interface version
 122 struct WXDLLIMPEXP_CORE wxRendererVersion
 123 {
 124     wxRendererVersion(int version_, int age_) : version(version_), age(age_) { }
 125
 126     // default copy ctor, assignment operator and dtor are ok
 127
 128     // the current version and age of wxRendererNative interface: different
 129     // versions are incompatible (in both ways) while the ages inside the same
 130     // version are upwards compatible, i.e. the version of the renderer must
 131     // match the version of the main program exactly while the age may be
 132     // highergreater or equal to it
 133     //
 134     // NB: don't forget to increment age after adding any new virtual function!
 135     enum
 136     {
 137         Current_Version = 1,
 138         Current_Age = 5
 139     };
 140
 141
 142     // check if the given version is compatible with the current one
 143     static bool IsCompatible(const wxRendererVersion& ver)
 144     {
 145         return ver.version == Current_Version && ver.age >= Current_Age;
 146     }
 147
 148     const int version;
 149     const int age;
 150 };
 151
 152 // ----------------------------------------------------------------------------
 153 // wxRendererNative: abstracts drawing methods needed by the native controls
 154 // ----------------------------------------------------------------------------
 155
 156 class WXDLLIMPEXP_CORE wxRendererNative
 157 {
 158 public:
 159     // drawing functions
 160     // -----------------
 161
 162     // draw the header control button (used by wxListCtrl) Returns optimal
 163     // width for the label contents.
 164     virtual int  DrawHeaderButton(wxWindow *win,
 165                                   wxDC& dc,
 166                                   const wxRect& rect,
 167                                   int flags = 0,
 168                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 169                                   wxHeaderButtonParams* params=NULL) = 0;
 170
 171
 172     // Draw the contents of a header control button (label, sort arrows, etc.)
 173     // Normally only called by DrawHeaderButton.
 174     virtual int  DrawHeaderButtonContents(wxWindow *win,
 175                                           wxDC& dc,
 176                                           const wxRect& rect,
 177                                           int flags = 0,
 178                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 179                                           wxHeaderButtonParams* params=NULL) = 0;
 180
 181     // Returns the default height of a header button, either a fixed platform
 182     // height if available, or a generic height based on the window's font.
 183     virtual int GetHeaderButtonHeight(wxWindow *win) = 0;
 184
 185
 186     // draw the expanded/collapsed icon for a tree control item
 187     virtual void DrawTreeItemButton(wxWindow *win,
 188                                     wxDC& dc,
 189                                     const wxRect& rect,
 190                                     int flags = 0) = 0;
 191
 192     // draw the border for sash window: this border must be such that the sash
 193     // drawn by DrawSash() blends into it well
 194     virtual void DrawSplitterBorder(wxWindow *win,
 195                                     wxDC& dc,
 196                                     const wxRect& rect,
 197                                     int flags = 0) = 0;
 198
 199     // draw a (vertical) sash
 200     virtual void DrawSplitterSash(wxWindow *win,
 201                                   wxDC& dc,
 202                                   const wxSize& size,
 203                                   wxCoord position,
 204                                   wxOrientation orient,
 205                                   int flags = 0) = 0;
 206
 207     // draw a combobox dropdown button
 208     //
 209     // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
 210     virtual void DrawComboBoxDropButton(wxWindow *win,
 211                                         wxDC& dc,
 212                                         const wxRect& rect,
 213                                         int flags = 0) = 0;
 214
 215     // draw a dropdown arrow
 216     //
 217     // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
 218     virtual void DrawDropArrow(wxWindow *win,
 219                                wxDC& dc,
 220                                const wxRect& rect,
 221                                int flags = 0) = 0;
 222
 223     // draw check button
 224     //
 225     // flags may use wxCONTROL_CHECKED, wxCONTROL_UNDETERMINED and wxCONTROL_CURRENT
 226     virtual void DrawCheckBox(wxWindow *win,
 227                               wxDC& dc,
 228                               const wxRect& rect,
 229                               int flags = 0) = 0;
 230
 231     // Returns the default size of a check box.
 232     virtual wxSize GetCheckBoxSize(wxWindow *win) = 0;
 233
 234     // draw blank button
 235     //
 236     // flags may use wxCONTROL_PRESSED, wxCONTROL_CURRENT and wxCONTROL_ISDEFAULT
 237     virtual void DrawPushButton(wxWindow *win,
 238                                 wxDC& dc,
 239                                 const wxRect& rect,
 240                                 int flags = 0) = 0;
 241
 242     // draw rectangle indicating that an item in e.g. a list control
 243     // has been selected or focused
 244     //
 245     // flags may use
 246     // wxCONTROL_SELECTED (item is selected, e.g. draw background)
 247     // wxCONTROL_CURRENT (item is the current item, e.g. dotted border)
 248     // wxCONTROL_FOCUSED (the whole control has focus, e.g. blue background vs. grey otherwise)
 249     virtual void DrawItemSelectionRect(wxWindow *win,
 250                                        wxDC& dc,
 251                                        const wxRect& rect,
 252                                        int flags = 0) = 0;
 253
 254     // draw the focus rectangle around the label contained in the given rect
 255     //
 256     // only wxCONTROL_SELECTED makes sense in flags here
 257     virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0) = 0;
 258
 259     // geometry functions
 260     // ------------------
 261
 262     // get the splitter parameters: the x field of the returned point is the
 263     // sash width and the y field is the border width
 264     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win) = 0;
 265
 266
 267     // pseudo constructors
 268     // -------------------
 269
 270     // return the currently used renderer
 271     static wxRendererNative& Get();
 272
 273     // return the generic implementation of the renderer
 274     static wxRendererNative& GetGeneric();
 275
 276     // return the default (native) implementation for this platform
 277     static wxRendererNative& GetDefault();
 278
 279
 280     // changing the global renderer
 281     // ----------------------------
 282
 283 #if wxUSE_DYNLIB_CLASS
 284     // load the renderer from the specified DLL, the returned pointer must be
 285     // deleted by caller if not NULL when it is not used any more
 286     static wxRendererNative *Load(const wxString& name);
 287 #endif // wxUSE_DYNLIB_CLASS
 288
 289     // set the renderer to use, passing NULL reverts to using the default
 290     // renderer
 291     //
 292     // return the previous renderer used with Set() or NULL if none
 293     static wxRendererNative *Set(wxRendererNative *renderer);
 294
 295
 296     // miscellaneous stuff
 297     // -------------------
 298
 299     // this function is used for version checking: Load() refuses to load any
 300     // DLLs implementing an older or incompatible version; it should be
 301     // implemented simply by returning wxRendererVersion::Current_XXX values
 302     virtual wxRendererVersion GetVersion() const = 0;
 303
 304     // virtual dtor for any base class
 305     virtual ~wxRendererNative();
 306 };
 307
 308 // ----------------------------------------------------------------------------
 309 // wxDelegateRendererNative: allows reuse of renderers code
 310 // ----------------------------------------------------------------------------
 311
 312 class WXDLLIMPEXP_CORE wxDelegateRendererNative : public wxRendererNative
 313 {
 314 public:
 315     wxDelegateRendererNative()
 316         : m_rendererNative(GetGeneric()) { }
 317
 318     wxDelegateRendererNative(wxRendererNative& rendererNative)
 319         : m_rendererNative(rendererNative) { }
 320
 321
 322     virtual int  DrawHeaderButton(wxWindow *win,
 323                                   wxDC& dc,
 324                                   const wxRect& rect,
 325                                   int flags = 0,
 326                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 327                                   wxHeaderButtonParams* params = NULL)
 328         { return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params); }
 329
 330     virtual int  DrawHeaderButtonContents(wxWindow *win,
 331                                           wxDC& dc,
 332                                           const wxRect& rect,
 333                                           int flags = 0,
 334                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 335                                           wxHeaderButtonParams* params = NULL)
 336         { return m_rendererNative.DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }
 337
 338     virtual int GetHeaderButtonHeight(wxWindow *win)
 339         { return m_rendererNative.GetHeaderButtonHeight(win); }
 340
 341     virtual void DrawTreeItemButton(wxWindow *win,
 342                                     wxDC& dc,
 343                                     const wxRect& rect,
 344                                     int flags = 0)
 345         { m_rendererNative.DrawTreeItemButton(win, dc, rect, flags); }
 346
 347     virtual void DrawSplitterBorder(wxWindow *win,
 348                                     wxDC& dc,
 349                                     const wxRect& rect,
 350                                     int flags = 0)
 351         { m_rendererNative.DrawSplitterBorder(win, dc, rect, flags); }
 352
 353     virtual void DrawSplitterSash(wxWindow *win,
 354                                   wxDC& dc,
 355                                   const wxSize& size,
 356                                   wxCoord position,
 357                                   wxOrientation orient,
 358                                   int flags = 0)
 359         { m_rendererNative.DrawSplitterSash(win, dc, size,
 360                                             position, orient, flags); }
 361
 362     virtual void DrawComboBoxDropButton(wxWindow *win,
 363                                         wxDC& dc,
 364                                         const wxRect& rect,
 365                                         int flags = 0)
 366         { m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags); }
 367
 368     virtual void DrawDropArrow(wxWindow *win,
 369                                wxDC& dc,
 370                                const wxRect& rect,
 371                                int flags = 0)
 372         { m_rendererNative.DrawDropArrow(win, dc, rect, flags); }
 373
 374     virtual void DrawCheckBox(wxWindow *win,
 375                               wxDC& dc,
 376                               const wxRect& rect,
 377                               int flags = 0 )
 378         { m_rendererNative.DrawCheckBox( win, dc, rect, flags ); }
 379
 380     virtual wxSize GetCheckBoxSize(wxWindow *win)
 381         { return m_rendererNative.GetCheckBoxSize(win); }
 382
 383     virtual void DrawPushButton(wxWindow *win,
 384                                 wxDC& dc,
 385                                 const wxRect& rect,
 386                                 int flags = 0 )
 387         { m_rendererNative.DrawPushButton( win, dc, rect, flags ); }
 388
 389     virtual void DrawItemSelectionRect(wxWindow *win,
 390                                        wxDC& dc,
 391                                        const wxRect& rect,
 392                                        int flags = 0 )
 393         { m_rendererNative.DrawItemSelectionRect( win, dc, rect, flags ); }
 394
 395     virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0)
 396         { m_rendererNative.DrawFocusRect( win, dc, rect, flags ); }
 397
 398     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win)
 399         { return m_rendererNative.GetSplitterParams(win); }
 400
 401     virtual wxRendererVersion GetVersion() const
 402         { return m_rendererNative.GetVersion(); }
 403
 404 protected:
 405     wxRendererNative& m_rendererNative;
 406
 407     DECLARE_NO_COPY_CLASS(wxDelegateRendererNative)
 408 };
 409
 410 // ----------------------------------------------------------------------------
 411 // inline functions implementation
 412 // ----------------------------------------------------------------------------
 413
 414 #ifndef wxHAS_NATIVE_RENDERER
 415
 416 // default native renderer is the generic one then
 417 /* static */ inline
 418 wxRendererNative& wxRendererNative::GetDefault()
 419 {
 420     return GetGeneric();
 421 }
 422
 423 #endif // !wxHAS_NATIVE_RENDERER
 424
 425 #endif // _WX_RENDERER_H_