utils/configtool/src/propeditor.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        propeditor.cpp
   3 // Purpose:     wxWidgets Configuration Tool property editor
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     2003-06-03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20
  21 #include "wx/grid.h"
  22 #include "wx/filedlg.h"
  23
  24 #endif
  25
  26 #include "wx/html/htmlwin.h"
  27 #include "wx/tokenzr.h"
  28 #include "wx/valgen.h"
  29 #include "propeditor.h"
  30 #include "symbols.h"
  31 #include "utils.h"
  32 #include "configtooldoc.h"
  33 #include "configitemselector.h"
  34
  35 #include "bitmaps/ellipsis.xpm"
  36
  37
  38 /*!
  39  * A container window for the property editor.
  40  * and attribute editor.
  41  */
  42
  43 IMPLEMENT_CLASS(ctPropertyEditor, wxPanel)
  44
  45 BEGIN_EVENT_TABLE(ctPropertyEditor, wxPanel)
  46     EVT_BUTTON(ctID_ATTRIBUTE_EDITOR_EDIT_DETAILS, ctPropertyEditor::OnEditDetails)
  47     EVT_GRID_SELECT_CELL(ctPropertyEditor::OnSelectCell)
  48     EVT_GRID_CELL_CHANGE(ctPropertyEditor::OnChangeCell)
  49     EVT_GRID_CELL_LEFT_DCLICK(ctPropertyEditor::OnDClickCell)
  50     EVT_UPDATE_UI(ctID_ATTRIBUTE_EDITOR_EDIT_DETAILS, ctPropertyEditor::OnUpdateEditDetails)
  51 END_EVENT_TABLE()
  52
  53 ctPropertyEditor::ctPropertyEditor(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style):
  54     wxPanel(parent, id, pos, size, style)
  55 {
  56     m_splitterWindow = NULL;
  57     m_attributeEditorGrid = NULL;
  58     m_propertyDescriptionWindow = NULL;
  59     m_elementTitleTextCtrl = NULL;
  60
  61     CreateControls(this);
  62 }
  63
  64 void ctPropertyEditor::CreateControls(wxWindow* parent)
  65 {
  66     m_elementTitleTextCtrl = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
  67     wxBitmap detailsIcon(ellipsis_xpm);
  68
  69     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
  70
  71     wxBoxSizer *item1 = new wxBoxSizer( wxHORIZONTAL );
  72
  73     wxTextCtrl *item2 = m_elementTitleTextCtrl;
  74     item1->Add( item2, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  75
  76     m_attributeEditorEditDetails = new wxButton( parent, ctID_ATTRIBUTE_EDITOR_EDIT_DETAILS, wxT("Edit..."));
  77     item1->Add( m_attributeEditorEditDetails, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
  78
  79     item0->Add( item1, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
  80
  81     // TODO: find sash pos from last time
  82     int sashPos = 100;
  83
  84     m_splitterWindow = new wxSplitterWindow(parent, ctID_PROPERTY_EDITOR_SPLITTER, wxDefaultPosition, wxSize(500, 400), wxSP_3DSASH/*|wxCLIP_CHILDREN*/ |wxBORDER_NONE|wxNO_FULL_REPAINT_ON_RESIZE);
  85     m_splitterWindow->SetMinimumPaneSize(10);
  86
  87     m_propertyDescriptionWindow = new wxHtmlWindow(m_splitterWindow, ctID_ATTRIBUTE_EDITOR_DESCRIPTION, wxDefaultPosition, wxSize(200, 60), wxSUNKEN_BORDER);
  88     m_propertyDescriptionWindow->SetBackgroundColour(ctDESCRIPTION_BACKGROUND_COLOUR);
  89     m_propertyDescriptionWindow->SetBorders(4);
  90     m_attributeEditorGrid = new ctPropertyEditorGrid(m_splitterWindow, ctID_ATTRIBUTE_EDITOR_GRID , wxPoint(0, 0), wxSize(200, 100), wxBORDER_SUNKEN | wxWANTS_CHARS);
  91
  92     m_splitterWindow->SplitHorizontally(m_propertyDescriptionWindow, m_attributeEditorGrid, sashPos);
  93
  94     // TODO: show or hide description window
  95 //    if (some-setting)
  96 //        ShowDescriptionWindow(false);
  97
  98     item0->Add( m_splitterWindow, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxBOTTOM, 5 );
  99
 100     this->SetSizer( item0 );
 101
 102     /// Add help text
 103     m_elementTitleTextCtrl->SetHelpText(_("The title of the property being edited."));
 104     m_attributeEditorEditDetails->SetHelpText(_("Click to use an appropriate editor for the selected property (if any)."));
 105     m_attributeEditorGrid->SetHelpText(_("Shows the properties of the selected item."));
 106     m_propertyDescriptionWindow->SetHelpText(_("Shows a description of the selected property, or a summary of the whole item."));
 107
 108     /// Set up the grid to display properties
 109     m_attributeEditorGrid->RegisterDataType(ctGRID_VALUE_STRING,
 110                              new wxGridCellStringRenderer,
 111                              new ctGridCellTextEditor);
 112
 113     m_attributeEditorGrid->CreateGrid( 0, 2, wxGrid::wxGridSelectRows );
 114     m_attributeEditorGrid->SetRowLabelSize(0);
 115     m_attributeEditorGrid->SetColLabelSize(0 /* 18 */);
 116
 117     wxArrayString columns;
 118     columns.Add(_T("Name"));
 119     columns.Add(_T("Value"));
 120
 121     m_attributeEditorGrid->SetColSize(0, 140);
 122     m_attributeEditorGrid->SetColSize(1, 80);
 123
 124     m_attributeEditorGrid->SetColumnsToDisplay(columns);
 125     m_attributeEditorGrid->DisplayLabels();
 126
 127     m_attributeEditorGrid->SetStretchableColumn(1);
 128
 129     m_attributeEditorGrid->SetDefaultCellBackgroundColour(ctCELL_BACKGROUND_COLOUR);
 130
 131     UpdateDescription();
 132 }
 133
 134 /// Show/hide the description control
 135 void ctPropertyEditor::ShowDescriptionWindow(bool show)
 136 {
 137     if (!show)
 138     {
 139         if (m_splitterWindow->IsSplit())
 140             m_splitterWindow->Unsplit(m_propertyDescriptionWindow);
 141     }
 142     else
 143     {
 144         // TODO
 145         int pos = 100;
 146         m_propertyDescriptionWindow->Show(true);
 147         if (!m_splitterWindow->IsSplit())
 148         {
 149             m_splitterWindow->SplitHorizontally(m_propertyDescriptionWindow, m_attributeEditorGrid, pos);
 150         }
 151     }
 152 }
 153
 154 /// Clear grid editor
 155 void ctPropertyEditor::ClearEditor()
 156 {
 157     m_attributeEditorGrid->ClearAttributes();
 158     m_propertyDescriptionWindow->SetPage(WrapDescription(wxEmptyString));
 159     m_elementTitleTextCtrl->SetValue(wxEmptyString);
 160 }
 161
 162 /// Handles detailed editing event.
 163 void ctPropertyEditor::OnEditDetails(wxCommandEvent& WXUNUSED(event))
 164 {
 165     wxWindow* parentFrame = this;
 166     while (parentFrame && !parentFrame->IsKindOf(CLASSINFO(wxFrame)))
 167         parentFrame = parentFrame->GetParent();
 168
 169     EditDetails(parentFrame);
 170 }
 171
 172 /// Handles detailed editing update event.
 173 void ctPropertyEditor::OnUpdateEditDetails(wxUpdateUIEvent& event)
 174 {
 175     event.Enable(CanEditDetails());
 176 }
 177
 178 /// Can we edit the details of the selected property?
 179 bool ctPropertyEditor::CanEditDetails()
 180 {
 181     if (!m_item)
 182         return false;
 183
 184     int row;
 185     ctProperty* prop = FindSelectedProperty(row);
 186     if (!prop || prop->GetEditorType().empty())
 187         return false;
 188     return true;
 189 }
 190
 191 /// Shows the item
 192 void ctPropertyEditor::ShowItem(ctConfigItem* item)
 193 {
 194     if (m_attributeEditorGrid->IsCellEditControlEnabled())
 195         m_attributeEditorGrid->SaveEditControlValue();
 196
 197     ClearEditor();
 198     if (item)
 199     {
 200         m_item = item;
 201
 202         UpdateTitle();
 203
 204         m_attributeEditorGrid->AppendRows(m_item->GetProperties().GetCount());
 205
 206         wxObjectList::compatibility_iterator node = m_item->GetProperties().GetList().GetFirst();
 207         int i = 0;
 208         while (node)
 209         {
 210             ctProperty* prop = (ctProperty*) node->GetData();
 211             DisplayProperty(i, prop);
 212
 213             i ++;
 214             node = node->GetNext();
 215         }
 216         // Make sure scrollbars are up-to-date, etc.
 217         wxSizeEvent event(m_attributeEditorGrid->GetSize(), m_attributeEditorGrid->GetId());
 218         m_attributeEditorGrid->GetEventHandler()->ProcessEvent(event);
 219
 220         DisplayDefaultProperty();
 221     }
 222     else
 223     {
 224         m_item = NULL;
 225     }
 226 }
 227
 228 /// Determine background colour for this property.
 229 void ctPropertyEditor::DeterminePropertyColour(ctProperty* prop, wxColour& colour)
 230 {
 231     if (prop->IsCustom())
 232         colour = ctCUSTOM_CELL_BACKGROUND_COLOUR;
 233     else
 234         colour = ctCELL_BACKGROUND_COLOUR;
 235 }
 236
 237 /// Update the title at the top of the property editor
 238 void ctPropertyEditor::UpdateTitle()
 239 {
 240     if (m_item)
 241     {
 242         wxString name(m_item->GetTitle());
 243         m_elementTitleTextCtrl->SetValue(name);
 244     }
 245 }
 246
 247 /// Updates the item display, assuming it was already displayed.
 248 void ctPropertyEditor::UpdateItem()
 249 {
 250     if (m_attributeEditorGrid->IsCellEditControlEnabled())
 251         m_attributeEditorGrid->SaveEditControlValue();
 252     if (m_item)
 253     {
 254         UpdateTitle();
 255
 256         wxObjectList::compatibility_iterator node = m_item->GetProperties().GetList().GetFirst();
 257         int i = 0;
 258         while (node)
 259         {
 260             ctProperty* prop = (ctProperty*) node->GetData();
 261             DisplayProperty(i, prop, true);
 262
 263             i ++;
 264             node = node->GetNext();
 265         }
 266         // Make sure scrollbars are up-to-date, etc.
 267         wxSizeEvent event(m_attributeEditorGrid->GetSize(), this->GetId());
 268         m_attributeEditorGrid->GetEventHandler()->ProcessEvent(event);
 269     }
 270 }
 271
 272 /// Display attribute at given row
 273 bool ctPropertyEditor::DisplayProperty(int row, ctProperty* prop, bool valueOnly)
 274 {
 275     wxColour backgroundColour;
 276
 277     DeterminePropertyColour(prop, backgroundColour);
 278
 279     if (!valueOnly)
 280     {
 281         m_attributeEditorGrid->SetCellBackgroundColour(row, 0, backgroundColour);
 282         m_attributeEditorGrid->SetCellBackgroundColour(row, 1, backgroundColour);
 283
 284         m_attributeEditorGrid->SetCellValue(row, 0, prop->GetName());
 285
 286         m_attributeEditorGrid->SetReadOnly(row, 0);
 287         // Set the alignment
 288         m_attributeEditorGrid->SetCellAlignment(row, 1, wxALIGN_LEFT, wxALIGN_CENTER);
 289     }
 290
 291     if (!m_item->CanEditProperty(prop->GetName()))
 292     {
 293         m_attributeEditorGrid->SetReadOnly(row, 1);
 294
 295         wxColour col(wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT));
 296         m_attributeEditorGrid->SetCellTextColour(row, 1, col);
 297     }
 298     else
 299     {
 300         m_attributeEditorGrid->SetReadOnly(row, 1, false);
 301         m_attributeEditorGrid->SetCellTextColour(row, 1, * wxBLACK);
 302     }
 303
 304     // Set the value
 305     m_attributeEditorGrid->SetCellValue(row, 1, ctConvertToSingleText(prop->GetValue()));
 306
 307     if (valueOnly)
 308         return true;
 309
 310     // Set the value type
 311     if (prop->GetEditorType() == _T("choice"))
 312     {
 313 #if 0
 314         wxString* strArr = prop->GetChoices().GetStringArray();
 315
 316         m_attributeEditorGrid->SetCellEditor(row, 1,
 317                 new wxGridCellChoiceEditor(prop->GetChoices().GetCount(), strArr));
 318
 319         delete[] strArr;
 320 #endif
 321         m_attributeEditorGrid->SetCellEditor(row, 1,
 322                 new wxGridCellChoiceEditor(prop->GetChoices()));
 323     }
 324     else if (prop->GetEditorType() == _T("integer") || prop->GetVariant().GetType() == _T("long"))
 325     {
 326         m_attributeEditorGrid->SetCellEditor(row, 1,
 327                 new wxGridCellNumberEditor);
 328     }
 329     else if (prop->GetEditorType() == _T("float") || prop->GetVariant().GetType() == _T("double"))
 330     {
 331         m_attributeEditorGrid->SetCellEditor(row, 1,
 332                 new wxGridCellFloatEditor);
 333     }
 334     else if (prop->GetEditorType() == _T("bool") || prop->GetVariant().GetType() == _T("bool"))
 335     {
 336         m_attributeEditorGrid->SetCellValue(row, 1, prop->GetVariant().GetBool() ? _T("1") : _T("0"));
 337         m_attributeEditorGrid->SetCellEditor(row, 1,
 338                 new wxGridCellBoolEditor);
 339         m_attributeEditorGrid->SetCellRenderer(row, 1, new wxGridCellBoolRenderer);
 340     }
 341     else
 342     {
 343         m_attributeEditorGrid->SetCellEditor(row, 1,
 344                 new ctGridCellTextEditor);
 345     }
 346
 347     return true;
 348 }
 349
 350 /// Display attribute value
 351 bool ctPropertyEditor::DisplayProperty(ctProperty* prop)
 352 {
 353     if (!m_item)
 354         return false;
 355
 356     int index = m_item->GetProperties().GetList().IndexOf(prop);
 357     return DisplayProperty(index, prop, true);
 358 }
 359
 360 /// Display the default property
 361 bool ctPropertyEditor::DisplayDefaultProperty()
 362 {
 363     if (!m_item)
 364         return false;
 365
 366     wxString str = m_item->GetDefaultProperty();
 367
 368     ctProperty* prop = m_item->GetProperties().FindProperty(str);
 369     if (prop)
 370     {
 371         int index = m_item->GetProperties().GetList().IndexOf(prop);
 372         this->m_attributeEditorGrid->SelectRow(index);
 373         this->m_attributeEditorGrid->SetGridCursor(index, 1);
 374     }
 375     return true;
 376 }
 377
 378 /// Edit the default property
 379 bool ctPropertyEditor::EditDefaultProperty(ctConfigItem* item)
 380 {
 381     wxString defaultPropertyName = item->GetDefaultProperty();
 382     if (!defaultPropertyName.empty())
 383     {
 384         ctProperty* prop = item->GetProperties().FindProperty(defaultPropertyName);
 385         if (prop)
 386         {
 387             int index = item->GetProperties().GetList().IndexOf(prop);
 388             if (index >= 0)
 389             {
 390                 this->m_attributeEditorGrid->SelectRow(index);
 391                 this->m_attributeEditorGrid->SetGridCursor(index, 1);
 392                 EditDetails(wxTheApp->GetTopWindow());
 393                 return true;
 394             }
 395         }
 396
 397     }
 398     return false;
 399 }
 400
 401 /// Find the selected property
 402 ctProperty* ctPropertyEditor::FindSelectedProperty(int& row)
 403 {
 404     if (!m_item)
 405         return NULL;
 406
 407     int selRow = m_attributeEditorGrid->GetCursorRow();
 408     if (selRow > -1)
 409     {
 410         row = selRow;
 411
 412         if (selRow < (int) m_item->GetProperties().GetCount())
 413         {
 414             ctProperty* prop = m_item->GetProperties().GetNth(selRow);
 415             return prop;
 416         }
 417     }
 418     return NULL;
 419 }
 420
 421 /// Find the property
 422 ctProperty* ctPropertyEditor::FindProperty(int row)
 423 {
 424     if (!m_item)
 425         return NULL;
 426
 427     if (row > -1)
 428     {
 429         if (row < (int) m_item->GetProperties().GetCount())
 430         {
 431             ctProperty* prop = m_item->GetProperties().GetNth(row);
 432             return prop;
 433         }
 434     }
 435     return NULL;
 436 }
 437
 438 /// Edit the details of this cell appropriately.
 439 bool ctPropertyEditor::EditDetails(wxWindow* WXUNUSED(parent))
 440 {
 441     if (CanEditDetails())
 442     {
 443         int row;
 444         ctProperty* prop = FindSelectedProperty(row);
 445         if (!prop)
 446             return false;
 447
 448         wxString type(prop->GetEditorType());
 449         wxString value = m_attributeEditorGrid->GetCellValue(row, 1);
 450
 451         if (type == _T("multiline"))
 452         {
 453             value = ctConvertToMultilineText(value);
 454             wxString msg;
 455             msg.Printf(wxT("Edit %s:"), (const wxChar*) prop->GetName());
 456             ctMultiLineTextEditor dialog(wxTheApp->GetTopWindow(),
 457                 wxID_ANY, wxT("Edit Text Property"), msg, value);
 458             if (dialog.ShowModal() == wxID_OK)
 459             {
 460                 value = ctConvertToSingleText(dialog.GetText());
 461                 m_attributeEditorGrid->SetCellValue(row, 1, value);
 462                 ApplyCellValueToProperty(row, 1);
 463                 return true;
 464             }
 465             else
 466                 return false;
 467         }
 468         else if (type == _T("filename"))
 469         {
 470             wxString fullPath = value;
 471             wxString defaultDir ;
 472             wxString defaultFilename = wxFileNameFromPath(fullPath);
 473
 474             defaultDir = wxPathOnly(value);
 475
 476             wxString msg = wxT("Choose a filename");
 477             wxFileDialog dialog(wxTheApp->GetTopWindow(),
 478                     msg, defaultDir, defaultFilename, wxT("*.*"));
 479             if (dialog.ShowModal() == wxID_OK)
 480             {
 481                 fullPath = dialog.GetPath();
 482                 value = fullPath;
 483
 484                 m_attributeEditorGrid->SetCellValue(row, 1, value);
 485                 ApplyCellValueToProperty(row, 1);
 486                 return true;
 487             }
 488             else
 489                 return false;
 490         }
 491         else if (type == _T("configitems"))
 492         {
 493             wxArrayString items;
 494             ctConfigItem::StringToArray(value, items);
 495
 496             ctConfigItemsSelector dialog(wxTheApp->GetTopWindow(),
 497                     wxID_ANY, wxT("Select Configuration Items"));
 498             dialog.SetConfigList(items);
 499             if (dialog.ShowModal() == wxID_OK)
 500             {
 501                 wxString newValue;
 502                 items = dialog.GetConfigList();
 503                 ctConfigItem::ArrayToString(items, newValue);
 504
 505                 m_attributeEditorGrid->SetCellValue(row, 1, newValue);
 506                 ApplyCellValueToProperty(row, 1);
 507                 return true;
 508             }
 509             else
 510                 return false;
 511         }
 512     }
 513
 514     return false;
 515 }
 516
 517 /// Intercept selection event.
 518 void ctPropertyEditor::OnSelectCell(wxGridEvent& event)
 519 {
 520     int row = event.GetRow();
 521
 522     UpdateDescription(row);
 523
 524     event.Skip();
 525 }
 526
 527 /// Update the description
 528 void ctPropertyEditor::UpdateDescription(int row)
 529 {
 530     if (row == -1)
 531     {
 532         row = m_attributeEditorGrid->GetCursorRow();
 533     }
 534     if (row == -1)
 535     {
 536         wxString str = WrapDescription(wxEmptyString);
 537         m_propertyDescriptionWindow->SetPage(str);
 538     }
 539     else
 540     {
 541         ctProperty* prop = FindProperty(row);
 542         if (prop)
 543         {
 544             wxString str = WrapDescription(m_item->GetDescription(prop));
 545             m_propertyDescriptionWindow->SetPage(str);
 546         }
 547     }
 548 }
 549
 550 /// Wraps a description string in HTML
 551 wxString ctPropertyEditor::WrapDescription(const wxString& s)
 552 {
 553     /// Convert a colour to a 6-digit hex string
 554     wxColour col = ctDESCRIPTION_BACKGROUND_COLOUR;
 555     wxString colStr = apColourToHexString(col);
 556     colStr = wxT("#") + colStr;
 557
 558     wxString str;
 559     str << _T("<HTML><BODY BGCOLOR=\"") << colStr << wxT("\"><FONT SIZE=-1>") ;
 560     str << s;
 561     str << _T("</FONT></BODY></HTML>");
 562
 563     return str;
 564 }
 565
 566 /// Intercept cell data change event.
 567 void ctPropertyEditor::OnChangeCell(wxGridEvent& event)
 568 {
 569     int row = event.GetRow();
 570     int col = event.GetCol();
 571
 572     ApplyCellValueToProperty(row, col);
 573 }
 574
 575 /// Double-click to show specialised editor.
 576 void ctPropertyEditor::OnDClickCell(wxGridEvent& WXUNUSED(event))
 577 {
 578     wxWindow* parentFrame = this;
 579     while (parentFrame && !parentFrame->IsKindOf(CLASSINFO(wxFrame)))
 580         parentFrame = parentFrame->GetParent();
 581
 582     EditDetails(parentFrame);
 583 }
 584
 585 /// Apply the cell value to the property, and notify the
 586 /// item object.
 587 void ctPropertyEditor::ApplyCellValueToProperty(int row, int col)
 588 {
 589     static bool s_Applying = false;
 590
 591     if (s_Applying)
 592         return;
 593
 594     s_Applying = true;
 595     if (col == 1 && m_item)
 596     {
 597         ctProperty* prop = m_item->GetProperties().GetNth(row);
 598
 599         wxString value = m_attributeEditorGrid->GetCellValue(row, col);
 600         if (prop->GetEditorType() == wxT("multiline"))
 601             value = ctConvertToMultilineText(value);
 602
 603         wxVariant variant = prop->GetVariant();
 604
 605         if (prop->GetVariant().GetType() == _T("bool"))
 606         {
 607             if (value == _T("1"))
 608                 variant = true;
 609             else
 610                 variant = false;
 611         }
 612         else if (prop->GetVariant().GetType() == _T("long"))
 613         {
 614             long l;
 615             value.ToLong(& l);
 616             variant = l;
 617         }
 618         else if (prop->GetVariant().GetType() == _T("double"))
 619         {
 620             double d;
 621             value.ToDouble(& d);
 622             variant = d;
 623         }
 624         else
 625         {
 626             variant = value;
 627         }
 628
 629         ApplyPropertyValue(m_item, prop, variant);
 630
 631         if (prop->GetName() == _T("description"))
 632             UpdateDescription(row);
 633     }
 634     s_Applying = false;
 635 }
 636
 637 /// Apply the cell value to the property, and notify the
 638 /// item object.
 639 void ctPropertyEditor::ApplyPropertyValue(ctConfigItem* item, ctProperty* property, const wxVariant& variant)
 640 {
 641     static bool s_Applying = false;
 642
 643     if (s_Applying)
 644         return;
 645
 646     s_Applying = true;
 647
 648     // Save the old values
 649     ctProperties* oldProperties = new ctProperties(item->GetProperties());
 650
 651     wxVariant oldValue = property->GetVariant();
 652
 653     // Apply the new value
 654     property->GetVariant() = variant;
 655     item->ApplyProperty(property, oldValue);
 656     item->Modify();
 657
 658     UpdateItem();
 659
 660     wxString menuLabel(_T("Change ") + property->GetName());
 661
 662     // This won't do anything first time Do is applied,
 663     // since we've already done the action for this property.
 664     // But when we Undo or Redo, the changed properties will be applied.
 665     item->GetDocument()->GetCommandProcessor()->Submit(
 666         new ctConfigCommand(menuLabel, ctCMD_APPLY_PROPERTY,
 667         item, oldProperties, true));
 668
 669     s_Applying = false;
 670 }
 671
 672 /*!
 673  * Attribute editor grid
 674  */
 675
 676 IMPLEMENT_CLASS(ctPropertyEditorGrid, wxGrid)
 677
 678 BEGIN_EVENT_TABLE(ctPropertyEditorGrid, wxGrid)
 679     EVT_SIZE(ctPropertyEditorGrid::OnSize)
 680 END_EVENT_TABLE()
 681
 682 ctPropertyEditorGrid::ctPropertyEditorGrid(wxWindow* parent, wxWindowID id,
 683                                              const wxPoint& pos,
 684                                              const wxSize& sz, long style):
 685     wxGrid(parent, id, pos, sz, style)
 686
 687 {
 688     m_stretchableColumn = -1;
 689 }
 690
 691 void ctPropertyEditorGrid::OnSize(wxSizeEvent& event)
 692 {
 693     if (m_stretchableColumn != -1)
 694     {
 695         // This window's client size = the internal window's
 696         // client size if it has no borders
 697         wxSize sz = GetClientSize();
 698
 699         int totalSize = 0;
 700         int i;
 701         for (i = 0; i < GetNumberCols(); i ++)
 702         {
 703             if (i != m_stretchableColumn)
 704             {
 705                 totalSize += GetColSize(i);
 706             }
 707         }
 708
 709         // Allow for grid lines
 710         totalSize += 1;
 711
 712         int stretchSize = wxMax(5, sz.x - totalSize);
 713         SetColSize(m_stretchableColumn, stretchSize);
 714     }
 715
 716     event.Skip();
 717 }
 718
 719 /// Use m_columnsToDisplay to set the label strings
 720 void ctPropertyEditorGrid::DisplayLabels()
 721 {
 722     size_t i;
 723     for (i = 0; i < m_columnsToDisplay.GetCount(); i++)
 724     {
 725         SetColLabelValue(i, m_columnsToDisplay[i]);
 726     }
 727 }
 728
 729 /// Clear attributes
 730 bool ctPropertyEditorGrid::ClearAttributes()
 731 {
 732     if (GetNumberRows() > 0)
 733         DeleteRows(0, GetNumberRows());
 734     return true;
 735 }
 736
 737 /*!
 738  * Use a single-line text control.
 739  */
 740
 741 void ctGridCellTextEditor::Create(wxWindow* parent, wxWindowID id,
 742         wxEvtHandler* evtHandler)
 743 {
 744     m_control = new wxTextCtrl(parent, id, wxEmptyString,
 745                                wxDefaultPosition, wxDefaultSize
 746                               );
 747
 748     wxGridCellEditor::Create(parent, id, evtHandler);
 749 }
 750
 751
 752 /// Translate the value to one which can be edited in a single-line
 753 /// text control
 754 wxString ctConvertToSingleText(const wxString& value)
 755 {
 756     wxString value1(value);
 757     value1.Replace(wxT("\n"), wxT("\\n"));
 758     value1.Replace(wxT("\t"), wxT("\\t"));
 759     return value1;
 760 }
 761
 762 /// Translate back to 'real' characters, i.e. newlines are real
 763 /// newlines.
 764 wxString ctConvertToMultilineText(const wxString& value)
 765 {
 766     wxString value1(value);
 767     value1.Replace(wxT("\\n"), wxT("\n"));
 768     value1.Replace(wxT("\\t"), wxT("\t"));
 769     return value1;
 770 }
 771
 772 //----------------------------------------------------------------------------
 773 // ctMultiLineTextEditor
 774 //----------------------------------------------------------------------------
 775
 776 BEGIN_EVENT_TABLE(ctMultiLineTextEditor, wxDialog)
 777 END_EVENT_TABLE()
 778
 779 ctMultiLineTextEditor::ctMultiLineTextEditor( wxWindow *parent, wxWindowID id, const wxString &title,
 780         const wxString& msg,
 781         const wxString& value,
 782         const wxPoint& pos,
 783         const wxSize& size,
 784         long style):
 785     wxDialog(parent, id, title, pos, size, style)
 786 {
 787     m_text = value;
 788     AddControls(this, msg);
 789     Centre();
 790 }
 791
 792 bool ctMultiLineTextEditor::AddControls(wxWindow* parent, const wxString& msg)
 793 {
 794     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
 795
 796     wxBoxSizer *item1 = new wxBoxSizer( wxVERTICAL );
 797
 798     wxStaticText *item2 = new wxStaticText( parent, wxID_STATIC, msg, wxDefaultPosition, wxDefaultSize, 0 );
 799     item1->Add( item2, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxLEFT|wxRIGHT, 5 );
 800
 801     wxTextCtrl *item3 = new wxTextCtrl( parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(330,180), wxTE_MULTILINE|wxTE_RICH );
 802     item1->Add( item3, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 803
 804     wxBoxSizer *item4 = new wxBoxSizer( wxHORIZONTAL );
 805
 806     item4->Add( 5, 5, 1, wxALIGN_CENTRE|wxALL, 5 );
 807
 808     wxButton *item5 = new wxButton( parent, wxID_OK);
 809     item4->Add( item5, 0, wxALIGN_CENTRE|wxALL, 5 );
 810
 811     wxButton *item6 = new wxButton( parent, wxID_CANCEL);
 812     item4->Add( item6, 0, wxALIGN_CENTRE|wxALL, 5 );
 813
 814     item1->Add( item4, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
 815
 816     item0->Add( item1, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 817
 818     item3->SetValue(m_text);
 819     item3->SetValidator(wxGenericValidator(& m_text));
 820
 821
 822     item3->SetFocus();
 823     item5->SetDefault();
 824
 825     parent->SetSizer(item0);
 826     item0->Fit(parent);
 827
 828     return true;
 829 }
 830
 831 /*
 832  * Special-purpose splitter window for changing sash look and
 833  * also saving sash width
 834  */
 835
 836 BEGIN_EVENT_TABLE(ctSplitterWindow, wxSplitterWindow)
 837     EVT_SPLITTER_SASH_POS_CHANGED(wxID_ANY, ctSplitterWindow::OnChangeSash)
 838 END_EVENT_TABLE()
 839
 840 ctSplitterWindow::ctSplitterWindow(wxWindow* parent, wxWindowID id,
 841         const wxPoint& pos, const wxSize& size, long style):
 842       wxSplitterWindow(parent, id, pos, size, style)
 843 {
 844     m_updateSettings = false;
 845     m_position = 0;
 846 }
 847
 848 void ctSplitterWindow::OnChangeSash(wxSplitterEvent& event)
 849 {
 850     if (!m_updateSettings)
 851         return;
 852
 853     m_position = event.GetSashPosition();
 854 }