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