include/wx/dvrenderers.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/dvrenderers.h
   3 // Purpose:     Declare all wxDataViewCtrl classes
   4 // Author:      Robert Roebling, Vadim Zeitlin
   5 // Created:     2009-11-08 (extracted from wx/dataview.h)
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2006 Robert Roebling
   8 //              (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_DVRENDERERS_H_
  13 #define _WX_DVRENDERERS_H_
  14
  15 /*
  16     Note about the structure of various headers: they're organized in a more
  17     complicated way than usual because of the various dependencies which are
  18     different for different ports. In any case the only public header, i.e. the
  19     one which can be included directly is wx/dataview.h. It, in turn, includes
  20     this one to define all the renderer classes.
  21
  22     We define the base wxDataViewRendererBase class first and then include a
  23     port-dependent wx/xxx/dvrenderer.h which defines wxDataViewRenderer itself.
  24     After this we can define wxDataViewRendererCustomBase (and maybe in the
  25     future base classes for other renderers if the need arises, i.e. if there
  26     is any non-trivial code or API which it makes sense to keep in common code)
  27     and include wx/xxx/dvrenderers.h (notice the plural) which defines all the
  28     rest of the renderer classes.
  29  */
  30
  31 class WXDLLIMPEXP_FWD_ADV wxDataViewCustomRenderer;
  32
  33 // ----------------------------------------------------------------------------
  34 // wxDataViewIconText: helper class used by wxDataViewIconTextRenderer
  35 // ----------------------------------------------------------------------------
  36
  37 class WXDLLIMPEXP_ADV wxDataViewIconText : public wxObject
  38 {
  39 public:
  40     wxDataViewIconText( const wxString &text = wxEmptyString,
  41                         const wxIcon& icon = wxNullIcon )
  42         : m_text(text),
  43           m_icon(icon)
  44     { }
  45
  46     wxDataViewIconText( const wxDataViewIconText &other )
  47         : wxObject(),
  48           m_text(other.m_text),
  49           m_icon(other.m_icon)
  50     { }
  51
  52     void SetText( const wxString &text ) { m_text = text; }
  53     wxString GetText() const             { return m_text; }
  54     void SetIcon( const wxIcon &icon )   { m_icon = icon; }
  55     const wxIcon &GetIcon() const        { return m_icon; }
  56
  57 private:
  58     wxString    m_text;
  59     wxIcon      m_icon;
  60
  61     DECLARE_DYNAMIC_CLASS(wxDataViewIconText)
  62 };
  63
  64 inline
  65 bool operator==(const wxDataViewIconText& left, const wxDataViewIconText& right)
  66 {
  67     return left.GetText() == right.GetText() &&
  68              left.GetIcon().IsSameAs(right.GetIcon());
  69 }
  70
  71 inline
  72 bool operator!=(const wxDataViewIconText& left, const wxDataViewIconText& right)
  73 {
  74     return !(left == right);
  75 }
  76
  77 DECLARE_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)
  78
  79 // ----------------------------------------------------------------------------
  80 // wxDataViewRendererBase
  81 // ----------------------------------------------------------------------------
  82
  83 enum wxDataViewCellMode
  84 {
  85     wxDATAVIEW_CELL_INERT,
  86     wxDATAVIEW_CELL_ACTIVATABLE,
  87     wxDATAVIEW_CELL_EDITABLE
  88 };
  89
  90 enum wxDataViewCellRenderState
  91 {
  92     wxDATAVIEW_CELL_SELECTED    = 1,
  93     wxDATAVIEW_CELL_PRELIT      = 2,
  94     wxDATAVIEW_CELL_INSENSITIVE = 4,
  95     wxDATAVIEW_CELL_FOCUSED     = 8
  96 };
  97
  98 class WXDLLIMPEXP_ADV wxDataViewRendererBase: public wxObject
  99 {
 100 public:
 101     wxDataViewRendererBase( const wxString &varianttype,
 102                             wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
 103                             int alignment = wxDVR_DEFAULT_ALIGNMENT );
 104     virtual ~wxDataViewRendererBase();
 105
 106     virtual bool Validate( wxVariant& WXUNUSED(value) )
 107         { return true; }
 108
 109     void SetOwner( wxDataViewColumn *owner )    { m_owner = owner; }
 110     wxDataViewColumn* GetOwner() const          { return m_owner; }
 111
 112     // renderer value and attributes: SetValue() and SetAttr() are called
 113     // before a cell is rendered using this renderer
 114     virtual bool SetValue(const wxVariant& value) = 0;
 115     virtual bool GetValue(wxVariant& value) const = 0;
 116
 117     virtual void SetAttr(const wxDataViewItemAttr& WXUNUSED(attr)) { }
 118
 119     wxString GetVariantType() const             { return m_variantType; }
 120
 121     // renderer properties:
 122     virtual void SetMode( wxDataViewCellMode mode ) = 0;
 123     virtual wxDataViewCellMode GetMode() const = 0;
 124
 125     // NOTE: Set/GetAlignment do not take/return a wxAlignment enum but
 126     //       rather an "int"; that's because for rendering cells it's allowed
 127     //       to combine alignment flags (e.g. wxALIGN_LEFT|wxALIGN_BOTTOM)
 128     virtual void SetAlignment( int align ) = 0;
 129     virtual int GetAlignment() const = 0;
 130
 131     // enable or disable (if called with wxELLIPSIZE_NONE) replacing parts of
 132     // the item text (hence this only makes sense for renderers showing
 133     // text...) with ellipsis in order to make it fit the column width
 134     virtual void EnableEllipsize(wxEllipsizeMode mode = wxELLIPSIZE_MIDDLE) = 0;
 135     void DisableEllipsize() { EnableEllipsize(wxELLIPSIZE_NONE); }
 136
 137     virtual wxEllipsizeMode GetEllipsizeMode() const = 0;
 138
 139     // in-place editing
 140     virtual bool HasEditorCtrl() const
 141         { return false; }
 142     virtual wxControl* CreateEditorCtrl(wxWindow * WXUNUSED(parent),
 143                                         wxRect WXUNUSED(labelRect),
 144                                         const wxVariant& WXUNUSED(value))
 145         { return NULL; }
 146     virtual bool GetValueFromEditorCtrl(wxControl * WXUNUSED(editor),
 147                                         wxVariant& WXUNUSED(value))
 148         { return false; }
 149
 150     virtual bool StartEditing( const wxDataViewItem &item, wxRect labelRect );
 151     virtual void CancelEditing();
 152     virtual bool FinishEditing();
 153
 154     wxControl *GetEditorCtrl() { return m_editorCtrl; }
 155
 156 protected:
 157     // Called from {Cancel,Finish}Editing() to cleanup m_editorCtrl
 158     void DestroyEditControl();
 159
 160     wxString                m_variantType;
 161     wxDataViewColumn       *m_owner;
 162     wxWeakRef<wxControl>    m_editorCtrl;
 163     wxDataViewItem          m_item; // for m_editorCtrl
 164
 165     // internal utility:
 166     const wxDataViewCtrl* GetView() const;
 167
 168 protected:
 169     DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewRendererBase)
 170 };
 171
 172 // include the real wxDataViewRenderer declaration for the native ports
 173 #ifdef wxHAS_GENERIC_DATAVIEWCTRL
 174     // in the generic implementation there is no real wxDataViewRenderer, all
 175     // renderers are custom so it's the same as wxDataViewCustomRenderer and
 176     // wxDataViewCustomRendererBase derives from wxDataViewRendererBase directly
 177     //
 178     // this is a rather ugly hack but unfortunately it just doesn't seem to be
 179     // possible to have the same class hierarchy in all ports and avoid
 180     // duplicating the entire wxDataViewCustomRendererBase in the generic
 181     // wxDataViewRenderer class (well, we could use a mix-in but this would
 182     // make classes hierarchy non linear and arguably even more complex)
 183     #define wxDataViewCustomRendererRealBase wxDataViewRendererBase
 184 #else
 185     #if defined(__WXGTK20__)
 186         #include "wx/gtk/dvrenderer.h"
 187     #elif defined(__WXMAC__)
 188         #include "wx/osx/dvrenderer.h"
 189     #else
 190         #error "unknown native wxDataViewCtrl implementation"
 191     #endif
 192     #define wxDataViewCustomRendererRealBase wxDataViewRenderer
 193 #endif
 194
 195 // ----------------------------------------------------------------------------
 196 // wxDataViewCustomRendererBase
 197 // ----------------------------------------------------------------------------
 198
 199 class WXDLLIMPEXP_ADV wxDataViewCustomRendererBase
 200     : public wxDataViewCustomRendererRealBase
 201 {
 202 public:
 203     // Constructor must specify the usual renderer parameters which we simply
 204     // pass to the base class
 205     wxDataViewCustomRendererBase(const wxString& varianttype = "string",
 206                                  wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
 207                                  int align = wxDVR_DEFAULT_ALIGNMENT)
 208         : wxDataViewCustomRendererRealBase(varianttype, mode, align)
 209     {
 210     }
 211
 212
 213     // Render the item using the current value (returned by GetValue()).
 214     virtual bool Render(wxRect cell, wxDC *dc, int state) = 0;
 215
 216     // Return the size of the item appropriate to its current value.
 217     virtual wxSize GetSize() const = 0;
 218
 219     // Define virtual function which are called when the item is activated
 220     // (double-clicked or Enter is pressed on it), clicked or the user starts
 221     // to drag it: by default they all simply return false indicating that the
 222     // events are not handled
 223
 224     virtual bool Activate(wxRect WXUNUSED(cell),
 225                           wxDataViewModel *WXUNUSED(model),
 226                           const wxDataViewItem & WXUNUSED(item),
 227                           unsigned int WXUNUSED(col))
 228         { return false; }
 229
 230     virtual bool LeftClick(wxPoint WXUNUSED(cursor),
 231                            wxRect WXUNUSED(cell),
 232                            wxDataViewModel *WXUNUSED(model),
 233                            const wxDataViewItem & WXUNUSED(item),
 234                            unsigned int WXUNUSED(col) )
 235         { return false; }
 236
 237     virtual bool StartDrag(wxPoint WXUNUSED(cursor),
 238                            wxRect WXUNUSED(cell),
 239                            wxDataViewModel *WXUNUSED(model),
 240                            const wxDataViewItem & WXUNUSED(item),
 241                            unsigned int WXUNUSED(col) )
 242         { return false; }
 243
 244
 245     // Helper which can be used by Render() implementation in the derived
 246     // classes: it will draw the text in the same manner as the standard
 247     // renderers do.
 248     virtual void RenderText(const wxString& text,
 249                             int xoffset,
 250                             wxRect cell,
 251                             wxDC *dc,
 252                             int state);
 253
 254
 255     // Override the base class virtual method to simply store the attribute so
 256     // that it can be accessed using GetAttr() from Render() if needed.
 257     virtual void SetAttr(const wxDataViewItemAttr& attr) { m_attr = attr; }
 258     const wxDataViewItemAttr& GetAttr() const { return m_attr; }
 259
 260
 261     // Implementation only from now on
 262
 263     // Retrieve the DC to use for drawing. This is implemented in derived
 264     // platform-specific classes.
 265     virtual wxDC *GetDC() = 0;
 266
 267     // Prepare DC to use attributes and call Render().
 268     void WXCallRender(wxRect rect, wxDC *dc, int state);
 269
 270 private:
 271     wxDataViewItemAttr m_attr;
 272
 273     wxDECLARE_NO_COPY_CLASS(wxDataViewCustomRendererBase);
 274 };
 275
 276 // include the declaration of all the other renderers to get the real
 277 // wxDataViewCustomRenderer from which we need to inherit below
 278 #ifdef wxHAS_GENERIC_DATAVIEWCTRL
 279     // because of the different renderer classes hierarchy in the generic
 280     // version, as explained above, we can include the header defining
 281     // wxDataViewRenderer only here and not before wxDataViewCustomRendererBase
 282     // declaration as for the native ports
 283     #include "wx/generic/dvrenderer.h"
 284     #include "wx/generic/dvrenderers.h"
 285 #elif defined(__WXGTK20__)
 286     #include "wx/gtk/dvrenderers.h"
 287 #elif defined(__WXMAC__)
 288     #include "wx/osx/dvrenderers.h"
 289 #else
 290     #error "unknown native wxDataViewCtrl implementation"
 291 #endif
 292
 293 // ----------------------------------------------------------------------------
 294 // wxDataViewSpinRenderer
 295 // ----------------------------------------------------------------------------
 296
 297 class WXDLLIMPEXP_ADV wxDataViewSpinRenderer: public wxDataViewCustomRenderer
 298 {
 299 public:
 300     wxDataViewSpinRenderer( int min, int max,
 301                             wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 302                             int alignment = wxDVR_DEFAULT_ALIGNMENT );
 303     virtual bool HasEditorCtrl() const { return true; }
 304     virtual wxControl* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
 305     virtual bool GetValueFromEditorCtrl( wxControl* editor, wxVariant &value );
 306     virtual bool Render( wxRect rect, wxDC *dc, int state );
 307     virtual wxSize GetSize() const;
 308     virtual bool SetValue( const wxVariant &value );
 309     virtual bool GetValue( wxVariant &value ) const;
 310
 311 private:
 312     long    m_data;
 313     long    m_min,m_max;
 314 };
 315
 316 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXOSX_CARBON__)
 317
 318 // ----------------------------------------------------------------------------
 319 // wxDataViewChoiceRenderer
 320 // ----------------------------------------------------------------------------
 321
 322 class WXDLLIMPEXP_ADV wxDataViewChoiceRenderer: public wxDataViewCustomRenderer
 323 {
 324 public:
 325     wxDataViewChoiceRenderer( const wxArrayString &choices,
 326                             wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 327                             int alignment = wxDVR_DEFAULT_ALIGNMENT );
 328     virtual bool HasEditorCtrl() const { return true; }
 329     virtual wxControl* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
 330     virtual bool GetValueFromEditorCtrl( wxControl* editor, wxVariant &value );
 331     virtual bool Render( wxRect rect, wxDC *dc, int state );
 332     virtual wxSize GetSize() const;
 333     virtual bool SetValue( const wxVariant &value );
 334     virtual bool GetValue( wxVariant &value ) const;
 335
 336     wxString GetChoice(size_t index) const { return m_choices[index]; }
 337     const wxArrayString& GetChoices() const { return m_choices; }
 338
 339 private:
 340     wxArrayString m_choices;
 341     wxString      m_data;
 342 };
 343
 344 // ----------------------------------------------------------------------------
 345 // wxDataViewChoiceByIndexRenderer
 346 // ----------------------------------------------------------------------------
 347
 348 class WXDLLIMPEXP_ADV wxDataViewChoiceByIndexRenderer: public wxDataViewChoiceRenderer
 349 {
 350 public:
 351     wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
 352                               wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 353                               int alignment = wxDVR_DEFAULT_ALIGNMENT );
 354
 355     virtual wxControl* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
 356     virtual bool GetValueFromEditorCtrl( wxControl* editor, wxVariant &value );
 357
 358     virtual bool SetValue( const wxVariant &value );
 359     virtual bool GetValue( wxVariant &value ) const;
 360 };
 361
 362
 363 #endif // generic or Carbon versions
 364
 365 // this class is obsolete, its functionality was merged in
 366 // wxDataViewTextRenderer itself now, don't use it any more
 367 #define wxDataViewTextRendererAttr wxDataViewTextRenderer
 368
 369 #endif // _WX_DVRENDERERS_H_
 370