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
  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_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 WXDLLEXPORT 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 WXDLLEXPORT 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     wxHDR_SORT_ICON_NONE,        // Header button has no sort arrow
 115     wxHDR_SORT_ICON_UP,          // Header button an an up sort arrow icon
 116     wxHDR_SORT_ICON_DOWN         // Header button an a down sort arrow icon
 117 };
 118
 119
 120 // wxRendererNative interface version
 121 struct WXDLLEXPORT wxRendererVersion
 122 {
 123     wxRendererVersion(int version_, int age_) : version(version_), age(age_) { }
 124
 125     // default copy ctor, assignment operator and dtor are ok
 126
 127     // the current version and age of wxRendererNative interface: different
 128     // versions are incompatible (in both ways) while the ages inside the same
 129     // version are upwards compatible, i.e. the version of the renderer must
 130     // match the version of the main program exactly while the age may be
 131     // highergreater or equal to it
 132     //
 133     // NB: don't forget to increment age after adding any new virtual function!
 134     enum
 135     {
 136         Current_Version = 1,
 137         Current_Age = 5
 138     };
 139
 140
 141     // check if the given version is compatible with the current one
 142     static bool IsCompatible(const wxRendererVersion& ver)
 143     {
 144         return ver.version == Current_Version && ver.age >= Current_Age;
 145     }
 146
 147     const int version;
 148     const int age;
 149 };
 150
 151 // ----------------------------------------------------------------------------
 152 // wxRendererNative: abstracts drawing methods needed by the native controls
 153 // ----------------------------------------------------------------------------
 154
 155 class WXDLLEXPORT wxRendererNative
 156 {
 157 public:
 158     // drawing functions
 159     // -----------------
 160
 161     // draw the header control button (used by wxListCtrl) Returns optimal
 162     // width for the label contents.
 163     virtual int  DrawHeaderButton(wxWindow *win,
 164                                   wxDC& dc,
 165                                   const wxRect& rect,
 166                                   int flags = 0,
 167                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 168                                   wxHeaderButtonParams* params=NULL) = 0;
 169
 170
 171     // Draw the contents of a header control button (label, sort arrows, etc.)
 172     // Normally only called by DrawHeaderButton.
 173     virtual int  DrawHeaderButtonContents(wxWindow *win,
 174                                           wxDC& dc,
 175                                           const wxRect& rect,
 176                                           int flags = 0,
 177                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 178                                           wxHeaderButtonParams* params=NULL) = 0;
 179
 180     // Returns the default height of a header button, either a fixed platform
 181     // height if available, or a generic height based on the window's font.
 182     virtual int GetHeaderButtonHeight(wxWindow *win) = 0;
 183
 184
 185     // draw the expanded/collapsed icon for a tree control item
 186     virtual void DrawTreeItemButton(wxWindow *win,
 187                                     wxDC& dc,
 188                                     const wxRect& rect,
 189                                     int flags = 0) = 0;
 190
 191     // draw the border for sash window: this border must be such that the sash
 192     // drawn by DrawSash() blends into it well
 193     virtual void DrawSplitterBorder(wxWindow *win,
 194                                     wxDC& dc,
 195                                     const wxRect& rect,
 196                                     int flags = 0) = 0;
 197
 198     // draw a (vertical) sash
 199     virtual void DrawSplitterSash(wxWindow *win,
 200                                   wxDC& dc,
 201                                   const wxSize& size,
 202                                   wxCoord position,
 203                                   wxOrientation orient,
 204                                   int flags = 0) = 0;
 205
 206     // draw a combobox dropdown button
 207     //
 208     // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
 209     virtual void DrawComboBoxDropButton(wxWindow *win,
 210                                         wxDC& dc,
 211                                         const wxRect& rect,
 212                                         int flags = 0) = 0;
 213
 214     // draw a dropdown arrow
 215     //
 216     // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
 217     virtual void DrawDropArrow(wxWindow *win,
 218                                wxDC& dc,
 219                                const wxRect& rect,
 220                                int flags = 0) = 0;
 221
 222     // draw check button
 223     //
 224     // flags may use wxCONTROL_CHECKED, wxCONTROL_UNDETERMINED and wxCONTROL_CURRENT
 225     virtual void DrawCheckBox(wxWindow *win,
 226                               wxDC& dc,
 227                               const wxRect& rect,
 228                               int flags = 0) = 0;
 229
 230     // draw blank button
 231     //
 232     // flags may use wxCONTROL_PRESSED, wxCONTROL_CURRENT and wxCONTROL_ISDEFAULT
 233     virtual void DrawPushButton(wxWindow *win,
 234                                 wxDC& dc,
 235                                 const wxRect& rect,
 236                                 int flags = 0) = 0;
 237
 238     // draw rectangle indicating that an item in e.g. a list control
 239     // has been selected or focused
 240     //
 241     // flags may use
 242     // wxCONTROL_SELECTED (item is selected, e.g. draw background)
 243     // wxCONTROL_CURRENT (item is the current item, e.g. dotted border)
 244     // wxCONTROL_FOCUSED (the whole control has focus, e.g. blue background vs. grey otherwise)
 245     virtual void DrawItemSelectionRect(wxWindow *win,
 246                                        wxDC& dc,
 247                                        const wxRect& rect,
 248                                        int flags = 0) = 0;
 249
 250     // geometry functions
 251     // ------------------
 252
 253     // get the splitter parameters: the x field of the returned point is the
 254     // sash width and the y field is the border width
 255     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win) = 0;
 256
 257
 258     // pseudo constructors
 259     // -------------------
 260
 261     // return the currently used renderer
 262     static wxRendererNative& Get();
 263
 264     // return the generic implementation of the renderer
 265     static wxRendererNative& GetGeneric();
 266
 267     // return the default (native) implementation for this platform
 268     static wxRendererNative& GetDefault();
 269
 270
 271     // changing the global renderer
 272     // ----------------------------
 273
 274 #if wxUSE_DYNLIB_CLASS
 275     // load the renderer from the specified DLL, the returned pointer must be
 276     // deleted by caller if not NULL when it is not used any more
 277     static wxRendererNative *Load(const wxString& name);
 278 #endif // wxUSE_DYNLIB_CLASS
 279
 280     // set the renderer to use, passing NULL reverts to using the default
 281     // renderer
 282     //
 283     // return the previous renderer used with Set() or NULL if none
 284     static wxRendererNative *Set(wxRendererNative *renderer);
 285
 286
 287     // miscellaneous stuff
 288     // -------------------
 289
 290     // this function is used for version checking: Load() refuses to load any
 291     // DLLs implementing an older or incompatible version; it should be
 292     // implemented simply by returning wxRendererVersion::Current_XXX values
 293     virtual wxRendererVersion GetVersion() const = 0;
 294
 295     // virtual dtor for any base class
 296     virtual ~wxRendererNative();
 297 };
 298
 299 // ----------------------------------------------------------------------------
 300 // wxDelegateRendererNative: allows reuse of renderers code
 301 // ----------------------------------------------------------------------------
 302
 303 class WXDLLEXPORT wxDelegateRendererNative : public wxRendererNative
 304 {
 305 public:
 306     wxDelegateRendererNative()
 307         : m_rendererNative(GetGeneric()) { }
 308
 309     wxDelegateRendererNative(wxRendererNative& rendererNative)
 310         : m_rendererNative(rendererNative) { }
 311
 312
 313     virtual int  DrawHeaderButton(wxWindow *win,
 314                                   wxDC& dc,
 315                                   const wxRect& rect,
 316                                   int flags = 0,
 317                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 318                                   wxHeaderButtonParams* params = NULL)
 319         { return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params); }
 320
 321     virtual int  DrawHeaderButtonContents(wxWindow *win,
 322                                           wxDC& dc,
 323                                           const wxRect& rect,
 324                                           int flags = 0,
 325                                           wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
 326                                           wxHeaderButtonParams* params = NULL)
 327         { return m_rendererNative.DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }
 328
 329     virtual int GetHeaderButtonHeight(wxWindow *win)
 330         { return m_rendererNative.GetHeaderButtonHeight(win); }
 331
 332     virtual void DrawTreeItemButton(wxWindow *win,
 333                                     wxDC& dc,
 334                                     const wxRect& rect,
 335                                     int flags = 0)
 336         { m_rendererNative.DrawTreeItemButton(win, dc, rect, flags); }
 337
 338     virtual void DrawSplitterBorder(wxWindow *win,
 339                                     wxDC& dc,
 340                                     const wxRect& rect,
 341                                     int flags = 0)
 342         { m_rendererNative.DrawSplitterBorder(win, dc, rect, flags); }
 343
 344     virtual void DrawSplitterSash(wxWindow *win,
 345                                   wxDC& dc,
 346                                   const wxSize& size,
 347                                   wxCoord position,
 348                                   wxOrientation orient,
 349                                   int flags = 0)
 350         { m_rendererNative.DrawSplitterSash(win, dc, size,
 351                                             position, orient, flags); }
 352
 353     virtual void DrawComboBoxDropButton(wxWindow *win,
 354                                         wxDC& dc,
 355                                         const wxRect& rect,
 356                                         int flags = 0)
 357         { m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags); }
 358
 359     virtual void DrawDropArrow(wxWindow *win,
 360                                wxDC& dc,
 361                                const wxRect& rect,
 362                                int flags = 0)
 363         { m_rendererNative.DrawDropArrow(win, dc, rect, flags); }
 364
 365     virtual void DrawCheckBox(wxWindow *win,
 366                               wxDC& dc,
 367                               const wxRect& rect,
 368                               int flags = 0 )
 369         { m_rendererNative.DrawCheckBox( win, dc, rect, flags ); }
 370
 371     virtual void DrawPushButton(wxWindow *win,
 372                                 wxDC& dc,
 373                                 const wxRect& rect,
 374                                 int flags = 0 )
 375         { m_rendererNative.DrawPushButton( win, dc, rect, flags ); }
 376
 377     virtual void DrawItemSelectionRect(wxWindow *win,
 378                                        wxDC& dc,
 379                                        const wxRect& rect,
 380                                        int flags = 0 )
 381         { m_rendererNative.DrawItemSelectionRect( win, dc, rect, flags ); }
 382
 383     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win)
 384         { return m_rendererNative.GetSplitterParams(win); }
 385
 386     virtual wxRendererVersion GetVersion() const
 387         { return m_rendererNative.GetVersion(); }
 388
 389 protected:
 390     wxRendererNative& m_rendererNative;
 391
 392     DECLARE_NO_COPY_CLASS(wxDelegateRendererNative)
 393 };
 394
 395 // ----------------------------------------------------------------------------
 396 // inline functions implementation
 397 // ----------------------------------------------------------------------------
 398
 399 #ifndef wxHAS_NATIVE_RENDERER
 400
 401 // default native renderer is the generic one then
 402 /* static */ inline
 403 wxRendererNative& wxRendererNative::GetDefault()
 404 {
 405     return GetGeneric();
 406 }
 407
 408 #endif // !wxHAS_NATIVE_RENDERER
 409
 410 #endif // _WX_RENDERER_H_