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     bool IsSameAs(const wxDataViewIconText& other) const
  58     {
  59         return m_text == other.m_text && m_icon.IsSameAs(other.m_icon);
  60     }
  61
  62     bool operator==(const wxDataViewIconText& other) const
  63     {
  64         return IsSameAs(other);
  65     }
  66
  67     bool operator!=(const wxDataViewIconText& other) const
  68     {
  69         return !IsSameAs(other);
  70     }
  71
  72 private:
  73     wxString    m_text;
  74     wxIcon      m_icon;
  75
  76     DECLARE_DYNAMIC_CLASS(wxDataViewIconText)
  77 };
  78
  79 DECLARE_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)
  80
  81 // ----------------------------------------------------------------------------
  82 // wxDataViewRendererBase
  83 // ----------------------------------------------------------------------------
  84
  85 enum wxDataViewCellMode
  86 {
  87     wxDATAVIEW_CELL_INERT,
  88     wxDATAVIEW_CELL_ACTIVATABLE,
  89     wxDATAVIEW_CELL_EDITABLE
  90 };
  91
  92 enum wxDataViewCellRenderState
  93 {
  94     wxDATAVIEW_CELL_SELECTED    = 1,
  95     wxDATAVIEW_CELL_PRELIT      = 2,
  96     wxDATAVIEW_CELL_INSENSITIVE = 4,
  97     wxDATAVIEW_CELL_FOCUSED     = 8
  98 };
  99
 100 class WXDLLIMPEXP_ADV wxDataViewRendererBase: public wxObject
 101 {
 102 public:
 103     wxDataViewRendererBase( const wxString &varianttype,
 104                             wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
 105                             int alignment = wxDVR_DEFAULT_ALIGNMENT );
 106     virtual ~wxDataViewRendererBase();
 107
 108     virtual bool Validate( wxVariant& WXUNUSED(value) )
 109         { return true; }
 110
 111     void SetOwner( wxDataViewColumn *owner )    { m_owner = owner; }
 112     wxDataViewColumn* GetOwner() const          { return m_owner; }
 113
 114     // renderer value and attributes: SetValue() and SetAttr() are called
 115     // before a cell is rendered using this renderer
 116     virtual bool SetValue(const wxVariant& value) = 0;
 117     virtual bool GetValue(wxVariant& value) const = 0;
 118
 119     virtual void SetAttr(const wxDataViewItemAttr& WXUNUSED(attr)) { }
 120
 121     virtual void SetEnabled(bool WXUNUSED(enabled)) { }
 122
 123     wxString GetVariantType() const             { return m_variantType; }
 124
 125     // helper that calls SetValue and SetAttr:
 126     void PrepareForItem(const wxDataViewModel *model,
 127                         const wxDataViewItem& item, unsigned column);
 128
 129     // renderer properties:
 130     virtual void SetMode( wxDataViewCellMode mode ) = 0;
 131     virtual wxDataViewCellMode GetMode() const = 0;
 132
 133     // NOTE: Set/GetAlignment do not take/return a wxAlignment enum but
 134     //       rather an "int"; that's because for rendering cells it's allowed
 135     //       to combine alignment flags (e.g. wxALIGN_LEFT|wxALIGN_BOTTOM)
 136     virtual void SetAlignment( int align ) = 0;
 137     virtual int GetAlignment() const = 0;
 138
 139     // enable or disable (if called with wxELLIPSIZE_NONE) replacing parts of
 140     // the item text (hence this only makes sense for renderers showing
 141     // text...) with ellipsis in order to make it fit the column width
 142     virtual void EnableEllipsize(wxEllipsizeMode mode = wxELLIPSIZE_MIDDLE) = 0;
 143     void DisableEllipsize() { EnableEllipsize(wxELLIPSIZE_NONE); }
 144
 145     virtual wxEllipsizeMode GetEllipsizeMode() const = 0;
 146
 147     // in-place editing
 148     virtual bool HasEditorCtrl() const
 149         { return false; }
 150     virtual wxWindow* CreateEditorCtrl(wxWindow * WXUNUSED(parent),
 151                                        wxRect WXUNUSED(labelRect),
 152                                        const wxVariant& WXUNUSED(value))
 153         { return NULL; }
 154     virtual bool GetValueFromEditorCtrl(wxWindow * WXUNUSED(editor),
 155                                         wxVariant& WXUNUSED(value))
 156         { return false; }
 157
 158     virtual bool StartEditing( const wxDataViewItem &item, wxRect labelRect );
 159     virtual void CancelEditing();
 160     virtual bool FinishEditing();
 161
 162     wxWindow *GetEditorCtrl() { return m_editorCtrl; }
 163
 164     virtual bool IsCustomRenderer() const { return false; }
 165
 166
 167 protected:
 168     // Called from {Cancel,Finish}Editing() to cleanup m_editorCtrl
 169     void DestroyEditControl();
 170
 171     wxString                m_variantType;
 172     wxDataViewColumn       *m_owner;
 173     wxWeakRef<wxWindow>     m_editorCtrl;
 174     wxDataViewItem          m_item; // for m_editorCtrl
 175
 176     // internal utility, may be used anywhere the window associated with the
 177     // renderer is required
 178     wxDataViewCtrl* GetView() const;
 179
 180 protected:
 181     DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewRendererBase)
 182 };
 183
 184 // include the real wxDataViewRenderer declaration for the native ports
 185 #ifdef wxHAS_GENERIC_DATAVIEWCTRL
 186     // in the generic implementation there is no real wxDataViewRenderer, all
 187     // renderers are custom so it's the same as wxDataViewCustomRenderer and
 188     // wxDataViewCustomRendererBase derives from wxDataViewRendererBase directly
 189     //
 190     // this is a rather ugly hack but unfortunately it just doesn't seem to be
 191     // possible to have the same class hierarchy in all ports and avoid
 192     // duplicating the entire wxDataViewCustomRendererBase in the generic
 193     // wxDataViewRenderer class (well, we could use a mix-in but this would
 194     // make classes hierarchy non linear and arguably even more complex)
 195     #define wxDataViewCustomRendererRealBase wxDataViewRendererBase
 196 #else
 197     #if defined(__WXGTK20__)
 198         #include "wx/gtk/dvrenderer.h"
 199     #elif defined(__WXMAC__)
 200         #include "wx/osx/dvrenderer.h"
 201     #else
 202         #error "unknown native wxDataViewCtrl implementation"
 203     #endif
 204     #define wxDataViewCustomRendererRealBase wxDataViewRenderer
 205 #endif
 206
 207 // ----------------------------------------------------------------------------
 208 // wxDataViewCustomRendererBase
 209 // ----------------------------------------------------------------------------
 210
 211 class WXDLLIMPEXP_ADV wxDataViewCustomRendererBase
 212     : public wxDataViewCustomRendererRealBase
 213 {
 214 public:
 215     // Constructor must specify the usual renderer parameters which we simply
 216     // pass to the base class
 217     wxDataViewCustomRendererBase(const wxString& varianttype = "string",
 218                                  wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
 219                                  int align = wxDVR_DEFAULT_ALIGNMENT)
 220         : wxDataViewCustomRendererRealBase(varianttype, mode, align)
 221     {
 222     }
 223
 224
 225     // Render the item using the current value (returned by GetValue()).
 226     virtual bool Render(wxRect cell, wxDC *dc, int state) = 0;
 227
 228     // Return the size of the item appropriate to its current value.
 229     virtual wxSize GetSize() const = 0;
 230
 231     // Define virtual function which are called when a key is pressed on the
 232     // item, clicked or the user starts to drag it: by default they all simply
 233     // return false indicating that the events are not handled
 234
 235     virtual bool ActivateCell(const wxRect& cell,
 236                               wxDataViewModel *model,
 237                               const wxDataViewItem & item,
 238                               unsigned int col,
 239                               const wxMouseEvent* mouseEvent)
 240     {
 241         // Compatibility code
 242         if ( mouseEvent )
 243             return LeftClick(mouseEvent->GetPosition(), cell, model, item, col);
 244         else
 245             return Activate(cell, model, item, col);
 246     }
 247
 248     // Deprecated, use (and override) ActivateCell() instead
 249     wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
 250         virtual bool Activate(wxRect WXUNUSED(cell),
 251                               wxDataViewModel *WXUNUSED(model),
 252                               const wxDataViewItem & WXUNUSED(item),
 253                               unsigned int WXUNUSED(col)),
 254                           return false; )
 255
 256     // Deprecated, use (and override) ActivateCell() instead
 257     wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
 258         virtual bool LeftClick(wxPoint WXUNUSED(cursor),
 259                                wxRect WXUNUSED(cell),
 260                                wxDataViewModel *WXUNUSED(model),
 261                                const wxDataViewItem & WXUNUSED(item),
 262                                unsigned int WXUNUSED(col)),
 263                           return false; )
 264
 265     virtual bool StartDrag(const wxPoint& WXUNUSED(cursor),
 266                            const wxRect& WXUNUSED(cell),
 267                            wxDataViewModel *WXUNUSED(model),
 268                            const wxDataViewItem & WXUNUSED(item),
 269                            unsigned int WXUNUSED(col) )
 270         { return false; }
 271
 272
 273     // Helper which can be used by Render() implementation in the derived
 274     // classes: it will draw the text in the same manner as the standard
 275     // renderers do.
 276     virtual void RenderText(const wxString& text,
 277                             int xoffset,
 278                             wxRect cell,
 279                             wxDC *dc,
 280                             int state);
 281
 282
 283     // Override the base class virtual method to simply store the attribute so
 284     // that it can be accessed using GetAttr() from Render() if needed.
 285     virtual void SetAttr(const wxDataViewItemAttr& attr) { m_attr = attr; }
 286     const wxDataViewItemAttr& GetAttr() const { return m_attr; }
 287
 288     // Store the enabled state of the item so that it can be accessed from
 289     // Render() via GetEnabled() if needed.
 290     virtual void SetEnabled(bool enabled) { m_enabled = enabled; }
 291     bool GetEnabled() const { return m_enabled; }
 292
 293
 294     // Implementation only from now on
 295
 296     // Retrieve the DC to use for drawing. This is implemented in derived
 297     // platform-specific classes.
 298     virtual wxDC *GetDC() = 0;
 299
 300     // Prepare DC to use attributes and call Render().
 301     void WXCallRender(wxRect rect, wxDC *dc, int state);
 302
 303     virtual bool IsCustomRenderer() const { return true; }
 304
 305 protected:
 306     // helper for GetSize() implementations, respects attributes
 307     wxSize GetTextExtent(const wxString& str) const;
 308
 309 private:
 310     wxDataViewItemAttr m_attr;
 311     bool m_enabled;
 312
 313     wxDECLARE_NO_COPY_CLASS(wxDataViewCustomRendererBase);
 314 };
 315
 316 // include the declaration of all the other renderers to get the real
 317 // wxDataViewCustomRenderer from which we need to inherit below
 318 #ifdef wxHAS_GENERIC_DATAVIEWCTRL
 319     // because of the different renderer classes hierarchy in the generic
 320     // version, as explained above, we can include the header defining
 321     // wxDataViewRenderer only here and not before wxDataViewCustomRendererBase
 322     // declaration as for the native ports
 323     #include "wx/generic/dvrenderer.h"
 324     #include "wx/generic/dvrenderers.h"
 325 #elif defined(__WXGTK20__)
 326     #include "wx/gtk/dvrenderers.h"
 327 #elif defined(__WXMAC__)
 328     #include "wx/osx/dvrenderers.h"
 329 #else
 330     #error "unknown native wxDataViewCtrl implementation"
 331 #endif
 332
 333 // ----------------------------------------------------------------------------
 334 // wxDataViewSpinRenderer
 335 // ----------------------------------------------------------------------------
 336
 337 class WXDLLIMPEXP_ADV wxDataViewSpinRenderer: public wxDataViewCustomRenderer
 338 {
 339 public:
 340     wxDataViewSpinRenderer( int min, int max,
 341                             wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 342                             int alignment = wxDVR_DEFAULT_ALIGNMENT );
 343     virtual bool HasEditorCtrl() const { return true; }
 344     virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
 345     virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
 346     virtual bool Render( wxRect rect, wxDC *dc, int state );
 347     virtual wxSize GetSize() const;
 348     virtual bool SetValue( const wxVariant &value );
 349     virtual bool GetValue( wxVariant &value ) const;
 350
 351 private:
 352     long    m_data;
 353     long    m_min,m_max;
 354 };
 355
 356 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXOSX_CARBON__)
 357
 358 // ----------------------------------------------------------------------------
 359 // wxDataViewChoiceRenderer
 360 // ----------------------------------------------------------------------------
 361
 362 class WXDLLIMPEXP_ADV wxDataViewChoiceRenderer: public wxDataViewCustomRenderer
 363 {
 364 public:
 365     wxDataViewChoiceRenderer( const wxArrayString &choices,
 366                             wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 367                             int alignment = wxDVR_DEFAULT_ALIGNMENT );
 368     virtual bool HasEditorCtrl() const { return true; }
 369     virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
 370     virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
 371     virtual bool Render( wxRect rect, wxDC *dc, int state );
 372     virtual wxSize GetSize() const;
 373     virtual bool SetValue( const wxVariant &value );
 374     virtual bool GetValue( wxVariant &value ) const;
 375
 376     wxString GetChoice(size_t index) const { return m_choices[index]; }
 377     const wxArrayString& GetChoices() const { return m_choices; }
 378
 379 private:
 380     wxArrayString m_choices;
 381     wxString      m_data;
 382 };
 383
 384 // ----------------------------------------------------------------------------
 385 // wxDataViewChoiceByIndexRenderer
 386 // ----------------------------------------------------------------------------
 387
 388 class WXDLLIMPEXP_ADV wxDataViewChoiceByIndexRenderer: public wxDataViewChoiceRenderer
 389 {
 390 public:
 391     wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
 392                               wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 393                               int alignment = wxDVR_DEFAULT_ALIGNMENT );
 394
 395     virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
 396     virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
 397
 398     virtual bool SetValue( const wxVariant &value );
 399     virtual bool GetValue( wxVariant &value ) const;
 400 };
 401
 402
 403 #endif // generic or Carbon versions
 404
 405 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXGTK__)
 406
 407 // ----------------------------------------------------------------------------
 408 // wxDataViewDateRenderer
 409 // ----------------------------------------------------------------------------
 410
 411 #if wxUSE_DATEPICKCTRL
 412 class WXDLLIMPEXP_ADV wxDataViewDateRenderer: public wxDataViewCustomRenderer
 413 {
 414 public:
 415     wxDataViewDateRenderer(const wxString &varianttype = wxT("datetime"),
 416                            wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
 417                            int align = wxDVR_DEFAULT_ALIGNMENT);
 418
 419     virtual bool HasEditorCtrl() const { return true; }
 420     virtual wxWindow *CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant &value);
 421     virtual bool GetValueFromEditorCtrl(wxWindow* editor, wxVariant &value);
 422     virtual bool SetValue(const wxVariant &value);
 423     virtual bool GetValue(wxVariant& value) const;
 424     virtual bool Render( wxRect cell, wxDC *dc, int state );
 425     virtual wxSize GetSize() const;
 426
 427 private:
 428     wxDateTime    m_date;
 429 };
 430 #else // !wxUSE_DATEPICKCTRL
 431 typedef wxDataViewTextRenderer wxDataViewDateRenderer;
 432 #endif
 433
 434 #endif // generic or GTK+ versions
 435
 436 // this class is obsolete, its functionality was merged in
 437 // wxDataViewTextRenderer itself now, don't use it any more
 438 #define wxDataViewTextRendererAttr wxDataViewTextRenderer
 439
 440 #endif // _WX_DVRENDERERS_H_
 441