src/generic/gridctrl.cpp

   1 ///////////////////////////////////////////////////////////////////////////
   2 // Name:        generic/gridctrl.cpp
   3 // Purpose:     wxGrid controls
   4 // Author:      Paul Gammans, Roger Gammans
   5 // Modified by:
   6 // Created:     11/04/2001
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) The Computer Surgery (paul@compsurg.co.uk)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma interface "gridctrl.h"
  14 #endif
  15
  16 #include "wx/wxprec.h"
  17
  18 #ifdef __BORLANDC__
  19     #pragma hdrstop
  20 #endif
  21
  22 #include "wx/generic/gridctrl.h"
  23 #include "wx/tokenzr.h"
  24
  25 // ----------------------------------------------------------------------------
  26 // wxGridCellDateTimeRenderer
  27 // ----------------------------------------------------------------------------
  28
  29 // Enables a grid cell to display a formated date and or time
  30
  31 wxGridCellDateTimeRenderer::wxGridCellDateTimeRenderer(wxString outformat, wxString informat)
  32 {
  33     m_iformat = informat;
  34     m_oformat = outformat;
  35     m_tz = wxDateTime::Local;
  36     m_dateDef = wxDefaultDateTime;
  37 }
  38
  39 wxGridCellRenderer *wxGridCellDateTimeRenderer::Clone() const
  40 {
  41     wxGridCellDateTimeRenderer *renderer = new wxGridCellDateTimeRenderer;
  42     renderer->m_iformat = m_iformat;
  43     renderer->m_oformat = m_oformat;
  44     renderer->m_dateDef = m_dateDef;
  45     renderer->m_tz = m_tz;
  46
  47     return renderer;
  48 }
  49
  50 wxString wxGridCellDateTimeRenderer::GetString(wxGrid& grid, int row, int col)
  51 {
  52     wxGridTableBase *table = grid.GetTable();
  53
  54     bool hasDatetime = FALSE;
  55     wxDateTime val;
  56     wxString text;
  57     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_DATETIME) )
  58     {
  59         void * tempval = table->GetValueAsCustom(row, col,wxGRID_VALUE_DATETIME);
  60
  61         if (tempval){
  62             val = *((wxDateTime *)tempval);
  63             hasDatetime = TRUE;
  64             delete (wxDateTime *)tempval;
  65         }
  66
  67     }
  68
  69     if (!hasDatetime )
  70     {
  71         text = table->GetValue(row, col);
  72         hasDatetime = (val.ParseFormat( text, m_iformat, m_dateDef ) != (wxChar *)NULL) ;
  73     }
  74
  75     if ( hasDatetime )
  76         text = val.Format(m_oformat, m_tz );
  77
  78     //If we faild to parse string just show what we where given?
  79     return text;
  80 }
  81
  82 void wxGridCellDateTimeRenderer::Draw(wxGrid& grid,
  83                                    wxGridCellAttr& attr,
  84                                    wxDC& dc,
  85                                    const wxRect& rectCell,
  86                                    int row, int col,
  87                                    bool isSelected)
  88 {
  89     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
  90
  91     SetTextColoursAndFont(grid, attr, dc, isSelected);
  92
  93     // draw the text right aligned by default
  94     int hAlign, vAlign;
  95     attr.GetAlignment(&hAlign, &vAlign);
  96     hAlign = wxRIGHT;
  97
  98     wxRect rect = rectCell;
  99     rect.Inflate(-1);
 100
 101     grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
 102 }
 103
 104 wxSize wxGridCellDateTimeRenderer::GetBestSize(wxGrid& grid,
 105                                             wxGridCellAttr& attr,
 106                                             wxDC& dc,
 107                                             int row, int col)
 108 {
 109     return DoGetBestSize(attr, dc, GetString(grid, row, col));
 110 }
 111
 112 void wxGridCellDateTimeRenderer::SetParameters(const wxString& params){
 113     if(params)
 114         m_oformat=params;
 115 }
 116
 117 // ----------------------------------------------------------------------------
 118 // wxGridCellChoiceNumberRenderer
 119 // ----------------------------------------------------------------------------
 120 // Renders a number as a textual equivalent.
 121 // eg data in cell is 0,1,2 ... n the cell could be rendered as "John","Fred"..."Bob"
 122
 123
 124 wxGridCellEnumRenderer::wxGridCellEnumRenderer(const wxString& choices)
 125 {
 126     if(choices)
 127         SetParameters(choices);
 128 }
 129
 130 wxGridCellRenderer *wxGridCellEnumRenderer::Clone() const
 131 {
 132     wxGridCellEnumRenderer *renderer = new wxGridCellEnumRenderer;
 133     renderer->m_choices = m_choices;
 134     return renderer;
 135 }
 136
 137 wxString wxGridCellEnumRenderer::GetString(wxGrid& grid, int row, int col)
 138 {
 139     wxGridTableBase *table = grid.GetTable();
 140     wxString text;
 141     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
 142     {
 143         int choiceno = table->GetValueAsLong(row, col);
 144         text.Printf(_T("%s"), m_choices[ choiceno ].c_str() );
 145     }
 146     else
 147     {
 148         text = table->GetValue(row, col);
 149     }
 150
 151
 152     //If we faild to parse string just show what we where given?
 153     return text;
 154 }
 155
 156 void wxGridCellEnumRenderer::Draw(wxGrid& grid,
 157                                    wxGridCellAttr& attr,
 158                                    wxDC& dc,
 159                                    const wxRect& rectCell,
 160                                    int row, int col,
 161                                    bool isSelected)
 162 {
 163     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
 164
 165     SetTextColoursAndFont(grid, attr, dc, isSelected);
 166
 167     // draw the text right aligned by default
 168     int hAlign, vAlign;
 169     attr.GetAlignment(&hAlign, &vAlign);
 170     hAlign = wxRIGHT;
 171
 172     wxRect rect = rectCell;
 173     rect.Inflate(-1);
 174
 175     grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
 176 }
 177
 178 wxSize wxGridCellEnumRenderer::GetBestSize(wxGrid& grid,
 179                                             wxGridCellAttr& attr,
 180                                             wxDC& dc,
 181                                             int row, int col)
 182 {
 183     return DoGetBestSize(attr, dc, GetString(grid, row, col));
 184 }
 185
 186 void wxGridCellEnumRenderer::SetParameters(const wxString& params)
 187 {
 188     if ( !params )
 189     {
 190         // what can we do?
 191         return;
 192     }
 193
 194     m_choices.Empty();
 195
 196     wxStringTokenizer tk(params, _T(','));
 197     while ( tk.HasMoreTokens() )
 198     {
 199         m_choices.Add(tk.GetNextToken());
 200     }
 201 }
 202
 203 // ----------------------------------------------------------------------------
 204 // wxGridCellEnumEditor
 205 // ----------------------------------------------------------------------------
 206 // A cell editor which displays an enum number as a textual equivalent.
 207 // eg data in cell is 0,1,2 ... n the cell could be displayed as "John","Fred"..."Bob"
 208 // in the combo choice box
 209 //
 210 wxGridCellEnumEditor::wxGridCellEnumEditor(const wxString& choices)
 211                     : wxGridCellChoiceEditor()
 212 {
 213     if(choices)
 214         SetParameters(choices);
 215 }
 216
 217 wxGridCellEditor *wxGridCellEnumEditor::Clone() const
 218 {
 219     wxGridCellEnumEditor *editor = new wxGridCellEnumEditor();
 220     editor->m_startint = m_startint;
 221     return editor;
 222 }
 223
 224 void wxGridCellEnumEditor::BeginEdit(int row, int col, wxGrid* grid)
 225 {
 226     wxASSERT_MSG(m_control,
 227                  wxT("The wxGridCellEnumEditor must be Created first!"));
 228
 229     wxGridTableBase *table = grid->GetTable();
 230
 231     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
 232     {
 233         m_startint = table->GetValueAsLong(row, col);
 234     }
 235     else
 236     {
 237         wxString startValue = table->GetValue(row, col);
 238         if (startValue.IsNumber() && !startValue.IsEmpty())
 239         {
 240             startValue.ToLong(&m_startint);
 241         }
 242         else
 243         {
 244             m_startint=-1;
 245         }
 246     }
 247
 248     Combo()->SetSelection(m_startint);
 249     Combo()->SetInsertionPointEnd();
 250     Combo()->SetFocus();
 251
 252 }
 253
 254 bool wxGridCellEnumEditor::EndEdit(int row, int col, wxGrid* grid)
 255 {
 256     int pos = Combo()->GetSelection();
 257     bool changed = (pos != m_startint);
 258     if (changed)
 259     {
 260         if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
 261             grid->GetTable()->SetValueAsLong(row, col, pos);
 262         else
 263             grid->GetTable()->SetValue(row, col,wxString::Format("%i",pos));
 264     }
 265
 266     return changed;
 267 }
 268
 269
 270 void
 271 wxGridCellAutoWrapStringEditor::Create(wxWindow* parent,
 272                                        wxWindowID id,
 273                                        wxEvtHandler* evtHandler)
 274 {
 275   m_control = new wxTextCtrl(parent, id, wxEmptyString,
 276                              wxDefaultPosition, wxDefaultSize,
 277                              wxTE_MULTILINE | wxTE_RICH);
 278
 279
 280   wxGridCellEditor::Create(parent, id, evtHandler);
 281 }
 282
 283 void
 284 wxGridCellAutoWrapStringRenderer::Draw(wxGrid& grid,
 285                       wxGridCellAttr& attr,
 286                       wxDC& dc,
 287                       const wxRect& rectCell,
 288                       int row, int col,
 289                       bool isSelected) {
 290
 291
 292     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
 293
 294     // now we only have to draw the text
 295     SetTextColoursAndFont(grid, attr, dc, isSelected);
 296
 297     int horizAlign, vertAlign;
 298     attr.GetAlignment(&horizAlign, &vertAlign);
 299
 300     wxRect rect = rectCell;
 301     rect.Inflate(-1);
 302
 303     grid.DrawTextRectangle(dc, GetTextLines(grid,dc,attr,rect,row,col),
 304                            rect, horizAlign, vertAlign);
 305 }
 306
 307
 308 wxArrayString
 309 wxGridCellAutoWrapStringRenderer::GetTextLines(wxGrid& grid,
 310                                                wxDC& dc,
 311                                                wxGridCellAttr& attr,
 312                                                const wxRect& rect,
 313                                                int row, int col)
 314 {
 315     wxString  data = grid.GetCellValue(row, col);
 316
 317     wxArrayString lines;
 318     dc.SetFont(attr.GetFont());
 319
 320     //Taken from wxGrid again!
 321     wxCoord x = 0, y = 0, curr_x = 0;
 322     wxCoord max_x = rect.GetWidth();
 323
 324     dc.SetFont(attr.GetFont());
 325     wxStringTokenizer tk(data , _T(" \n\t\r"));
 326     wxString thisline("");
 327
 328     while ( tk.HasMoreTokens() )
 329     {
 330         wxString tok = tk.GetNextToken();
 331     //FIXME: this causes us to print an extra unnecesary
 332     //       space at the end of the line. But it
 333     //       is invisible , simplifies the size calculation
 334     //       and ensures tokens are seperated in the display
 335     tok += _T(" ");
 336
 337         dc.GetTextExtent(tok, &x, &y);
 338         if ( curr_x + x > max_x) {
 339             lines.Add( wxString(thisline) );
 340         thisline = tok;
 341         curr_x=x;
 342     } else {
 343             thisline+= tok;
 344         curr_x += x;
 345     }
 346
 347     }
 348     //Add last line
 349     lines.Add( wxString(thisline) );
 350
 351     return lines;
 352 }
 353
 354
 355 wxSize
 356 wxGridCellAutoWrapStringRenderer::GetBestSize(wxGrid& grid,
 357                                               wxGridCellAttr& attr,
 358                                               wxDC& dc,
 359                                               int row, int col)
 360 {
 361     int x,y, height , width = grid.GetColSize(col) -10;
 362     int count = 250; //Limit iterations..
 363
 364     wxRect rect(0,0,width,10);
 365
 366     // M is a nice large character 'y' gives descender!.
 367     dc.GetTextExtent("My", &x, &y);
 368
 369     do
 370     {
 371         width+=10;
 372         rect.SetWidth(width);
 373         height = y *( GetTextLines(grid,dc,attr,rect,row,col).GetCount());
 374         count--;
 375     // Search for a shape no taller than the golden ratio.
 376     } while (count && (width  < (height*1.68)) );
 377
 378
 379     return wxSize(width,height);
 380 }
 381