src/propgrid/propgrid.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/propgrid/propgrid.cpp
   3 // Purpose:     wxPropertyGrid
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2004-09-25
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  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 #if wxUSE_PROPGRID
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/defs.h"
  23     #include "wx/object.h"
  24     #include "wx/hash.h"
  25     #include "wx/string.h"
  26     #include "wx/log.h"
  27     #include "wx/event.h"
  28     #include "wx/window.h"
  29     #include "wx/panel.h"
  30     #include "wx/dc.h"
  31     #include "wx/dcmemory.h"
  32     #include "wx/button.h"
  33     #include "wx/pen.h"
  34     #include "wx/brush.h"
  35     #include "wx/cursor.h"
  36     #include "wx/dialog.h"
  37     #include "wx/settings.h"
  38     #include "wx/msgdlg.h"
  39     #include "wx/choice.h"
  40     #include "wx/stattext.h"
  41     #include "wx/scrolwin.h"
  42     #include "wx/dirdlg.h"
  43     #include "wx/sizer.h"
  44     #include "wx/textdlg.h"
  45     #include "wx/filedlg.h"
  46     #include "wx/statusbr.h"
  47     #include "wx/intl.h"
  48     #include "wx/frame.h"
  49 #endif
  50
  51
  52 // This define is necessary to prevent macro clearing
  53 #define __wxPG_SOURCE_FILE__
  54
  55 #include "wx/propgrid/propgrid.h"
  56 #include "wx/propgrid/editors.h"
  57
  58 #if wxPG_USE_RENDERER_NATIVE
  59     #include "wx/renderer.h"
  60 #endif
  61
  62 #include "wx/odcombo.h"
  63
  64 #include "wx/timer.h"
  65 #include "wx/dcbuffer.h"
  66
  67 // Two pics for the expand / collapse buttons.
  68 // Files are not supplied with this project (since it is
  69 // recommended to use either custom or native rendering).
  70 // If you want them, get wxTreeMultiCtrl by Jorgen Bodde,
  71 // and copy xpm files from archive to wxPropertyGrid src directory
  72 // (and also comment/undef wxPG_ICON_WIDTH in propGrid.h
  73 // and set wxPG_USE_RENDERER_NATIVE to 0).
  74 #ifndef wxPG_ICON_WIDTH
  75   #if defined(__WXMAC__)
  76     #include "mac_collapse.xpm"
  77     #include "mac_expand.xpm"
  78   #elif defined(__WXGTK__)
  79     #include "linux_collapse.xpm"
  80     #include "linux_expand.xpm"
  81   #else
  82     #include "default_collapse.xpm"
  83     #include "default_expand.xpm"
  84   #endif
  85 #endif
  86
  87
  88 //#define wxPG_TEXT_INDENT                4 // For the wxComboControl
  89 //#define wxPG_ALLOW_CLIPPING             1 // If 1, GetUpdateRegion() in OnPaint event handler is not ignored
  90 #define wxPG_GUTTER_DIV                 3 // gutter is max(iconwidth/gutter_div,gutter_min)
  91 #define wxPG_GUTTER_MIN                 3 // gutter before and after image of [+] or [-]
  92 #define wxPG_YSPACING_MIN               1
  93 #define wxPG_DEFAULT_VSPACING           2 // This matches .NET propertygrid's value,
  94                                           // but causes normal combobox to spill out under MSW
  95
  96 //#define wxPG_OPTIMAL_WIDTH              200 // Arbitrary
  97
  98 //#define wxPG_MIN_SCROLLBAR_WIDTH        10 // Smallest scrollbar width on any platform
  99                                            // Must be larger than largest control border
 100                                            // width * 2.
 101
 102
 103 #define wxPG_DEFAULT_CURSOR             wxNullCursor
 104
 105
 106 //#define wxPG_NAT_CHOICE_BORDER_ANY   0
 107
 108 //#define wxPG_HIDER_BUTTON_HEIGHT        25
 109
 110 #define wxPG_PIXELS_PER_UNIT            m_lineHeight
 111
 112 #ifdef wxPG_ICON_WIDTH
 113   #define m_iconHeight m_iconWidth
 114 #endif
 115
 116 //#define wxPG_TOOLTIP_DELAY              1000
 117
 118 // This is the number of pixels the expander button inside
 119 // property cells (i.e. not in the grey margin area are
 120 // adjusted.
 121 #define IN_CELL_EXPANDER_BUTTON_X_ADJUST    2
 122
 123 // -----------------------------------------------------------------------
 124
 125 #if wxUSE_INTL
 126 void wxPropertyGrid::AutoGetTranslation ( bool enable )
 127 {
 128     wxPGGlobalVars->m_autoGetTranslation = enable;
 129 }
 130 #else
 131 void wxPropertyGrid::AutoGetTranslation ( bool ) { }
 132 #endif
 133
 134 // -----------------------------------------------------------------------
 135
 136 const char wxPropertyGridNameStr[] = "wxPropertyGrid";
 137
 138 // -----------------------------------------------------------------------
 139 // Statics in one class for easy destruction.
 140 // -----------------------------------------------------------------------
 141
 142 #include "wx/module.h"
 143
 144 class wxPGGlobalVarsClassManager : public wxModule
 145 {
 146     DECLARE_DYNAMIC_CLASS(wxPGGlobalVarsClassManager)
 147 public:
 148     wxPGGlobalVarsClassManager() {}
 149     virtual bool OnInit() { wxPGGlobalVars = new wxPGGlobalVarsClass(); return true; }
 150     virtual void OnExit() { delete wxPGGlobalVars; wxPGGlobalVars = NULL; }
 151 };
 152
 153 IMPLEMENT_DYNAMIC_CLASS(wxPGGlobalVarsClassManager, wxModule)
 154
 155
 156 // When wxPG is loaded dynamically after the application is already running
 157 // then the built-in module system won't pick this one up.  Add it manually.
 158 void wxPGInitResourceModule()
 159 {
 160     wxModule* module = new wxPGGlobalVarsClassManager;
 161     module->Init();
 162     wxModule::RegisterModule(module);
 163 }
 164
 165 wxPGGlobalVarsClass* wxPGGlobalVars = NULL;
 166
 167
 168 wxPGGlobalVarsClass::wxPGGlobalVarsClass()
 169 {
 170     wxPGProperty::sm_wxPG_LABEL = new wxString(wxPG_LABEL_STRING);
 171
 172     m_boolChoices.Add(_("False"));
 173     m_boolChoices.Add(_("True"));
 174
 175     m_fontFamilyChoices = NULL;
 176
 177     m_defaultRenderer = new wxPGDefaultRenderer();
 178
 179     m_autoGetTranslation = false;
 180
 181     m_offline = 0;
 182
 183     m_extraStyle = 0;
 184
 185     wxVariant v;
 186
 187     // Prepare some shared variants
 188     m_vEmptyString = wxString();
 189     m_vZero = (long) 0;
 190     m_vMinusOne = (long) -1;
 191     m_vTrue = true;
 192     m_vFalse = false;
 193
 194     // Prepare cached string constants
 195     m_strstring = wxS("string");
 196     m_strlong = wxS("long");
 197     m_strbool = wxS("bool");
 198     m_strlist = wxS("list");
 199     m_strDefaultValue = wxS("DefaultValue");
 200     m_strMin = wxS("Min");
 201     m_strMax = wxS("Max");
 202     m_strUnits = wxS("Units");
 203     m_strInlineHelp = wxS("InlineHelp");
 204
 205     m_warnings = 0;
 206 }
 207
 208
 209 wxPGGlobalVarsClass::~wxPGGlobalVarsClass()
 210 {
 211     size_t i;
 212
 213     delete m_defaultRenderer;
 214
 215     // This will always have one ref
 216     delete m_fontFamilyChoices;
 217
 218 #if wxUSE_VALIDATORS
 219     for ( i=0; i<m_arrValidators.size(); i++ )
 220         delete ((wxValidator*)m_arrValidators[i]);
 221 #endif
 222
 223     //
 224     // Destroy value type class instances.
 225     wxPGHashMapS2P::iterator vt_it;
 226
 227     // Destroy editor class instances.
 228     // iterate over all the elements in the class
 229     for( vt_it = m_mapEditorClasses.begin(); vt_it != m_mapEditorClasses.end(); ++vt_it )
 230     {
 231         delete ((wxPGEditor*)vt_it->second);
 232     }
 233
 234     delete wxPGProperty::sm_wxPG_LABEL;
 235 }
 236
 237 void wxPropertyGridInitGlobalsIfNeeded()
 238 {
 239 }
 240
 241 // -----------------------------------------------------------------------
 242 // wxPropertyGrid
 243 // -----------------------------------------------------------------------
 244
 245 IMPLEMENT_DYNAMIC_CLASS(wxPropertyGrid, wxScrolledWindow)
 246
 247 BEGIN_EVENT_TABLE(wxPropertyGrid, wxScrolledWindow)
 248   EVT_IDLE(wxPropertyGrid::OnIdle)
 249   EVT_PAINT(wxPropertyGrid::OnPaint)
 250   EVT_SIZE(wxPropertyGrid::OnResize)
 251   EVT_ENTER_WINDOW(wxPropertyGrid::OnMouseEntry)
 252   EVT_LEAVE_WINDOW(wxPropertyGrid::OnMouseEntry)
 253   EVT_MOUSE_CAPTURE_CHANGED(wxPropertyGrid::OnCaptureChange)
 254   EVT_SCROLLWIN(wxPropertyGrid::OnScrollEvent)
 255   EVT_CHILD_FOCUS(wxPropertyGrid::OnChildFocusEvent)
 256   EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
 257   EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)
 258   EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)
 259   EVT_MOTION(wxPropertyGrid::OnMouseMove)
 260   EVT_LEFT_DOWN(wxPropertyGrid::OnMouseClick)
 261   EVT_LEFT_UP(wxPropertyGrid::OnMouseUp)
 262   EVT_RIGHT_UP(wxPropertyGrid::OnMouseRightClick)
 263   EVT_LEFT_DCLICK(wxPropertyGrid::OnMouseDoubleClick)
 264   EVT_KEY_DOWN(wxPropertyGrid::OnKey)
 265 END_EVENT_TABLE()
 266
 267 // -----------------------------------------------------------------------
 268
 269 wxPropertyGrid::wxPropertyGrid()
 270     : wxScrolledWindow()
 271 {
 272     Init1();
 273 }
 274
 275 // -----------------------------------------------------------------------
 276
 277 wxPropertyGrid::wxPropertyGrid( wxWindow *parent,
 278                                 wxWindowID id,
 279                                 const wxPoint& pos,
 280                                 const wxSize& size,
 281                                 long style,
 282                                 const wxString& name )
 283     : wxScrolledWindow()
 284 {
 285     Init1();
 286     Create(parent,id,pos,size,style,name);
 287 }
 288
 289 // -----------------------------------------------------------------------
 290
 291 bool wxPropertyGrid::Create( wxWindow *parent,
 292                              wxWindowID id,
 293                              const wxPoint& pos,
 294                              const wxSize& size,
 295                              long style,
 296                              const wxString& name )
 297 {
 298
 299     if (!(style&wxBORDER_MASK))
 300     {
 301         style |= wxBORDER_THEME;
 302     }
 303
 304     style |= wxVSCROLL;
 305
 306     // Filter out wxTAB_TRAVERSAL - we will handle TABs manually
 307     style &= ~(wxTAB_TRAVERSAL);
 308     style |= wxWANTS_CHARS;
 309
 310     wxScrolledWindow::Create(parent,id,pos,size,style,name);
 311
 312     Init2();
 313
 314     return true;
 315 }
 316
 317 // -----------------------------------------------------------------------
 318
 319 //
 320 // Initialize values to defaults
 321 //
 322 void wxPropertyGrid::Init1()
 323 {
 324     // Register editor classes, if necessary.
 325     if ( wxPGGlobalVars->m_mapEditorClasses.empty() )
 326         wxPropertyGrid::RegisterDefaultEditors();
 327
 328     m_iFlags = 0;
 329     m_pState = NULL;
 330     m_wndEditor = m_wndEditor2 = NULL;
 331     m_selColumn = 1;
 332     m_colHover = 1;
 333     m_propHover = NULL;
 334     m_labelEditor = NULL;
 335     m_labelEditorProperty = NULL;
 336     m_eventObject = this;
 337     m_curFocused = NULL;
 338     m_processedEvent = NULL;
 339     m_sortFunction = NULL;
 340     m_inDoPropertyChanged = 0;
 341     m_inCommitChangesFromEditor = 0;
 342     m_inDoSelectProperty = 0;
 343     m_permanentValidationFailureBehavior = wxPG_VFB_DEFAULT;
 344     m_dragStatus = 0;
 345     m_mouseSide = 16;
 346     m_editorFocused = 0;
 347
 348     // Set default keys
 349     AddActionTrigger( wxPG_ACTION_NEXT_PROPERTY, WXK_RIGHT );
 350     AddActionTrigger( wxPG_ACTION_NEXT_PROPERTY, WXK_DOWN );
 351     AddActionTrigger( wxPG_ACTION_PREV_PROPERTY, WXK_LEFT );
 352     AddActionTrigger( wxPG_ACTION_PREV_PROPERTY, WXK_UP );
 353     AddActionTrigger( wxPG_ACTION_EXPAND_PROPERTY, WXK_RIGHT);
 354     AddActionTrigger( wxPG_ACTION_COLLAPSE_PROPERTY, WXK_LEFT);
 355     AddActionTrigger( wxPG_ACTION_CANCEL_EDIT, WXK_ESCAPE );
 356     AddActionTrigger( wxPG_ACTION_PRESS_BUTTON, WXK_DOWN, wxMOD_ALT );
 357     AddActionTrigger( wxPG_ACTION_PRESS_BUTTON, WXK_F4 );
 358
 359     m_coloursCustomized = 0;
 360     m_frozen = 0;
 361
 362 #if wxPG_DOUBLE_BUFFER
 363     m_doubleBuffer = NULL;
 364 #endif
 365
 366 #ifndef wxPG_ICON_WIDTH
 367     m_expandbmp = NULL;
 368     m_collbmp = NULL;
 369     m_iconWidth = 11;
 370     m_iconHeight = 11;
 371 #else
 372     m_iconWidth = wxPG_ICON_WIDTH;
 373 #endif
 374
 375     m_prevVY = -1;
 376
 377     m_gutterWidth = wxPG_GUTTER_MIN;
 378     m_subgroup_extramargin = 10;
 379
 380     m_lineHeight = 0;
 381
 382     m_width = m_height = 0;
 383
 384     m_commonValues.push_back(new wxPGCommonValue(_("Unspecified"), wxPGGlobalVars->m_defaultRenderer) );
 385     m_cvUnspecified = 0;
 386
 387     m_chgInfo_changedProperty = NULL;
 388 }
 389
 390 // -----------------------------------------------------------------------
 391
 392 //
 393 // Initialize after parent etc. set
 394 //
 395 void wxPropertyGrid::Init2()
 396 {
 397     wxASSERT( !(m_iFlags & wxPG_FL_INITIALIZED ) );
 398
 399 #ifdef __WXMAC__
 400    // Smaller controls on Mac
 401    SetWindowVariant(wxWINDOW_VARIANT_SMALL);
 402 #endif
 403
 404     // Now create state, if one didn't exist already
 405     // (wxPropertyGridManager might have created it for us).
 406     if ( !m_pState )
 407     {
 408         m_pState = CreateState();
 409         m_pState->m_pPropGrid = this;
 410         m_iFlags |= wxPG_FL_CREATEDSTATE;
 411     }
 412
 413     if ( !(m_windowStyle & wxPG_SPLITTER_AUTO_CENTER) )
 414         m_pState->m_dontCenterSplitter = true;
 415
 416     if ( m_windowStyle & wxPG_HIDE_CATEGORIES )
 417     {
 418         m_pState->InitNonCatMode();
 419
 420         m_pState->m_properties = m_pState->m_abcArray;
 421     }
 422
 423     GetClientSize(&m_width,&m_height);
 424
 425 #ifndef wxPG_ICON_WIDTH
 426     // create two bitmap nodes for drawing
 427     m_expandbmp = new wxBitmap(expand_xpm);
 428     m_collbmp = new wxBitmap(collapse_xpm);
 429
 430     // calculate average font height for bitmap centering
 431
 432     m_iconWidth = m_expandbmp->GetWidth();
 433     m_iconHeight = m_expandbmp->GetHeight();
 434 #endif
 435
 436     m_curcursor = wxCURSOR_ARROW;
 437     m_cursorSizeWE = new wxCursor( wxCURSOR_SIZEWE );
 438
 439     // adjust bitmap icon y position so they are centered
 440     m_vspacing = wxPG_DEFAULT_VSPACING;
 441
 442     CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );
 443
 444     // Allocate cell datas indirectly by calling setter
 445     m_propertyDefaultCell.SetBgCol(*wxBLACK);
 446     m_categoryDefaultCell.SetBgCol(*wxBLACK);
 447
 448     RegainColours();
 449
 450     // This helps with flicker
 451     SetBackgroundStyle( wxBG_STYLE_CUSTOM );
 452
 453     // Hook the top-level parent
 454     m_tlp = NULL;
 455     m_tlpClosed = NULL;
 456     m_tlpClosedTime = 0;
 457
 458     // set virtual size to this window size
 459     wxSize wndsize = GetSize();
 460     SetVirtualSize(wndsize.GetWidth(), wndsize.GetWidth());
 461
 462     m_timeCreated = ::wxGetLocalTimeMillis();
 463
 464     //m_canvas->Create(this, wxID_ANY, wxPoint(0, 0), GetClientSize(),
 465     //                 wxWANTS_CHARS | wxCLIP_CHILDREN);
 466     SetBackgroundStyle( wxBG_STYLE_CUSTOM );
 467
 468     m_iFlags |= wxPG_FL_INITIALIZED;
 469
 470     m_ncWidth = wndsize.GetWidth();
 471
 472     // Need to call OnResize handler or size given in constructor/Create
 473     // will never work.
 474     wxSizeEvent sizeEvent(wndsize,0);
 475     OnResize(sizeEvent);
 476 }
 477
 478 // -----------------------------------------------------------------------
 479
 480 wxPropertyGrid::~wxPropertyGrid()
 481 {
 482     size_t i;
 483
 484 #if wxUSE_THREADS
 485     wxCriticalSectionLocker(wxPGGlobalVars->m_critSect);
 486 #endif
 487
 488     //
 489     // Remove grid and property pointers from live wxPropertyGridEvents.
 490     for ( i=0; i<m_liveEvents.size(); i++ )
 491     {
 492         wxPropertyGridEvent* evt = m_liveEvents[i];
 493         evt->SetPropertyGrid(NULL);
 494         evt->SetProperty(NULL);
 495     }
 496     m_liveEvents.clear();
 497
 498     if ( m_processedEvent )
 499     {
 500         // All right... we are being deleted while wxPropertyGrid event
 501         // is being sent. Make sure that event propagates as little
 502         // as possible (although usually this is not enough to prevent
 503         // a crash).
 504         m_processedEvent->Skip(false);
 505         m_processedEvent->StopPropagation();
 506
 507         // Let's use wxMessageBox to make the message appear more
 508         // reliably (and *before* the crash can happen).
 509         ::wxMessageBox("wxPropertyGrid was being destroyed in an event "
 510                        "generated by it. This usually leads to a crash "
 511                        "so it is recommended to destroy the control "
 512                        "at idle time instead.");
 513     }
 514
 515     DoSelectProperty(NULL, wxPG_SEL_NOVALIDATE|wxPG_SEL_DONT_SEND_EVENT);
 516
 517     // This should do prevent things from going too badly wrong
 518     m_iFlags &= ~(wxPG_FL_INITIALIZED);
 519
 520     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
 521         ReleaseMouse();
 522
 523     // Call with NULL to disconnect event handling
 524     if ( GetExtraStyle() & wxPG_EX_ENABLE_TLP_TRACKING )
 525     {
 526         OnTLPChanging(NULL);
 527
 528         wxASSERT_MSG( !IsEditorsValueModified(),
 529                       wxS("Most recent change in property editor was ")
 530                       wxS("lost!!! (if you don't want this to happen, ")
 531                       wxS("close your frames and dialogs using ")
 532                       wxS("Close(false).)") );
 533     }
 534
 535 #if wxPG_DOUBLE_BUFFER
 536     if ( m_doubleBuffer )
 537         delete m_doubleBuffer;
 538 #endif
 539
 540     if ( m_iFlags & wxPG_FL_CREATEDSTATE )
 541         delete m_pState;
 542
 543     delete m_cursorSizeWE;
 544
 545 #ifndef wxPG_ICON_WIDTH
 546     delete m_expandbmp;
 547     delete m_collbmp;
 548 #endif
 549
 550     // Delete common value records
 551     for ( i=0; i<m_commonValues.size(); i++ )
 552     {
 553         // Use temporary variable to work around possible strange VC6 (asserts because m_size is zero)
 554         wxPGCommonValue* value = m_commonValues[i];
 555         delete value;
 556     }
 557 }
 558
 559 // -----------------------------------------------------------------------
 560
 561 bool wxPropertyGrid::Destroy()
 562 {
 563     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
 564         ReleaseMouse();
 565
 566     return wxScrolledWindow::Destroy();
 567 }
 568
 569 // -----------------------------------------------------------------------
 570
 571 wxPropertyGridPageState* wxPropertyGrid::CreateState() const
 572 {
 573     return new wxPropertyGridPageState();
 574 }
 575
 576 // -----------------------------------------------------------------------
 577 // wxPropertyGrid overridden wxWindow methods
 578 // -----------------------------------------------------------------------
 579
 580 void wxPropertyGrid::SetWindowStyleFlag( long style )
 581 {
 582     long old_style = m_windowStyle;
 583
 584     if ( m_iFlags & wxPG_FL_INITIALIZED )
 585     {
 586         wxASSERT( m_pState );
 587
 588         if ( !(style & wxPG_HIDE_CATEGORIES) && (old_style & wxPG_HIDE_CATEGORIES) )
 589         {
 590         // Enable categories
 591             EnableCategories( true );
 592         }
 593         else if ( (style & wxPG_HIDE_CATEGORIES) && !(old_style & wxPG_HIDE_CATEGORIES) )
 594         {
 595         // Disable categories
 596             EnableCategories( false );
 597         }
 598         if ( !(old_style & wxPG_AUTO_SORT) && (style & wxPG_AUTO_SORT) )
 599         {
 600             //
 601             // Autosort enabled
 602             //
 603             if ( !m_frozen )
 604                 PrepareAfterItemsAdded();
 605             else
 606                 m_pState->m_itemsAdded = 1;
 607         }
 608     #if wxPG_SUPPORT_TOOLTIPS
 609         if ( !(old_style & wxPG_TOOLTIPS) && (style & wxPG_TOOLTIPS) )
 610         {
 611             //
 612             // Tooltips enabled
 613             //
 614             /*
 615             wxToolTip* tooltip = new wxToolTip ( wxEmptyString );
 616             SetToolTip ( tooltip );
 617             tooltip->SetDelay ( wxPG_TOOLTIP_DELAY );
 618             */
 619         }
 620         else if ( (old_style & wxPG_TOOLTIPS) && !(style & wxPG_TOOLTIPS) )
 621         {
 622             //
 623             // Tooltips disabled
 624             //
 625             wxScrolledWindow::SetToolTip( NULL );
 626         }
 627     #endif
 628     }
 629
 630     wxScrolledWindow::SetWindowStyleFlag ( style );
 631
 632     if ( m_iFlags & wxPG_FL_INITIALIZED )
 633     {
 634         if ( (old_style & wxPG_HIDE_MARGIN) != (style & wxPG_HIDE_MARGIN) )
 635         {
 636             CalculateFontAndBitmapStuff( m_vspacing );
 637             Refresh();
 638         }
 639     }
 640 }
 641
 642 // -----------------------------------------------------------------------
 643
 644 void wxPropertyGrid::Freeze()
 645 {
 646     if ( !m_frozen )
 647     {
 648         wxScrolledWindow::Freeze();
 649     }
 650     m_frozen++;
 651 }
 652
 653 // -----------------------------------------------------------------------
 654
 655 void wxPropertyGrid::Thaw()
 656 {
 657     m_frozen--;
 658
 659     if ( !m_frozen )
 660     {
 661         wxScrolledWindow::Thaw();
 662         RecalculateVirtualSize();
 663     #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
 664         Refresh();
 665     #endif
 666
 667         // Force property re-selection
 668         // NB: We must copy the selection.
 669         wxArrayPGProperty selection = m_pState->m_selection;
 670         DoSetSelection(selection, wxPG_SEL_FORCE | wxPG_SEL_NONVISIBLE);
 671     }
 672 }
 673
 674 // -----------------------------------------------------------------------
 675
 676 bool wxPropertyGrid::DoAddToSelection( wxPGProperty* prop, int selFlags )
 677 {
 678     wxCHECK( prop, false );
 679
 680     if ( !(GetExtraStyle() & wxPG_EX_MULTIPLE_SELECTION) )
 681         return DoSelectProperty(prop, selFlags);
 682
 683     wxArrayPGProperty& selection = m_pState->m_selection;
 684
 685     if ( !selection.size() )
 686     {
 687         return DoSelectProperty(prop, selFlags);
 688     }
 689     else
 690     {
 691         // For categories, only one can be selected at a time
 692         if ( prop->IsCategory() || selection[0]->IsCategory() )
 693             return true;
 694
 695         selection.push_back(prop);
 696
 697         if ( !(selFlags & wxPG_SEL_DONT_SEND_EVENT) )
 698         {
 699             SendEvent( wxEVT_PG_SELECTED, prop, NULL );
 700         }
 701
 702         DrawItem(prop);
 703     }
 704
 705     return true;
 706 }
 707
 708 // -----------------------------------------------------------------------
 709
 710 bool wxPropertyGrid::DoRemoveFromSelection( wxPGProperty* prop, int selFlags )
 711 {
 712     wxCHECK( prop, false );
 713     bool res;
 714
 715     wxArrayPGProperty& selection = m_pState->m_selection;
 716     if ( selection.size() <= 1 )
 717     {
 718         res = DoSelectProperty(NULL, selFlags);
 719     }
 720     else
 721     {
 722         m_pState->DoRemoveFromSelection(prop);
 723         DrawItem(prop);
 724         res = true;
 725     }
 726
 727     return res;
 728 }
 729
 730 // -----------------------------------------------------------------------
 731
 732 bool wxPropertyGrid::DoSelectAndEdit( wxPGProperty* prop,
 733                                       unsigned int colIndex,
 734                                       unsigned int selFlags )
 735 {
 736     //
 737     // NB: Enable following if label editor background colour is
 738     //     ever changed to any other than m_colSelBack.
 739     //
 740     // We use this workaround to prevent visible flicker when editing
 741     // a cell. Atleast on wxMSW, there is a difficult to find
 742     // (and perhaps prevent) redraw somewhere between making property
 743     // selected and enabling label editing.
 744     //
 745     //wxColour prevColSelBack = m_colSelBack;
 746     //m_colSelBack = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
 747
 748     bool res;
 749
 750     if ( colIndex == 1 )
 751     {
 752         res = DoSelectProperty(prop, selFlags);
 753     }
 754     else
 755     {
 756         // send event
 757         DoClearSelection(false, wxPG_SEL_NO_REFRESH);
 758
 759         if ( m_pState->m_editableColumns.Index(colIndex) == wxNOT_FOUND )
 760         {
 761             res = DoAddToSelection(prop, selFlags);
 762         }
 763         else
 764         {
 765             res = DoAddToSelection(prop, selFlags|wxPG_SEL_NO_REFRESH);
 766
 767             DoBeginLabelEdit(colIndex, selFlags);
 768         }
 769     }
 770
 771     //m_colSelBack = prevColSelBack;
 772     return res;
 773 }
 774
 775 // -----------------------------------------------------------------------
 776
 777 bool wxPropertyGrid::AddToSelectionFromInputEvent( wxPGProperty* prop,
 778                                                    unsigned int colIndex,
 779                                                    wxMouseEvent* mouseEvent,
 780                                                    int selFlags )
 781 {
 782     bool alreadySelected = m_pState->DoIsPropertySelected(prop);
 783     bool res = true;
 784     bool addToExistingSelection;
 785
 786     if ( GetExtraStyle() & wxPG_EX_MULTIPLE_SELECTION )
 787     {
 788         if ( mouseEvent )
 789         {
 790             if ( mouseEvent->GetEventType() == wxEVT_RIGHT_DOWN ||
 791                  mouseEvent->GetEventType() == wxEVT_RIGHT_UP )
 792             {
 793                 // Allow right-click for context menu without
 794                 // disturbing the selection.
 795                 if ( GetSelectedProperties().size() <= 1 ||
 796                      !alreadySelected )
 797                     return DoSelectAndEdit(prop, colIndex, selFlags);
 798                 return true;
 799             }
 800             else
 801             {
 802                 addToExistingSelection = mouseEvent->ShiftDown();
 803             }
 804         }
 805         else
 806         {
 807             addToExistingSelection = false;
 808         }
 809     }
 810     else
 811     {
 812         addToExistingSelection = false;
 813     }
 814
 815     if ( addToExistingSelection )
 816     {
 817         if ( !alreadySelected )
 818         {
 819             res = DoAddToSelection(prop, selFlags);
 820         }
 821         else if ( GetSelectedProperties().size() > 1 )
 822         {
 823             res = DoRemoveFromSelection(prop, selFlags);
 824         }
 825     }
 826     else
 827     {
 828         res = DoSelectAndEdit(prop, colIndex, selFlags);
 829     }
 830
 831     return res;
 832 }
 833
 834 // -----------------------------------------------------------------------
 835
 836 void wxPropertyGrid::DoSetSelection( const wxArrayPGProperty& newSelection,
 837                                      int selFlags )
 838 {
 839     if ( newSelection.size() > 0 )
 840     {
 841         if ( !DoSelectProperty(newSelection[0], selFlags) )
 842             return;
 843     }
 844     else
 845     {
 846         DoClearSelection(false, selFlags);
 847     }
 848
 849     for ( unsigned int i = 1; i < newSelection.size(); i++ )
 850     {
 851         DoAddToSelection(newSelection[i], selFlags);
 852     }
 853
 854     Refresh();
 855 }
 856
 857 // -----------------------------------------------------------------------
 858
 859 void wxPropertyGrid::MakeColumnEditable( unsigned int column,
 860                                          bool editable )
 861 {
 862     wxASSERT( column != 1 );
 863
 864     wxArrayInt& cols = m_pState->m_editableColumns;
 865
 866     if ( editable )
 867     {
 868         cols.push_back(column);
 869     }
 870     else
 871     {
 872         for ( int i = cols.size() - 1; i > 0; i-- )
 873         {
 874             if ( cols[i] == (int)column )
 875                 cols.erase( cols.begin() + i );
 876         }
 877     }
 878 }
 879
 880 // -----------------------------------------------------------------------
 881
 882 void wxPropertyGrid::DoBeginLabelEdit( unsigned int colIndex,
 883                                        int selFlags )
 884 {
 885     wxPGProperty* selected = GetSelection();
 886     wxCHECK_RET(selected, wxT("No property selected"));
 887     wxCHECK_RET(colIndex != 1, wxT("Do not use this for column 1"));
 888
 889     if ( !(selFlags & wxPG_SEL_DONT_SEND_EVENT) )
 890     {
 891         if ( SendEvent( wxEVT_PG_LABEL_EDIT_BEGIN,
 892                         selected, NULL, 0,
 893                         colIndex ) )
 894             return;
 895     }
 896
 897     wxString text;
 898     const wxPGCell* cell = NULL;
 899     if ( selected->HasCell(colIndex) )
 900     {
 901         cell = &selected->GetCell(colIndex);
 902         if ( !cell->HasText() && colIndex == 0 )
 903             text = selected->GetLabel();
 904     }
 905
 906     if ( !cell  )
 907     {
 908         if ( colIndex == 0 )
 909             text = selected->GetLabel();
 910         else
 911             cell = &selected->GetOrCreateCell(colIndex);
 912     }
 913
 914     if ( cell && cell->HasText() )
 915         text = cell->GetText();
 916
 917     DoEndLabelEdit(true, wxPG_SEL_NOVALIDATE);  // send event
 918
 919     m_selColumn = colIndex;
 920
 921     wxRect r = GetEditorWidgetRect(selected, m_selColumn);
 922
 923     wxWindow* tc = GenerateEditorTextCtrl(r.GetPosition(),
 924                                           r.GetSize(),
 925                                           text,
 926                                           NULL,
 927                                           wxTE_PROCESS_ENTER,
 928                                           0,
 929                                           colIndex);
 930
 931     wxWindowID id = tc->GetId();
 932     tc->Connect(id, wxEVT_COMMAND_TEXT_ENTER,
 933         wxCommandEventHandler(wxPropertyGrid::OnLabelEditorEnterPress),
 934         NULL, this);
 935     tc->Connect(id, wxEVT_KEY_DOWN,
 936         wxKeyEventHandler(wxPropertyGrid::OnLabelEditorKeyPress),
 937         NULL, this);
 938
 939     tc->SetFocus();
 940
 941     m_labelEditor = wxStaticCast(tc, wxTextCtrl);
 942     m_labelEditorProperty = selected;
 943 }
 944
 945 // -----------------------------------------------------------------------
 946
 947 void
 948 wxPropertyGrid::OnLabelEditorEnterPress( wxCommandEvent& WXUNUSED(event) )
 949 {
 950     DoEndLabelEdit(true);
 951 }
 952
 953 // -----------------------------------------------------------------------
 954
 955 void wxPropertyGrid::OnLabelEditorKeyPress( wxKeyEvent& event )
 956 {
 957     int keycode = event.GetKeyCode();
 958
 959     if ( keycode == WXK_ESCAPE )
 960     {
 961         DoEndLabelEdit(false);
 962     }
 963     else
 964     {
 965         event.Skip();
 966     }
 967 }
 968
 969 // -----------------------------------------------------------------------
 970
 971 void wxPropertyGrid::DoEndLabelEdit( bool commit, int selFlags )
 972 {
 973     if ( !m_labelEditor )
 974         return;
 975
 976     wxPGProperty* prop = m_labelEditorProperty;
 977     wxASSERT(prop);
 978
 979     if ( commit )
 980     {
 981         if ( !(selFlags & wxPG_SEL_DONT_SEND_EVENT) )
 982         {
 983             // wxPG_SEL_NOVALIDATE is passed correctly in selFlags
 984             if ( SendEvent( wxEVT_PG_LABEL_EDIT_ENDING,
 985                             prop, NULL, selFlags,
 986                             m_selColumn ) )
 987                 return;
 988         }
 989
 990         wxString text = m_labelEditor->GetValue();
 991         wxPGCell* cell = NULL;
 992         if ( prop->HasCell(m_selColumn) )
 993         {
 994             cell = &prop->GetCell(m_selColumn);
 995         }
 996         else
 997         {
 998             if ( m_selColumn == 0 )
 999                 prop->SetLabel(text);
1000             else
1001                 cell = &prop->GetOrCreateCell(m_selColumn);
1002         }
1003
1004         if ( cell )
1005             cell->SetText(text);
1006     }
1007
1008     m_selColumn = 1;
1009
1010     DestroyEditorWnd(m_labelEditor);
1011     m_labelEditor = NULL;
1012     m_labelEditorProperty = NULL;
1013
1014     DrawItem(prop);
1015 }
1016
1017 // -----------------------------------------------------------------------
1018
1019 void wxPropertyGrid::SetExtraStyle( long exStyle )
1020 {
1021     if ( exStyle & wxPG_EX_ENABLE_TLP_TRACKING )
1022         OnTLPChanging(::wxGetTopLevelParent(this));
1023     else
1024         OnTLPChanging(NULL);
1025
1026     if ( exStyle & wxPG_EX_NATIVE_DOUBLE_BUFFERING )
1027     {
1028 #if defined(__WXMSW__)
1029
1030         /*
1031         // Don't use WS_EX_COMPOSITED just now.
1032         HWND hWnd;
1033
1034         if ( m_iFlags & wxPG_FL_IN_MANAGER )
1035             hWnd = (HWND)GetParent()->GetHWND();
1036         else
1037             hWnd = (HWND)GetHWND();
1038
1039         ::SetWindowLong( hWnd, GWL_EXSTYLE,
1040                          ::GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_COMPOSITED );
1041         */
1042
1043 //#elif defined(__WXGTK20__)
1044 #endif
1045         // Only apply wxPG_EX_NATIVE_DOUBLE_BUFFERING if the window
1046         // truly was double-buffered.
1047         if ( !this->IsDoubleBuffered() )
1048         {
1049             exStyle &= ~(wxPG_EX_NATIVE_DOUBLE_BUFFERING);
1050         }
1051         else
1052         {
1053         #if wxPG_DOUBLE_BUFFER
1054             delete m_doubleBuffer;
1055             m_doubleBuffer = NULL;
1056         #endif
1057         }
1058     }
1059
1060     wxScrolledWindow::SetExtraStyle( exStyle );
1061
1062     if ( exStyle & wxPG_EX_INIT_NOCAT )
1063         m_pState->InitNonCatMode();
1064
1065     if ( exStyle & wxPG_EX_HELP_AS_TOOLTIPS )
1066         m_windowStyle |= wxPG_TOOLTIPS;
1067
1068     // Set global style
1069     wxPGGlobalVars->m_extraStyle = exStyle;
1070 }
1071
1072 // -----------------------------------------------------------------------
1073
1074 // returns the best acceptable minimal size
1075 wxSize wxPropertyGrid::DoGetBestSize() const
1076 {
1077     int lineHeight = wxMax(15, m_lineHeight);
1078
1079     // don't make the grid too tall (limit height to 10 items) but don't
1080     // make it too small neither
1081     int numLines = wxMin
1082                    (
1083                     wxMax(m_pState->m_properties->GetChildCount(), 3),
1084                     10
1085                    );
1086
1087     wxClientDC dc(const_cast<wxPropertyGrid *>(this));
1088     int width = m_marginWidth;
1089     for ( unsigned int i = 0; i < m_pState->m_colWidths.size(); i++ )
1090     {
1091         width += m_pState->GetColumnFitWidth(dc, m_pState->DoGetRoot(), i, true);
1092     }
1093
1094     const wxSize sz = wxSize(width, lineHeight*numLines + 40);
1095
1096     CacheBestSize(sz);
1097     return sz;
1098 }
1099
1100 // -----------------------------------------------------------------------
1101
1102 void wxPropertyGrid::OnTLPChanging( wxWindow* newTLP )
1103 {
1104     if ( newTLP == m_tlp )
1105         return;
1106
1107     wxLongLong currentTime = ::wxGetLocalTimeMillis();
1108
1109     //
1110     // Parent changed so let's redetermine and re-hook the
1111     // correct top-level window.
1112     if ( m_tlp )
1113     {
1114         m_tlp->Disconnect( wxEVT_CLOSE_WINDOW,
1115                            wxCloseEventHandler(wxPropertyGrid::OnTLPClose),
1116                            NULL, this );
1117         m_tlpClosed = m_tlp;
1118         m_tlpClosedTime = currentTime;
1119     }
1120
1121     if ( newTLP )
1122     {
1123         // Only accept new tlp if same one was not just dismissed.
1124         if ( newTLP != m_tlpClosed ||
1125              m_tlpClosedTime+250 < currentTime )
1126         {
1127             newTLP->Connect( wxEVT_CLOSE_WINDOW,
1128                              wxCloseEventHandler(wxPropertyGrid::OnTLPClose),
1129                              NULL, this );
1130             m_tlpClosed = NULL;
1131         }
1132         else
1133         {
1134             newTLP = NULL;
1135         }
1136     }
1137
1138     m_tlp = newTLP;
1139 }
1140
1141 // -----------------------------------------------------------------------
1142
1143 void wxPropertyGrid::OnTLPClose( wxCloseEvent& event )
1144 {
1145     // ClearSelection forces value validation/commit.
1146     if ( event.CanVeto() && !DoClearSelection() )
1147     {
1148         event.Veto();
1149         return;
1150     }
1151
1152     // Ok, it can close, set tlp pointer to NULL. Some other event
1153     // handler can of course veto the close, but our OnIdle() should
1154     // then be able to regain the tlp pointer.
1155     OnTLPChanging(NULL);
1156
1157     event.Skip();
1158 }
1159
1160 // -----------------------------------------------------------------------
1161
1162 bool wxPropertyGrid::Reparent( wxWindowBase *newParent )
1163 {
1164     OnTLPChanging((wxWindow*)newParent);
1165
1166     bool res = wxScrolledWindow::Reparent(newParent);
1167
1168     return res;
1169 }
1170
1171 // -----------------------------------------------------------------------
1172 // wxPropertyGrid Font and Colour Methods
1173 // -----------------------------------------------------------------------
1174
1175 void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing )
1176 {
1177     int x = 0, y = 0;
1178
1179     m_captionFont = wxScrolledWindow::GetFont();
1180
1181     GetTextExtent(wxS("jG"), &x, &y, 0, 0, &m_captionFont);
1182     m_subgroup_extramargin = x + (x/2);
1183     m_fontHeight = y;
1184
1185 #if wxPG_USE_RENDERER_NATIVE
1186     m_iconWidth = wxPG_ICON_WIDTH;
1187 #elif wxPG_ICON_WIDTH
1188     // scale icon
1189     m_iconWidth = (m_fontHeight * wxPG_ICON_WIDTH) / 13;
1190     if ( m_iconWidth < 5 ) m_iconWidth = 5;
1191     else if ( !(m_iconWidth & 0x01) ) m_iconWidth++; // must be odd
1192
1193 #endif
1194
1195     m_gutterWidth = m_iconWidth / wxPG_GUTTER_DIV;
1196     if ( m_gutterWidth < wxPG_GUTTER_MIN )
1197         m_gutterWidth = wxPG_GUTTER_MIN;
1198
1199     int vdiv = 6;
1200     if ( vspacing <= 1 ) vdiv = 12;
1201     else if ( vspacing >= 3 ) vdiv = 3;
1202
1203     m_spacingy = m_fontHeight / vdiv;
1204     if ( m_spacingy < wxPG_YSPACING_MIN )
1205         m_spacingy = wxPG_YSPACING_MIN;
1206
1207     m_marginWidth = 0;
1208     if ( !(m_windowStyle & wxPG_HIDE_MARGIN) )
1209         m_marginWidth = m_gutterWidth*2 + m_iconWidth;
1210
1211     m_captionFont.SetWeight(wxBOLD);
1212     GetTextExtent(wxS("jG"), &x, &y, 0, 0, &m_captionFont);
1213
1214     m_lineHeight = m_fontHeight+(2*m_spacingy)+1;
1215
1216     // button spacing
1217     m_buttonSpacingY = (m_lineHeight - m_iconHeight) / 2;
1218     if ( m_buttonSpacingY < 0 ) m_buttonSpacingY = 0;
1219
1220     if ( m_pState )
1221         m_pState->CalculateFontAndBitmapStuff(vspacing);
1222
1223     if ( m_iFlags & wxPG_FL_INITIALIZED )
1224         RecalculateVirtualSize();
1225
1226     InvalidateBestSize();
1227 }
1228
1229 // -----------------------------------------------------------------------
1230
1231 void wxPropertyGrid::OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) )
1232 {
1233     RegainColours();
1234     Refresh();
1235 }
1236
1237 // -----------------------------------------------------------------------
1238
1239 static wxColour wxPGAdjustColour(const wxColour& src, int ra,
1240                                  int ga = 1000, int ba = 1000,
1241                                  bool forceDifferent = false)
1242 {
1243     if ( ga >= 1000 )
1244         ga = ra;
1245     if ( ba >= 1000 )
1246         ba = ra;
1247
1248     // Recursion guard (allow 2 max)
1249     static int isinside = 0;
1250     isinside++;
1251     wxCHECK_MSG( isinside < 3,
1252                  *wxBLACK,
1253                  wxT("wxPGAdjustColour should not be recursively called more than once") );
1254
1255     wxColour dst;
1256
1257     int r = src.Red();
1258     int g = src.Green();
1259     int b = src.Blue();
1260     int r2 = r + ra;
1261     if ( r2>255 ) r2 = 255;
1262     else if ( r2<0) r2 = 0;
1263     int g2 = g + ga;
1264     if ( g2>255 ) g2 = 255;
1265     else if ( g2<0) g2 = 0;
1266     int b2 = b + ba;
1267     if ( b2>255 ) b2 = 255;
1268     else if ( b2<0) b2 = 0;
1269
1270     // Make sure they are somewhat different
1271     if ( forceDifferent && (abs((r+g+b)-(r2+g2+b2)) < abs(ra/2)) )
1272         dst = wxPGAdjustColour(src,-(ra*2));
1273     else
1274         dst = wxColour(r2,g2,b2);
1275
1276     // Recursion guard (allow 2 max)
1277     isinside--;
1278
1279     return dst;
1280 }
1281
1282
1283 static int wxPGGetColAvg( const wxColour& col )
1284 {
1285     return (col.Red() + col.Green() + col.Blue()) / 3;
1286 }
1287
1288
1289 void wxPropertyGrid::RegainColours()
1290 {
1291     if ( !(m_coloursCustomized & 0x0002) )
1292     {
1293         wxColour col = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
1294
1295         // Make sure colour is dark enough
1296     #ifdef __WXGTK__
1297         int colDec = wxPGGetColAvg(col) - 230;
1298     #else
1299         int colDec = wxPGGetColAvg(col) - 200;
1300     #endif
1301         if ( colDec > 0 )
1302             m_colCapBack = wxPGAdjustColour(col,-colDec);
1303         else
1304             m_colCapBack = col;
1305         m_categoryDefaultCell.GetData()->SetBgCol(m_colCapBack);
1306     }
1307
1308     if ( !(m_coloursCustomized & 0x0001) )
1309         m_colMargin = m_colCapBack;
1310
1311     if ( !(m_coloursCustomized & 0x0004) )
1312     {
1313     #ifdef __WXGTK__
1314         int colDec = -90;
1315     #else
1316         int colDec = -72;
1317     #endif
1318         wxColour capForeCol = wxPGAdjustColour(m_colCapBack,colDec,5000,5000,true);
1319         m_colCapFore = capForeCol;
1320         m_categoryDefaultCell.GetData()->SetFgCol(capForeCol);
1321     }
1322
1323     if ( !(m_coloursCustomized & 0x0008) )
1324     {
1325         wxColour bgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
1326         m_colPropBack = bgCol;
1327         m_propertyDefaultCell.GetData()->SetBgCol(bgCol);
1328     }
1329
1330     if ( !(m_coloursCustomized & 0x0010) )
1331     {
1332         wxColour fgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
1333         m_colPropFore = fgCol;
1334         m_propertyDefaultCell.GetData()->SetFgCol(fgCol);
1335     }
1336
1337     if ( !(m_coloursCustomized & 0x0020) )
1338         m_colSelBack = wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT );
1339
1340     if ( !(m_coloursCustomized & 0x0040) )
1341         m_colSelFore = wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
1342
1343     if ( !(m_coloursCustomized & 0x0080) )
1344         m_colLine = m_colCapBack;
1345
1346     if ( !(m_coloursCustomized & 0x0100) )
1347         m_colDisPropFore = m_colCapFore;
1348
1349     m_colEmptySpace = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
1350 }
1351
1352 // -----------------------------------------------------------------------
1353
1354 void wxPropertyGrid::ResetColours()
1355 {
1356     m_coloursCustomized = 0;
1357
1358     RegainColours();
1359
1360     Refresh();
1361 }
1362
1363 // -----------------------------------------------------------------------
1364
1365 bool wxPropertyGrid::SetFont( const wxFont& font )
1366 {
1367     // Must disable active editor.
1368     DoClearSelection();
1369
1370     bool res = wxScrolledWindow::SetFont( font );
1371     if ( res && GetParent()) // may not have been Create()ed yet if SetFont called from SetWindowVariant
1372     {
1373         CalculateFontAndBitmapStuff( m_vspacing );
1374         Refresh();
1375     }
1376
1377     return res;
1378 }
1379
1380 // -----------------------------------------------------------------------
1381
1382 void wxPropertyGrid::SetLineColour( const wxColour& col )
1383 {
1384     m_colLine = col;
1385     m_coloursCustomized |= 0x80;
1386     Refresh();
1387 }
1388
1389 // -----------------------------------------------------------------------
1390
1391 void wxPropertyGrid::SetMarginColour( const wxColour& col )
1392 {
1393     m_colMargin = col;
1394     m_coloursCustomized |= 0x01;
1395     Refresh();
1396 }
1397
1398 // -----------------------------------------------------------------------
1399
1400 void wxPropertyGrid::SetCellBackgroundColour( const wxColour& col )
1401 {
1402     m_colPropBack = col;
1403     m_coloursCustomized |= 0x08;
1404
1405     m_propertyDefaultCell.GetData()->SetBgCol(col);
1406
1407     Refresh();
1408 }
1409
1410 // -----------------------------------------------------------------------
1411
1412 void wxPropertyGrid::SetCellTextColour( const wxColour& col )
1413 {
1414     m_colPropFore = col;
1415     m_coloursCustomized |= 0x10;
1416
1417     m_propertyDefaultCell.GetData()->SetFgCol(col);
1418
1419     Refresh();
1420 }
1421
1422 // -----------------------------------------------------------------------
1423
1424 void wxPropertyGrid::SetEmptySpaceColour( const wxColour& col )
1425 {
1426     m_colEmptySpace = col;
1427
1428     Refresh();
1429 }
1430
1431 // -----------------------------------------------------------------------
1432
1433 void wxPropertyGrid::SetCellDisabledTextColour( const wxColour& col )
1434 {
1435     m_colDisPropFore = col;
1436     m_coloursCustomized |= 0x100;
1437     Refresh();
1438 }
1439
1440 // -----------------------------------------------------------------------
1441
1442 void wxPropertyGrid::SetSelectionBackgroundColour( const wxColour& col )
1443 {
1444     m_colSelBack = col;
1445     m_coloursCustomized |= 0x20;
1446     Refresh();
1447 }
1448
1449 // -----------------------------------------------------------------------
1450
1451 void wxPropertyGrid::SetSelectionTextColour( const wxColour& col )
1452 {
1453     m_colSelFore = col;
1454     m_coloursCustomized |= 0x40;
1455     Refresh();
1456 }
1457
1458 // -----------------------------------------------------------------------
1459
1460 void wxPropertyGrid::SetCaptionBackgroundColour( const wxColour& col )
1461 {
1462     m_colCapBack = col;
1463     m_coloursCustomized |= 0x02;
1464
1465     m_categoryDefaultCell.GetData()->SetBgCol(col);
1466
1467     Refresh();
1468 }
1469
1470 // -----------------------------------------------------------------------
1471
1472 void wxPropertyGrid::SetCaptionTextColour( const wxColour& col )
1473 {
1474     m_colCapFore = col;
1475     m_coloursCustomized |= 0x04;
1476
1477     m_categoryDefaultCell.GetData()->SetFgCol(col);
1478
1479     Refresh();
1480 }
1481
1482 // -----------------------------------------------------------------------
1483 // wxPropertyGrid property adding and removal
1484 // -----------------------------------------------------------------------
1485
1486 void wxPropertyGrid::PrepareAfterItemsAdded()
1487 {
1488     if ( !m_pState || !m_pState->m_itemsAdded ) return;
1489
1490     m_pState->m_itemsAdded = 0;
1491
1492     if ( m_windowStyle & wxPG_AUTO_SORT )
1493         Sort(wxPG_SORT_TOP_LEVEL_ONLY);
1494
1495     RecalculateVirtualSize();
1496 }
1497
1498 // -----------------------------------------------------------------------
1499 // wxPropertyGrid property operations
1500 // -----------------------------------------------------------------------
1501
1502 bool wxPropertyGrid::EnsureVisible( wxPGPropArg id )
1503 {
1504     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
1505
1506     Update();
1507
1508     bool changed = false;
1509
1510     // Is it inside collapsed section?
1511     if ( !p->IsVisible() )
1512     {
1513         // expand parents
1514         wxPGProperty* parent = p->GetParent();
1515         wxPGProperty* grandparent = parent->GetParent();
1516
1517         if ( grandparent && grandparent != m_pState->m_properties )
1518             Expand( grandparent );
1519
1520         Expand( parent );
1521         changed = true;
1522     }
1523
1524     // Need to scroll?
1525     int vx, vy;
1526     GetViewStart(&vx,&vy);
1527     vy*=wxPG_PIXELS_PER_UNIT;
1528
1529     int y = p->GetY();
1530
1531     if ( y < vy )
1532     {
1533         Scroll(vx, y/wxPG_PIXELS_PER_UNIT );
1534         m_iFlags |= wxPG_FL_SCROLLED;
1535         changed = true;
1536     }
1537     else if ( (y+m_lineHeight) > (vy+m_height) )
1538     {
1539         Scroll(vx, (y-m_height+(m_lineHeight*2))/wxPG_PIXELS_PER_UNIT );
1540         m_iFlags |= wxPG_FL_SCROLLED;
1541         changed = true;
1542     }
1543
1544     if ( changed )
1545         DrawItems( p, p );
1546
1547     return changed;
1548 }
1549
1550 // -----------------------------------------------------------------------
1551 // wxPropertyGrid helper methods called by properties
1552 // -----------------------------------------------------------------------
1553
1554 // Control font changer helper.
1555 void wxPropertyGrid::SetCurControlBoldFont()
1556 {
1557     wxASSERT( m_wndEditor );
1558     m_wndEditor->SetFont( m_captionFont );
1559 }
1560
1561 // -----------------------------------------------------------------------
1562
1563 wxPoint wxPropertyGrid::GetGoodEditorDialogPosition( wxPGProperty* p,
1564                                                      const wxSize& sz )
1565 {
1566 #if wxPG_SMALL_SCREEN
1567     // On small-screen devices, always show dialogs with default position and size.
1568     return wxDefaultPosition;
1569 #else
1570     int splitterX = GetSplitterPosition();
1571     int x = splitterX;
1572     int y = p->GetY();
1573
1574     wxCHECK_MSG( y >= 0, wxPoint(-1,-1), wxT("invalid y?") );
1575
1576     ImprovedClientToScreen( &x, &y );
1577
1578     int sw = wxSystemSettings::GetMetric( ::wxSYS_SCREEN_X );
1579     int sh = wxSystemSettings::GetMetric( ::wxSYS_SCREEN_Y );
1580
1581     int new_x;
1582     int new_y;
1583
1584     if ( x > (sw/2) )
1585         // left
1586         new_x = x + (m_width-splitterX) - sz.x;
1587     else
1588         // right
1589         new_x = x;
1590
1591     if ( y > (sh/2) )
1592         // above
1593         new_y = y - sz.y;
1594     else
1595         // below
1596         new_y = y + m_lineHeight;
1597
1598     return wxPoint(new_x,new_y);
1599 #endif
1600 }
1601
1602 // -----------------------------------------------------------------------
1603
1604 wxString& wxPropertyGrid::ExpandEscapeSequences( wxString& dst_str, wxString& src_str )
1605 {
1606     if ( src_str.length() == 0 )
1607     {
1608         dst_str = src_str;
1609         return src_str;
1610     }
1611
1612     bool prev_is_slash = false;
1613
1614     wxString::const_iterator i = src_str.begin();
1615
1616     dst_str.clear();
1617
1618     for ( ; i != src_str.end(); ++i )
1619     {
1620         wxUniChar a = *i;
1621
1622         if ( a != wxS('\\') )
1623         {
1624             if ( !prev_is_slash )
1625             {
1626                 dst_str << a;
1627             }
1628             else
1629             {
1630                 if ( a == wxS('n') )
1631                 {
1632             #ifdef __WXMSW__
1633                     dst_str << wxS('\n');
1634             #else
1635                     dst_str << wxS('\n');
1636             #endif
1637                 }
1638                 else if ( a == wxS('t') )
1639                     dst_str << wxS('\t');
1640                 else
1641                     dst_str << a;
1642             }
1643             prev_is_slash = false;
1644         }
1645         else
1646         {
1647             if ( prev_is_slash )
1648             {
1649                 dst_str << wxS('\\');
1650                 prev_is_slash = false;
1651             }
1652             else
1653             {
1654                 prev_is_slash = true;
1655             }
1656         }
1657     }
1658     return dst_str;
1659 }
1660
1661 // -----------------------------------------------------------------------
1662
1663 wxString& wxPropertyGrid::CreateEscapeSequences( wxString& dst_str, wxString& src_str )
1664 {
1665     if ( src_str.length() == 0 )
1666     {
1667         dst_str = src_str;
1668         return src_str;
1669     }
1670
1671     wxString::const_iterator i = src_str.begin();
1672     wxUniChar prev_a = wxS('\0');
1673
1674     dst_str.clear();
1675
1676     for ( ; i != src_str.end(); ++i )
1677     {
1678         wxChar a = *i;
1679
1680         if ( a >= wxS(' ') )
1681         {
1682             // This surely is not something that requires an escape sequence.
1683             dst_str << a;
1684         }
1685         else
1686         {
1687             // This might need...
1688             if ( a == wxS('\r')  )
1689             {
1690                 // DOS style line end.
1691                 // Already taken care below
1692             }
1693             else if ( a == wxS('\n') )
1694                 // UNIX style line end.
1695                 dst_str << wxS("\\n");
1696             else if ( a == wxS('\t') )
1697                 // Tab.
1698                 dst_str << wxS('\t');
1699             else
1700             {
1701                 //wxLogDebug(wxT("WARNING: Could not create escape sequence for character #%i"),(int)a);
1702                 dst_str << a;
1703             }
1704         }
1705
1706         prev_a = a;
1707     }
1708     return dst_str;
1709 }
1710
1711 // -----------------------------------------------------------------------
1712
1713 wxPGProperty* wxPropertyGrid::DoGetItemAtY( int y ) const
1714 {
1715     // Outside?
1716     if ( y < 0 )
1717         return NULL;
1718
1719     unsigned int a = 0;
1720     return m_pState->m_properties->GetItemAtY(y, m_lineHeight, &a);
1721 }
1722
1723 // -----------------------------------------------------------------------
1724 // wxPropertyGrid graphics related methods
1725 // -----------------------------------------------------------------------
1726
1727 void wxPropertyGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
1728 {
1729     wxPaintDC dc(this);
1730     PrepareDC(dc);
1731
1732     // Don't paint after destruction has begun
1733     if ( !HasInternalFlag(wxPG_FL_INITIALIZED) )
1734         return;
1735
1736     // Find out where the window is scrolled to
1737     int vx,vy;                     // Top left corner of client
1738     GetViewStart(&vx,&vy);
1739     vy *= wxPG_PIXELS_PER_UNIT;
1740
1741     // Update everything inside the box
1742     wxRect r = GetUpdateRegion().GetBox();
1743
1744     r.y += vy;
1745
1746     // FIXME: This is just a workaround for a bug that causes splitters not
1747     //        to paint when other windows are being dragged over the grid.
1748     r.x = 0;
1749     r.width = GetClientSize().x;
1750
1751     // Repaint this rectangle
1752     DrawItems( dc, r.y, r.y + r.height, &r );
1753
1754     // We assume that the size set when grid is shown
1755     // is what is desired.
1756     SetInternalFlag(wxPG_FL_GOOD_SIZE_SET);
1757 }
1758
1759 // -----------------------------------------------------------------------
1760
1761 void wxPropertyGrid::DrawExpanderButton( wxDC& dc, const wxRect& rect,
1762                                          wxPGProperty* property ) const
1763 {
1764     // Prepare rectangle to be used
1765     wxRect r(rect);
1766     r.x += m_gutterWidth; r.y += m_buttonSpacingY;
1767     r.width = m_iconWidth; r.height = m_iconHeight;
1768
1769 #if (wxPG_USE_RENDERER_NATIVE)
1770     //
1771 #elif wxPG_ICON_WIDTH
1772     // Drawing expand/collapse button manually
1773     dc.SetPen(m_colPropFore);
1774     if ( property->IsCategory() )
1775         dc.SetBrush(*wxTRANSPARENT_BRUSH);
1776     else
1777         dc.SetBrush(m_colPropBack);
1778
1779     dc.DrawRectangle( r );
1780     int _y = r.y+(m_iconWidth/2);
1781     dc.DrawLine(r.x+2,_y,r.x+m_iconWidth-2,_y);
1782 #else
1783     wxBitmap* bmp;
1784 #endif
1785
1786     if ( property->IsExpanded() )
1787     {
1788     // wxRenderer functions are non-mutating in nature, so it
1789     // should be safe to cast "const wxPropertyGrid*" to "wxWindow*".
1790     // Hopefully this does not cause problems.
1791     #if (wxPG_USE_RENDERER_NATIVE)
1792         wxRendererNative::Get().DrawTreeItemButton(
1793                 (wxWindow*)this,
1794                 dc,
1795                 r,
1796                 wxCONTROL_EXPANDED
1797             );
1798     #elif wxPG_ICON_WIDTH
1799         //
1800     #else
1801         bmp = m_collbmp;
1802     #endif
1803
1804     }
1805     else
1806     {
1807     #if (wxPG_USE_RENDERER_NATIVE)
1808         wxRendererNative::Get().DrawTreeItemButton(
1809                 (wxWindow*)this,
1810                 dc,
1811                 r,
1812                 0
1813             );
1814     #elif wxPG_ICON_WIDTH
1815         int _x = r.x+(m_iconWidth/2);
1816         dc.DrawLine(_x,r.y+2,_x,r.y+m_iconWidth-2);
1817     #else
1818         bmp = m_expandbmp;
1819     #endif
1820     }
1821
1822 #if (wxPG_USE_RENDERER_NATIVE)
1823     //
1824 #elif wxPG_ICON_WIDTH
1825     //
1826 #else
1827     dc.DrawBitmap( *bmp, r.x, r.y, true );
1828 #endif
1829 }
1830
1831 // -----------------------------------------------------------------------
1832
1833 //
1834 // This is the one called by OnPaint event handler and others.
1835 // topy and bottomy are already unscrolled (ie. physical)
1836 //
1837 void wxPropertyGrid::DrawItems( wxDC& dc,
1838                                 unsigned int topItemY,
1839                                 unsigned int bottomItemY,
1840                                 const wxRect* drawRect )
1841 {
1842     if ( m_frozen ||
1843          m_height < 1 ||
1844          bottomItemY < topItemY ||
1845          !m_pState )
1846         return;
1847
1848     m_pState->EnsureVirtualHeight();
1849
1850     wxRect tempDrawRect;
1851     if ( !drawRect )
1852     {
1853         tempDrawRect = wxRect(0, topItemY,
1854                               m_pState->m_width,
1855                               bottomItemY);
1856         drawRect = &tempDrawRect;
1857     }
1858
1859     // items added check
1860     if ( m_pState->m_itemsAdded ) PrepareAfterItemsAdded();
1861
1862     int paintFinishY = 0;
1863
1864     if ( m_pState->m_properties->GetChildCount() > 0 )
1865     {
1866         wxDC* dcPtr = &dc;
1867         bool isBuffered = false;
1868
1869     #if wxPG_DOUBLE_BUFFER
1870         wxMemoryDC* bufferDC = NULL;
1871
1872         if ( !(GetExtraStyle() & wxPG_EX_NATIVE_DOUBLE_BUFFERING) )
1873         {
1874             if ( !m_doubleBuffer )
1875             {
1876                 paintFinishY = drawRect->y;
1877                 dcPtr = NULL;
1878             }
1879             else
1880             {
1881                 bufferDC = new wxMemoryDC();
1882
1883                 // If nothing was changed, then just copy from double-buffer
1884                 bufferDC->SelectObject( *m_doubleBuffer );
1885                 dcPtr = bufferDC;
1886
1887                 isBuffered = true;
1888             }
1889         }
1890     #endif
1891
1892         if ( dcPtr )
1893         {
1894             dc.SetClippingRegion( *drawRect );
1895             paintFinishY = DoDrawItems( *dcPtr, drawRect, isBuffered );
1896             int drawBottomY = drawRect->y + drawRect->height;
1897
1898             // Clear area beyond last painted property
1899             if ( paintFinishY < drawBottomY )
1900             {
1901                 dcPtr->SetPen(m_colEmptySpace);
1902                 dcPtr->SetBrush(m_colEmptySpace);
1903                 dcPtr->DrawRectangle(0, paintFinishY,
1904                                      m_width,
1905                                      drawBottomY );
1906             }
1907
1908             dc.DestroyClippingRegion();
1909         }
1910
1911     #if wxPG_DOUBLE_BUFFER
1912         if ( bufferDC )
1913         {
1914             dc.Blit( drawRect->x, drawRect->y, drawRect->width,
1915                      drawRect->height,
1916                      bufferDC, 0, 0, wxCOPY );
1917             delete bufferDC;
1918         }
1919     #endif
1920     }
1921     else
1922     {
1923         // Just clear the area
1924         dc.SetPen(m_colEmptySpace);
1925         dc.SetBrush(m_colEmptySpace);
1926         dc.DrawRectangle(*drawRect);
1927     }
1928 }
1929
1930 // -----------------------------------------------------------------------
1931
1932 int wxPropertyGrid::DoDrawItems( wxDC& dc,
1933                                  const wxRect* drawRect,
1934                                  bool isBuffered ) const
1935 {
1936     const wxPGProperty* firstItem;
1937     const wxPGProperty* lastItem;
1938
1939     firstItem = DoGetItemAtY(drawRect->y);
1940     lastItem = DoGetItemAtY(drawRect->y+drawRect->height-1);
1941
1942     if ( !lastItem )
1943         lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );
1944
1945     if ( m_frozen || m_height < 1 || firstItem == NULL )
1946         return drawRect->y;
1947
1948     wxCHECK_MSG( !m_pState->m_itemsAdded, drawRect->y,
1949                  "no items added" );
1950     wxASSERT( m_pState->m_properties->GetChildCount() );
1951
1952     int lh = m_lineHeight;
1953
1954     int firstItemTopY;
1955     int lastItemBottomY;
1956
1957     firstItemTopY = drawRect->y;
1958     lastItemBottomY = drawRect->y + drawRect->height;
1959
1960     // Align y coordinates to item boundaries
1961     firstItemTopY -= firstItemTopY % lh;
1962     lastItemBottomY += lh - (lastItemBottomY % lh);
1963     lastItemBottomY -= 1;
1964
1965     // Entire range outside scrolled, visible area?
1966     if ( firstItemTopY >= (int)m_pState->GetVirtualHeight() ||
1967          lastItemBottomY <= 0 )
1968         return drawRect->y;
1969
1970     wxCHECK_MSG( firstItemTopY < lastItemBottomY,
1971                  drawRect->y,
1972                  "invalid y values" );
1973
1974     /*
1975     wxLogDebug("  -> DoDrawItems ( \"%s\" -> \"%s\"
1976                "height=%i (ch=%i), drawRect = 0x%lX )",
1977         firstItem->GetLabel().c_str(),
1978         lastItem->GetLabel().c_str(),
1979         (int)(lastItemBottomY - firstItemTopY),
1980         (int)m_height,
1981         (unsigned long)drawRect );
1982     */
1983
1984     wxRect r;
1985
1986     long windowStyle = m_windowStyle;
1987
1988     int xRelMod = 0;
1989
1990     //
1991     // With wxPG_DOUBLE_BUFFER, do double buffering
1992     // - buffer's y = 0, so align drawRect and coordinates to that
1993     //
1994 #if wxPG_DOUBLE_BUFFER
1995     int yRelMod = 0;
1996
1997     wxRect cr2;
1998
1999     if ( isBuffered )
2000     {
2001         xRelMod = drawRect->x;
2002         yRelMod = drawRect->y;
2003
2004         //
2005         // drawRect conversion
2006         cr2 = *drawRect;
2007         cr2.x -= xRelMod;
2008         cr2.y -= yRelMod;
2009         drawRect = &cr2;
2010         firstItemTopY -= yRelMod;
2011         lastItemBottomY -= yRelMod;
2012     }
2013 #else
2014     wxUnusedVar(isBuffered);
2015 #endif
2016
2017     int x = m_marginWidth - xRelMod;
2018
2019     wxFont normalFont = GetFont();
2020
2021     bool reallyFocused = (m_iFlags & wxPG_FL_FOCUSED) != 0;
2022
2023     bool isPgEnabled = IsEnabled();
2024
2025     //
2026     // Prepare some pens and brushes that are often changed to.
2027     //
2028
2029     wxBrush marginBrush(m_colMargin);
2030     wxPen marginPen(m_colMargin);
2031     wxBrush capbgbrush(m_colCapBack,wxSOLID);
2032     wxPen linepen(m_colLine,1,wxSOLID);
2033
2034     wxColour selBackCol;
2035     if ( isPgEnabled )
2036         selBackCol = m_colSelBack;
2037     else
2038         selBackCol = m_colMargin;
2039
2040     // pen that has same colour as text
2041     wxPen outlinepen(m_colPropFore,1,wxSOLID);
2042
2043     //
2044     // Clear margin with background colour
2045     //
2046     dc.SetBrush( marginBrush );
2047     if ( !(windowStyle & wxPG_HIDE_MARGIN) )
2048     {
2049         dc.SetPen( *wxTRANSPARENT_PEN );
2050         dc.DrawRectangle(-1-xRelMod,firstItemTopY-1,x+2,lastItemBottomY-firstItemTopY+2);
2051     }
2052
2053     const wxPGProperty* firstSelected = GetSelection();
2054     const wxPropertyGridPageState* state = m_pState;
2055
2056 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
2057     bool wasSelectedPainted = false;
2058 #endif
2059
2060     // TODO: Only render columns that are within clipping region.
2061
2062     dc.SetFont(normalFont);
2063
2064     wxPropertyGridConstIterator it( state, wxPG_ITERATE_VISIBLE, firstItem );
2065     int endScanBottomY = lastItemBottomY + lh;
2066     int y = firstItemTopY;
2067
2068     //
2069     // Pregenerate list of visible properties.
2070     wxArrayPGProperty visPropArray;
2071     visPropArray.reserve((m_height/m_lineHeight)+6);
2072
2073     for ( ; !it.AtEnd(); it.Next() )
2074     {
2075         const wxPGProperty* p = *it;
2076
2077         if ( !p->HasFlag(wxPG_PROP_HIDDEN) )
2078         {
2079             visPropArray.push_back((wxPGProperty*)p);
2080
2081             if ( y > endScanBottomY )
2082                 break;
2083
2084             y += lh;
2085         }
2086     }
2087
2088     visPropArray.push_back(NULL);
2089
2090     wxPGProperty* nextP = visPropArray[0];
2091
2092     int gridWidth = state->m_width;
2093
2094     y = firstItemTopY;
2095     for ( unsigned int arrInd=1;
2096           nextP && y <= lastItemBottomY;
2097           arrInd++ )
2098     {
2099         wxPGProperty* p = nextP;
2100         nextP = visPropArray[arrInd];
2101
2102         int rowHeight = m_fontHeight+(m_spacingy*2)+1;
2103         int textMarginHere = x;
2104         int renderFlags = 0;
2105
2106         int greyDepth = m_marginWidth;
2107         if ( !(windowStyle & wxPG_HIDE_CATEGORIES) )
2108             greyDepth = (((int)p->m_depthBgCol)-1) * m_subgroup_extramargin + m_marginWidth;
2109
2110         int greyDepthX = greyDepth - xRelMod;
2111
2112         // Use basic depth if in non-categoric mode and parent is base array.
2113         if ( !(windowStyle & wxPG_HIDE_CATEGORIES) || p->GetParent() != m_pState->m_properties )
2114         {
2115             textMarginHere += ((unsigned int)((p->m_depth-1)*m_subgroup_extramargin));
2116         }
2117
2118         // Paint margin area
2119         dc.SetBrush(marginBrush);
2120         dc.SetPen(marginPen);
2121         dc.DrawRectangle( -xRelMod, y, greyDepth, lh );
2122
2123         dc.SetPen( linepen );
2124
2125         int y2 = y + lh;
2126
2127 #ifdef __WXMSW__
2128         // Margin Edge
2129         // Modified by JACS to not draw a margin if wxPG_HIDE_MARGIN is specified, since it
2130         // looks better, at least under Windows when we have a themed border (the themed-window-specific
2131         // whitespace between the real border and the propgrid margin exacerbates the double-border look).
2132
2133         // Is this or its parent themed?
2134         bool suppressMarginEdge = (GetWindowStyle() & wxPG_HIDE_MARGIN) &&
2135             (((GetWindowStyle() & wxBORDER_MASK) == wxBORDER_THEME) ||
2136             (((GetWindowStyle() & wxBORDER_MASK) == wxBORDER_NONE) && ((GetParent()->GetWindowStyle() & wxBORDER_MASK) == wxBORDER_THEME)));
2137 #else
2138         bool suppressMarginEdge = false;
2139 #endif
2140         if (!suppressMarginEdge)
2141             dc.DrawLine( greyDepthX, y, greyDepthX, y2 );
2142         else
2143         {
2144             // Blank out the margin edge
2145             dc.SetPen(wxPen(GetBackgroundColour()));
2146             dc.DrawLine( greyDepthX, y, greyDepthX, y2 );
2147             dc.SetPen( linepen );
2148         }
2149
2150         // Splitters
2151         unsigned int si;
2152         int sx = x;
2153
2154         for ( si=0; si<state->m_colWidths.size(); si++ )
2155         {
2156             sx += state->m_colWidths[si];
2157             dc.DrawLine( sx, y, sx, y2 );
2158         }
2159
2160         // Horizontal Line, below
2161         //   (not if both this and next is category caption)
2162         if ( p->IsCategory() &&
2163              nextP && nextP->IsCategory() )
2164             dc.SetPen(m_colCapBack);
2165
2166         dc.DrawLine( greyDepthX, y2-1, gridWidth-xRelMod, y2-1 );
2167
2168         //
2169         // Need to override row colours?
2170         wxColour rowFgCol;
2171         wxColour rowBgCol;
2172
2173         bool isSelected = state->DoIsPropertySelected(p);
2174
2175         if ( !isSelected )
2176         {
2177             // Disabled may get different colour.
2178             if ( !p->IsEnabled() )
2179             {
2180                 renderFlags |= wxPGCellRenderer::Disabled |
2181                                wxPGCellRenderer::DontUseCellFgCol;
2182                 rowFgCol = m_colDisPropFore;
2183             }
2184         }
2185         else
2186         {
2187 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
2188             if ( p == firstSelected )
2189                 wasSelectedPainted = true;
2190 #endif
2191
2192             renderFlags |= wxPGCellRenderer::Selected;
2193
2194             if ( !p->IsCategory() )
2195             {
2196                 renderFlags |= wxPGCellRenderer::DontUseCellFgCol |
2197                                wxPGCellRenderer::DontUseCellBgCol;
2198
2199                 if ( reallyFocused && p == firstSelected )
2200                 {
2201                     rowFgCol = m_colSelFore;
2202                     rowBgCol = selBackCol;
2203                 }
2204                 else if ( isPgEnabled )
2205                 {
2206                     rowFgCol = m_colPropFore;
2207                     if ( p == firstSelected )
2208                         rowBgCol = m_colMargin;
2209                     else
2210                         rowBgCol = selBackCol;
2211                 }
2212                 else
2213                 {
2214                     rowFgCol = m_colDisPropFore;
2215                     rowBgCol = selBackCol;
2216                 }
2217             }
2218         }
2219
2220         wxBrush rowBgBrush;
2221
2222         if ( rowBgCol.IsOk() )
2223             rowBgBrush = wxBrush(rowBgCol);
2224
2225         if ( HasInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL) )
2226             renderFlags = renderFlags & ~wxPGCellRenderer::DontUseCellColours;
2227
2228         //
2229         // Fill additional margin area with background colour of first cell
2230         if ( greyDepthX < textMarginHere )
2231         {
2232             if ( !(renderFlags & wxPGCellRenderer::DontUseCellBgCol) )
2233             {
2234                 wxPGCell& cell = p->GetCell(0);
2235                 rowBgCol = cell.GetBgCol();
2236                 rowBgBrush = wxBrush(rowBgCol);
2237             }
2238             dc.SetBrush(rowBgBrush);
2239             dc.SetPen(rowBgCol);
2240             dc.DrawRectangle(greyDepthX+1, y,
2241                              textMarginHere-greyDepthX, lh-1);
2242         }
2243
2244         bool fontChanged = false;
2245
2246         // Expander button rectangle
2247         wxRect butRect( ((p->m_depth - 1) * m_subgroup_extramargin) - xRelMod,
2248                         y,
2249                         m_marginWidth,
2250                         lh );
2251
2252         if ( p->IsCategory() )
2253         {
2254             // Captions have their cell areas merged as one
2255             dc.SetFont(m_captionFont);
2256             fontChanged = true;
2257             wxRect cellRect(greyDepthX, y, gridWidth - greyDepth + 2, rowHeight-1 );
2258
2259             if ( renderFlags & wxPGCellRenderer::DontUseCellBgCol )
2260             {
2261                 dc.SetBrush(rowBgBrush);
2262                 dc.SetPen(rowBgCol);
2263             }
2264
2265             if ( renderFlags & wxPGCellRenderer::DontUseCellFgCol )
2266             {
2267                 dc.SetTextForeground(rowFgCol);
2268             }
2269
2270             wxPGCellRenderer* renderer = p->GetCellRenderer(0);
2271             renderer->Render( dc, cellRect, this, p, 0, -1, renderFlags );
2272
2273             // Tree Item Button
2274             if ( !HasFlag(wxPG_HIDE_MARGIN) && p->HasVisibleChildren() )
2275                 DrawExpanderButton( dc, butRect, p );
2276         }
2277         else
2278         {
2279             // Fine tune button rectangle to actually fit the cell
2280             if ( butRect.x > 0 )
2281                 butRect.x += IN_CELL_EXPANDER_BUTTON_X_ADJUST;
2282
2283             if ( p->m_flags & wxPG_PROP_MODIFIED && (windowStyle & wxPG_BOLD_MODIFIED) )
2284             {
2285                 dc.SetFont(m_captionFont);
2286                 fontChanged = true;
2287             }
2288
2289             unsigned int ci;
2290             int cellX = x + 1;
2291             int nextCellWidth = state->m_colWidths[0] -
2292                                 (greyDepthX - m_marginWidth);
2293             wxRect cellRect(greyDepthX+1, y, 0, rowHeight-1);
2294             int textXAdd = textMarginHere - greyDepthX;
2295
2296             for ( ci=0; ci<state->m_colWidths.size(); ci++ )
2297             {
2298                 cellRect.width = nextCellWidth - 1;
2299
2300                 wxWindow* cellEditor = NULL;
2301                 int cellRenderFlags = renderFlags;
2302
2303                 // Tree Item Button (must be drawn before clipping is set up)
2304                 if ( ci == 0 && !HasFlag(wxPG_HIDE_MARGIN) && p->HasVisibleChildren() )
2305                     DrawExpanderButton( dc, butRect, p );
2306
2307                 // Background
2308                 if ( isSelected && (ci == 1 || ci == m_selColumn) )
2309                 {
2310                     if ( p == firstSelected )
2311                     {
2312                         if ( ci == 1 && m_wndEditor )
2313                             cellEditor = m_wndEditor;
2314                         else if ( ci == m_selColumn && m_labelEditor )
2315                             cellEditor = m_labelEditor;
2316                     }
2317
2318                     if ( cellEditor )
2319                     {
2320                         wxColour editorBgCol =
2321                             cellEditor->GetBackgroundColour();
2322                         dc.SetBrush(editorBgCol);
2323                         dc.SetPen(editorBgCol);
2324                         dc.SetTextForeground(m_colPropFore);
2325                         dc.DrawRectangle(cellRect);
2326
2327                         if ( m_dragStatus != 0 ||
2328                              (m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE) )
2329                             cellEditor = NULL;
2330                     }
2331                     else
2332                     {
2333                         dc.SetBrush(m_colPropBack);
2334                         dc.SetPen(m_colPropBack);
2335                         dc.SetTextForeground(m_colDisPropFore);
2336                         if ( p->IsEnabled() )
2337                             dc.SetTextForeground(rowFgCol);
2338                         else
2339                             dc.SetTextForeground(m_colDisPropFore);
2340                     }
2341                 }
2342                 else
2343                 {
2344                     if ( renderFlags & wxPGCellRenderer::DontUseCellBgCol )
2345                     {
2346                         dc.SetBrush(rowBgBrush);
2347                         dc.SetPen(rowBgCol);
2348                     }
2349
2350                     if ( renderFlags & wxPGCellRenderer::DontUseCellFgCol )
2351                     {
2352                         dc.SetTextForeground(rowFgCol);
2353                     }
2354                 }
2355
2356                 dc.SetClippingRegion(cellRect);
2357
2358                 cellRect.x += textXAdd;
2359                 cellRect.width -= textXAdd;
2360
2361                 // Foreground
2362                 if ( !cellEditor )
2363                 {
2364                     wxPGCellRenderer* renderer;
2365                     int cmnVal = p->GetCommonValue();
2366                     if ( cmnVal == -1 || ci != 1 )
2367                     {
2368                         renderer = p->GetCellRenderer(ci);
2369                         renderer->Render( dc, cellRect, this, p, ci, -1,
2370                                           cellRenderFlags );
2371                     }
2372                     else
2373                     {
2374                         renderer = GetCommonValue(cmnVal)->GetRenderer();
2375                         renderer->Render( dc, cellRect, this, p, ci, -1,
2376                                           cellRenderFlags );
2377                     }
2378                 }
2379
2380                 cellX += state->m_colWidths[ci];
2381                 if ( ci < (state->m_colWidths.size()-1) )
2382                     nextCellWidth = state->m_colWidths[ci+1];
2383                 cellRect.x = cellX;
2384                 dc.DestroyClippingRegion(); // Is this really necessary?
2385                 textXAdd = 0;
2386             }
2387         }
2388
2389         if ( fontChanged )
2390             dc.SetFont(normalFont);
2391
2392         y += rowHeight;
2393     }
2394
2395     // Refresh editor controls (seems not needed on msw)
2396     // NOTE: This code is mandatory for GTK!
2397 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
2398     if ( wasSelectedPainted )
2399     {
2400         if ( m_wndEditor )
2401             m_wndEditor->Refresh();
2402         if ( m_wndEditor2 )
2403             m_wndEditor2->Refresh();
2404     }
2405 #endif
2406
2407     return y;
2408 }
2409
2410 // -----------------------------------------------------------------------
2411
2412 wxRect wxPropertyGrid::GetPropertyRect( const wxPGProperty* p1, const wxPGProperty* p2 ) const
2413 {
2414     wxRect r;
2415
2416     if ( m_width < 10 || m_height < 10 ||
2417          !m_pState->m_properties->GetChildCount() ||
2418          p1 == NULL )
2419         return wxRect(0,0,0,0);
2420
2421     int vy = 0;
2422
2423     //
2424     // Return rect which encloses the given property range
2425
2426     int visTop = p1->GetY();
2427     int visBottom;
2428     if ( p2 )
2429         visBottom = p2->GetY() + m_lineHeight;
2430     else
2431         visBottom = m_height + visTop;
2432
2433     // If seleced property is inside the range, we'll extend the range to include
2434     // control's size.
2435     wxPGProperty* selected = GetSelection();
2436     if ( selected )
2437     {
2438         int selectedY = selected->GetY();
2439         if ( selectedY >= visTop && selectedY < visBottom )
2440         {
2441             wxWindow* editor = GetEditorControl();
2442             if ( editor )
2443             {
2444                 int visBottom2 = selectedY + editor->GetSize().y;
2445                 if ( visBottom2 > visBottom )
2446                     visBottom = visBottom2;
2447             }
2448         }
2449     }
2450
2451     return wxRect(0,visTop-vy,m_pState->m_width,visBottom-visTop);
2452 }
2453
2454 // -----------------------------------------------------------------------
2455
2456 void wxPropertyGrid::DrawItems( const wxPGProperty* p1, const wxPGProperty* p2 )
2457 {
2458     if ( m_frozen )
2459         return;
2460
2461     if ( m_pState->m_itemsAdded )
2462         PrepareAfterItemsAdded();
2463
2464     wxRect r = GetPropertyRect(p1, p2);
2465     if ( r.width > 0 )
2466     {
2467         RefreshRect(r);
2468     }
2469 }
2470
2471 // -----------------------------------------------------------------------
2472
2473 void wxPropertyGrid::RefreshProperty( wxPGProperty* p )
2474 {
2475     if ( m_pState->DoIsPropertySelected(p) )
2476     {
2477         // NB: We must copy the selection.
2478         wxArrayPGProperty selection = m_pState->m_selection;
2479         DoSetSelection(selection, wxPG_SEL_FORCE);
2480     }
2481
2482     DrawItemAndChildren(p);
2483 }
2484
2485 // -----------------------------------------------------------------------
2486
2487 void wxPropertyGrid::DrawItemAndValueRelated( wxPGProperty* p )
2488 {
2489     if ( m_frozen )
2490         return;
2491
2492     // Draw item, children, and parent too, if it is not category
2493     wxPGProperty* parent = p->GetParent();
2494
2495     while ( parent &&
2496             !parent->IsCategory() &&
2497             parent->GetParent() )
2498     {
2499          DrawItem(parent);
2500          parent = parent->GetParent();
2501     }
2502
2503     DrawItemAndChildren(p);
2504 }
2505
2506 void wxPropertyGrid::DrawItemAndChildren( wxPGProperty* p )
2507 {
2508     wxCHECK_RET( p, wxT("invalid property id") );
2509
2510     // Do not draw if in non-visible page
2511     if ( p->GetParentState() != m_pState )
2512         return;
2513
2514     // do not draw a single item if multiple pending
2515     if ( m_pState->m_itemsAdded || m_frozen )
2516         return;
2517
2518     // Update child control.
2519     wxPGProperty* selected = GetSelection();
2520     if ( selected && selected->GetParent() == p )
2521         RefreshEditor();
2522
2523     const wxPGProperty* lastDrawn = p->GetLastVisibleSubItem();
2524
2525     DrawItems(p, lastDrawn);
2526 }
2527
2528 // -----------------------------------------------------------------------
2529
2530 void wxPropertyGrid::Refresh( bool WXUNUSED(eraseBackground),
2531                               const wxRect *rect )
2532 {
2533     PrepareAfterItemsAdded();
2534
2535     wxWindow::Refresh(false, rect);
2536
2537 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
2538     // I think this really helps only GTK+1.2
2539     if ( m_wndEditor ) m_wndEditor->Refresh();
2540     if ( m_wndEditor2 ) m_wndEditor2->Refresh();
2541 #endif
2542 }
2543
2544 // -----------------------------------------------------------------------
2545 // wxPropertyGrid global operations
2546 // -----------------------------------------------------------------------
2547
2548 void wxPropertyGrid::Clear()
2549 {
2550     m_pState->DoClear();
2551
2552     m_propHover = NULL;
2553
2554     m_prevVY = 0;
2555
2556     RecalculateVirtualSize();
2557
2558     // Need to clear some area at the end
2559     if ( !m_frozen )
2560         RefreshRect(wxRect(0, 0, m_width, m_height));
2561 }
2562
2563 // -----------------------------------------------------------------------
2564
2565 bool wxPropertyGrid::EnableCategories( bool enable )
2566 {
2567     DoClearSelection();
2568
2569     if ( enable )
2570     {
2571         //
2572         // Enable categories
2573         //
2574
2575         m_windowStyle &= ~(wxPG_HIDE_CATEGORIES);
2576     }
2577     else
2578     {
2579         //
2580         // Disable categories
2581         //
2582         m_windowStyle |= wxPG_HIDE_CATEGORIES;
2583     }
2584
2585     if ( !m_pState->EnableCategories(enable) )
2586         return false;
2587
2588     if ( !m_frozen )
2589     {
2590         if ( m_windowStyle & wxPG_AUTO_SORT )
2591         {
2592             m_pState->m_itemsAdded = 1; // force
2593             PrepareAfterItemsAdded();
2594         }
2595     }
2596     else
2597         m_pState->m_itemsAdded = 1;
2598
2599     // No need for RecalculateVirtualSize() here - it is already called in
2600     // wxPropertyGridPageState method above.
2601
2602     Refresh();
2603
2604     return true;
2605 }
2606
2607 // -----------------------------------------------------------------------
2608
2609 void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
2610 {
2611     wxASSERT( pNewState );
2612     wxASSERT( pNewState->GetGrid() );
2613
2614     if ( pNewState == m_pState )
2615         return;
2616
2617     wxArrayPGProperty oldSelection = m_pState->m_selection;
2618
2619     // Call ClearSelection() instead of DoClearSelection()
2620     // so that selection clear events are not sent.
2621     ClearSelection();
2622
2623     m_pState->m_selection = oldSelection;
2624
2625     bool orig_mode = m_pState->IsInNonCatMode();
2626     bool new_state_mode = pNewState->IsInNonCatMode();
2627
2628     m_pState = pNewState;
2629
2630     // Validate width
2631     int pgWidth = GetClientSize().x;
2632     if ( HasVirtualWidth() )
2633     {
2634         int minWidth = pgWidth;
2635         if ( pNewState->m_width < minWidth )
2636         {
2637             pNewState->m_width = minWidth;
2638             pNewState->CheckColumnWidths();
2639         }
2640     }
2641     else
2642     {
2643         //
2644         // Just in case, fully re-center splitter
2645         //if ( HasFlag( wxPG_SPLITTER_AUTO_CENTER ) )
2646         //    pNewState->m_fSplitterX = -1.0;
2647
2648         pNewState->OnClientWidthChange(pgWidth,
2649                                        pgWidth - pNewState->m_width);
2650     }
2651
2652     m_propHover = NULL;
2653
2654     // If necessary, convert state to correct mode.
2655     if ( orig_mode != new_state_mode )
2656     {
2657         // This should refresh as well.
2658         EnableCategories( orig_mode?false:true );
2659     }
2660     else if ( !m_frozen )
2661     {
2662         // Refresh, if not frozen.
2663         m_pState->PrepareAfterItemsAdded();
2664
2665         // Reselect (Use SetSelection() instead of Do-variant so that
2666         // events won't be sent).
2667         SetSelection(m_pState->m_selection);
2668
2669         RecalculateVirtualSize(0);
2670         Refresh();
2671     }
2672     else
2673         m_pState->m_itemsAdded = 1;
2674 }
2675
2676 // -----------------------------------------------------------------------
2677
2678 // Call to SetSplitterPosition will always disable splitter auto-centering
2679 // if parent window is shown.
2680 void wxPropertyGrid::DoSetSplitterPosition( int newxpos,
2681                                             int splitterIndex,
2682                                             int flags )
2683 {
2684     if ( ( newxpos < wxPG_DRAG_MARGIN ) )
2685         return;
2686
2687     wxPropertyGridPageState* state = m_pState;
2688
2689     if ( flags & wxPG_SPLITTER_FROM_EVENT )
2690         state->m_dontCenterSplitter = true;
2691
2692     state->DoSetSplitterPosition(newxpos, splitterIndex, flags);
2693
2694     if ( flags & wxPG_SPLITTER_REFRESH )
2695     {
2696         if ( GetSelection() )
2697             CorrectEditorWidgetSizeX();
2698
2699         Refresh();
2700     }
2701
2702     return;
2703 }
2704
2705 // -----------------------------------------------------------------------
2706
2707 void wxPropertyGrid::CenterSplitter( bool enableAutoCentering )
2708 {
2709     SetSplitterPosition( m_width/2 );
2710     if ( enableAutoCentering && HasFlag(wxPG_SPLITTER_AUTO_CENTER) )
2711         m_pState->m_dontCenterSplitter = false;
2712 }
2713
2714 // -----------------------------------------------------------------------
2715 // wxPropertyGrid item iteration (GetNextProperty etc.) methods
2716 // -----------------------------------------------------------------------
2717
2718 // Returns nearest paint visible property (such that will be painted unless
2719 // window is scrolled or resized). If given property is paint visible, then
2720 // it itself will be returned
2721 wxPGProperty* wxPropertyGrid::GetNearestPaintVisible( wxPGProperty* p ) const
2722 {
2723     int vx,vy1;// Top left corner of client
2724     GetViewStart(&vx,&vy1);
2725     vy1 *= wxPG_PIXELS_PER_UNIT;
2726
2727     int vy2 = vy1 + m_height;
2728     int propY = p->GetY2(m_lineHeight);
2729
2730     if ( (propY + m_lineHeight) < vy1 )
2731     {
2732     // Too high
2733         return DoGetItemAtY( vy1 );
2734     }
2735     else if ( propY > vy2 )
2736     {
2737     // Too low
2738         return DoGetItemAtY( vy2 );
2739     }
2740
2741     // Itself paint visible
2742     return p;
2743
2744 }
2745
2746 // -----------------------------------------------------------------------
2747 // Methods related to change in value, value modification and sending events
2748 // -----------------------------------------------------------------------
2749
2750 // commits any changes in editor of selected property
2751 // return true if validation did not fail
2752 // flags are same as with DoSelectProperty
2753 bool wxPropertyGrid::CommitChangesFromEditor( wxUint32 flags )
2754 {
2755     // Committing already?
2756     if ( m_inCommitChangesFromEditor )
2757         return true;
2758
2759     // Don't do this if already processing editor event. It might
2760     // induce recursive dialogs and crap like that.
2761     if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )
2762     {
2763         if ( m_inDoPropertyChanged )
2764             return true;
2765
2766         return false;
2767     }
2768
2769     wxPGProperty* selected = GetSelection();
2770
2771     if ( m_wndEditor &&
2772          IsEditorsValueModified() &&
2773          (m_iFlags & wxPG_FL_INITIALIZED) &&
2774          selected )
2775     {
2776         m_inCommitChangesFromEditor = 1;
2777
2778         wxVariant variant(selected->GetValueRef());
2779         bool valueIsPending = false;
2780
2781         // JACS - necessary to avoid new focus being found spuriously within OnIdle
2782         // due to another window getting focus
2783         wxWindow* oldFocus = m_curFocused;
2784
2785         bool validationFailure = false;
2786         bool forceSuccess = (flags & (wxPG_SEL_NOVALIDATE|wxPG_SEL_FORCE)) ? true : false;
2787
2788         m_chgInfo_changedProperty = NULL;
2789
2790         // If truly modified, schedule value as pending.
2791         if ( selected->GetEditorClass()->
2792                 GetValueFromControl( variant,
2793                                      selected,
2794                                      GetEditorControl() ) )
2795         {
2796             if ( DoEditorValidate() &&
2797                  PerformValidation(selected, variant) )
2798             {
2799                 valueIsPending = true;
2800             }
2801             else
2802             {
2803                 validationFailure = true;
2804             }
2805         }
2806         else
2807         {
2808             EditorsValueWasNotModified();
2809         }
2810
2811         bool res = true;
2812
2813         m_inCommitChangesFromEditor = 0;
2814
2815         if ( validationFailure && !forceSuccess )
2816         {
2817             if (oldFocus)
2818             {
2819                 oldFocus->SetFocus();
2820                 m_curFocused = oldFocus;
2821             }
2822
2823             res = OnValidationFailure(selected, variant);
2824
2825             // Now prevent further validation failure messages
2826             if ( res )
2827             {
2828                 EditorsValueWasNotModified();
2829                 OnValidationFailureReset(selected);
2830             }
2831         }
2832         else if ( valueIsPending )
2833         {
2834             DoPropertyChanged( selected, flags );
2835             EditorsValueWasNotModified();
2836         }
2837
2838         return res;
2839     }
2840
2841     return true;
2842 }
2843
2844 // -----------------------------------------------------------------------
2845
2846 bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue,
2847                                         int flags )
2848 {
2849     //
2850     // Runs all validation functionality.
2851     // Returns true if value passes all tests.
2852     //
2853
2854     m_validationInfo.m_failureBehavior = m_permanentValidationFailureBehavior;
2855
2856     //
2857     // Variant list a special value that cannot be validated
2858     // by normal means.
2859     if ( pendingValue.GetType() != wxPG_VARIANT_TYPE_LIST )
2860     {
2861         if ( !p->ValidateValue(pendingValue, m_validationInfo) )
2862             return false;
2863     }
2864
2865     //
2866     // Adapt list to child values, if necessary
2867     wxVariant listValue = pendingValue;
2868     wxVariant* pPendingValue = &pendingValue;
2869     wxVariant* pList = NULL;
2870
2871     // If parent has wxPG_PROP_AGGREGATE flag, or uses composite
2872     // string value, then we need treat as it was changed instead
2873     // (or, in addition, as is the case with composite string parent).
2874     // This includes creating list variant for child values.
2875
2876     wxPGProperty* pwc = p->GetParent();
2877     wxPGProperty* changedProperty = p;
2878     wxPGProperty* baseChangedProperty = changedProperty;
2879     wxVariant bcpPendingList;
2880
2881     listValue = pendingValue;
2882     listValue.SetName(p->GetBaseName());
2883
2884     while ( pwc &&
2885             (pwc->HasFlag(wxPG_PROP_AGGREGATE) || pwc->HasFlag(wxPG_PROP_COMPOSED_VALUE)) )
2886     {
2887         wxVariantList tempList;
2888         wxVariant lv(tempList, pwc->GetBaseName());
2889         lv.Append(listValue);
2890         listValue = lv;
2891         pPendingValue = &listValue;
2892
2893         if ( pwc->HasFlag(wxPG_PROP_AGGREGATE) )
2894         {
2895             baseChangedProperty = pwc;
2896             bcpPendingList = lv;
2897         }
2898
2899         changedProperty = pwc;
2900         pwc = pwc->GetParent();
2901     }
2902
2903     wxVariant value;
2904     wxPGProperty* evtChangingProperty = changedProperty;
2905
2906     if ( pPendingValue->GetType() != wxPG_VARIANT_TYPE_LIST )
2907     {
2908         value = *pPendingValue;
2909     }
2910     else
2911     {
2912         // Convert list to child values
2913         pList = pPendingValue;
2914         changedProperty->AdaptListToValue( *pPendingValue, &value );
2915     }
2916
2917     wxVariant evtChangingValue = value;
2918
2919     if ( flags & SendEvtChanging )
2920     {
2921         // FIXME: After proper ValueToString()s added, remove
2922         // this. It is just a temporary fix, as evt_changing
2923         // will simply not work for wxPG_PROP_COMPOSED_VALUE
2924         // (unless it is selected, and textctrl editor is open).
2925         if ( changedProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
2926         {
2927             evtChangingProperty = baseChangedProperty;
2928             if ( evtChangingProperty != p )
2929             {
2930                 evtChangingProperty->AdaptListToValue( bcpPendingList, &evtChangingValue );
2931             }
2932             else
2933             {
2934                 evtChangingValue = pendingValue;
2935             }
2936         }
2937
2938         if ( evtChangingProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
2939         {
2940             if ( changedProperty == GetSelection() )
2941             {
2942                 wxWindow* editor = GetEditorControl();
2943                 wxASSERT( editor->IsKindOf(CLASSINFO(wxTextCtrl)) );
2944                 evtChangingValue = wxStaticCast(editor, wxTextCtrl)->GetValue();
2945             }
2946             else
2947             {
2948                 wxLogDebug(wxT("WARNING: wxEVT_PG_CHANGING is about to happen with old value."));
2949             }
2950         }
2951     }
2952
2953     wxASSERT( m_chgInfo_changedProperty == NULL );
2954     m_chgInfo_changedProperty = changedProperty;
2955     m_chgInfo_baseChangedProperty = baseChangedProperty;
2956     m_chgInfo_pendingValue = value;
2957
2958     if ( pList )
2959         m_chgInfo_valueList = *pList;
2960     else
2961         m_chgInfo_valueList.MakeNull();
2962
2963     // If changedProperty is not property which value was edited,
2964     // then call wxPGProperty::ValidateValue() for that as well.
2965     if ( p != changedProperty && value.GetType() != wxPG_VARIANT_TYPE_LIST )
2966     {
2967         if ( !changedProperty->ValidateValue(value, m_validationInfo) )
2968             return false;
2969     }
2970
2971     if ( flags & SendEvtChanging )
2972     {
2973         // SendEvent returns true if event was vetoed
2974         if ( SendEvent( wxEVT_PG_CHANGING, evtChangingProperty,
2975                         &evtChangingValue ) )
2976             return false;
2977     }
2978
2979     if ( flags & IsStandaloneValidation )
2980     {
2981         // If called in 'generic' context, we need to reset
2982         // m_chgInfo_changedProperty and write back translated value.
2983         m_chgInfo_changedProperty = NULL;
2984         pendingValue = value;
2985     }
2986
2987     return true;
2988 }
2989
2990 // -----------------------------------------------------------------------
2991
2992 void wxPropertyGrid::DoShowPropertyError( wxPGProperty* WXUNUSED(property), const wxString& msg )
2993 {
2994     if ( !msg.length() )
2995         return;
2996
2997 #if wxUSE_STATUSBAR
2998     if ( !wxPGGlobalVars->m_offline )
2999     {
3000         wxWindow* topWnd = ::wxGetTopLevelParent(this);
3001         if ( topWnd )
3002         {
3003             wxFrame* pFrame = wxDynamicCast(topWnd, wxFrame);
3004             if ( pFrame )
3005             {
3006                 wxStatusBar* pStatusBar = pFrame->GetStatusBar();
3007                 if ( pStatusBar )
3008                 {
3009                     pStatusBar->SetStatusText(msg);
3010                     return;
3011                 }
3012             }
3013         }
3014     }
3015 #endif
3016
3017     ::wxMessageBox(msg, wxT("Property Error"));
3018 }
3019
3020 // -----------------------------------------------------------------------
3021
3022 bool wxPropertyGrid::OnValidationFailure( wxPGProperty* property,
3023                                           wxVariant& invalidValue )
3024 {
3025     wxWindow* editor = GetEditorControl();
3026
3027     // First call property's handler
3028     property->OnValidationFailure(invalidValue);
3029
3030     bool res = DoOnValidationFailure(property, invalidValue);
3031
3032     //
3033     // For non-wxTextCtrl editors, we do need to revert the value
3034     if ( !editor->IsKindOf(CLASSINFO(wxTextCtrl)) &&
3035          property == GetSelection() )
3036     {
3037         property->GetEditorClass()->UpdateControl(property, editor);
3038     }
3039
3040     property->SetFlag(wxPG_PROP_INVALID_VALUE);
3041
3042     return res;
3043 }
3044
3045 bool wxPropertyGrid::DoOnValidationFailure( wxPGProperty* property, wxVariant& WXUNUSED(invalidValue) )
3046 {
3047     int vfb = m_validationInfo.m_failureBehavior;
3048
3049     if ( vfb & wxPG_VFB_BEEP )
3050         ::wxBell();
3051
3052     if ( (vfb & wxPG_VFB_MARK_CELL) &&
3053          !property->HasFlag(wxPG_PROP_INVALID_VALUE) )
3054     {
3055         unsigned int colCount = m_pState->GetColumnCount();
3056
3057         // We need backup marked property's cells
3058         m_propCellsBackup = property->m_cells;
3059
3060         wxColour vfbFg = *wxWHITE;
3061         wxColour vfbBg = *wxRED;
3062
3063         property->EnsureCells(colCount);
3064
3065         for ( unsigned int i=0; i<colCount; i++ )
3066         {
3067             wxPGCell& cell = property->m_cells[i];
3068             cell.SetFgCol(vfbFg);
3069             cell.SetBgCol(vfbBg);
3070         }
3071
3072         DrawItemAndChildren(property);
3073
3074         if ( property == GetSelection() )
3075         {
3076             SetInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL);
3077
3078             wxWindow* editor = GetEditorControl();
3079             if ( editor )
3080             {
3081                 editor->SetForegroundColour(vfbFg);
3082                 editor->SetBackgroundColour(vfbBg);
3083             }
3084         }
3085     }
3086
3087     if ( vfb & wxPG_VFB_SHOW_MESSAGE )
3088     {
3089         wxString msg = m_validationInfo.m_failureMessage;
3090
3091         if ( !msg.length() )
3092             msg = wxT("You have entered invalid value. Press ESC to cancel editing.");
3093
3094         DoShowPropertyError(property, msg);
3095     }
3096
3097     return (vfb & wxPG_VFB_STAY_IN_PROPERTY) ? false : true;
3098 }
3099
3100 // -----------------------------------------------------------------------
3101
3102 void wxPropertyGrid::DoOnValidationFailureReset( wxPGProperty* property )
3103 {
3104     int vfb = m_validationInfo.m_failureBehavior;
3105
3106     if ( vfb & wxPG_VFB_MARK_CELL )
3107     {
3108         // Revert cells
3109         property->m_cells = m_propCellsBackup;
3110
3111         ClearInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL);
3112
3113         if ( property == GetSelection() && GetEditorControl() )
3114         {
3115             // Calling this will recreate the control, thus resetting its colour
3116             RefreshProperty(property);
3117         }
3118         else
3119         {
3120             DrawItemAndChildren(property);
3121         }
3122     }
3123 }
3124
3125 // -----------------------------------------------------------------------
3126
3127 // flags are same as with DoSelectProperty
3128 bool wxPropertyGrid::DoPropertyChanged( wxPGProperty* p, unsigned int selFlags )
3129 {
3130     if ( m_inDoPropertyChanged )
3131         return true;
3132
3133     wxWindow* editor = GetEditorControl();
3134     wxPGProperty* selected = GetSelection();
3135
3136     m_pState->m_anyModified = 1;
3137
3138     m_inDoPropertyChanged = 1;
3139
3140     // Maybe need to update control
3141     wxASSERT( m_chgInfo_changedProperty != NULL );
3142
3143     // These values were calculated in PerformValidation()
3144     wxPGProperty* changedProperty = m_chgInfo_changedProperty;
3145     wxVariant value = m_chgInfo_pendingValue;
3146
3147     wxPGProperty* topPaintedProperty = changedProperty;
3148
3149     while ( !topPaintedProperty->IsCategory() &&
3150             !topPaintedProperty->IsRoot() )
3151     {
3152         topPaintedProperty = topPaintedProperty->GetParent();
3153     }
3154
3155     changedProperty->SetValue(value, &m_chgInfo_valueList, wxPG_SETVAL_BY_USER);
3156
3157     // Set as Modified (not if dragging just began)
3158     if ( !(p->m_flags & wxPG_PROP_MODIFIED) )
3159     {
3160         p->m_flags |= wxPG_PROP_MODIFIED;
3161         if ( p == selected && (m_windowStyle & wxPG_BOLD_MODIFIED) )
3162         {
3163             if ( editor )
3164                 SetCurControlBoldFont();
3165         }
3166     }
3167
3168     wxPGProperty* pwc;
3169
3170     // Propagate updates to parent(s)
3171     pwc = p;
3172     wxPGProperty* prevPwc = NULL;
3173
3174     while ( prevPwc != topPaintedProperty )
3175     {
3176         pwc->m_flags |= wxPG_PROP_MODIFIED;
3177
3178         if ( pwc == selected && (m_windowStyle & wxPG_BOLD_MODIFIED) )
3179         {
3180             if ( editor )
3181                 SetCurControlBoldFont();
3182         }
3183
3184         prevPwc = pwc;
3185         pwc = pwc->GetParent();
3186     }
3187
3188     // Draw the actual property
3189     DrawItemAndChildren( topPaintedProperty );
3190
3191     //
3192     // If value was set by wxPGProperty::OnEvent, then update the editor
3193     // control.
3194     if ( selFlags & wxPG_SEL_DIALOGVAL )
3195     {
3196         RefreshEditor();
3197     }
3198     else
3199     {
3200 #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
3201         if ( m_wndEditor ) m_wndEditor->Refresh();
3202         if ( m_wndEditor2 ) m_wndEditor2->Refresh();
3203 #endif
3204     }
3205
3206     // Sanity check
3207     wxASSERT( !changedProperty->GetParent()->HasFlag(wxPG_PROP_AGGREGATE) );
3208
3209     // If top parent has composite string value, then send to child parents,
3210     // starting from baseChangedProperty.
3211     if ( changedProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
3212     {
3213         pwc = m_chgInfo_baseChangedProperty;
3214
3215         while ( pwc != changedProperty )
3216         {
3217             SendEvent( wxEVT_PG_CHANGED, pwc, NULL );
3218             pwc = pwc->GetParent();
3219         }
3220     }
3221
3222     SendEvent( wxEVT_PG_CHANGED, changedProperty, NULL );
3223
3224     m_inDoPropertyChanged = 0;
3225
3226     return true;
3227 }
3228
3229 // -----------------------------------------------------------------------
3230
3231 bool wxPropertyGrid::ChangePropertyValue( wxPGPropArg id, wxVariant newValue )
3232 {
3233     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
3234
3235     m_chgInfo_changedProperty = NULL;
3236
3237     if ( PerformValidation(p, newValue) )
3238     {
3239         DoPropertyChanged(p);
3240         return true;
3241     }
3242     else
3243     {
3244         OnValidationFailure(p, newValue);
3245     }
3246
3247     return false;
3248 }
3249
3250 // -----------------------------------------------------------------------
3251
3252 wxVariant wxPropertyGrid::GetUncommittedPropertyValue()
3253 {
3254     wxPGProperty* prop = GetSelectedProperty();
3255
3256     if ( !prop )
3257         return wxNullVariant;
3258
3259     wxTextCtrl* tc = GetEditorTextCtrl();
3260     wxVariant value = prop->GetValue();
3261
3262     if ( !tc || !IsEditorsValueModified() )
3263         return value;
3264
3265     if ( !prop->StringToValue(value, tc->GetValue()) )
3266         return value;
3267
3268     if ( !PerformValidation(prop, value, IsStandaloneValidation) )
3269         return prop->GetValue();
3270
3271     return value;
3272 }
3273
3274 // -----------------------------------------------------------------------
3275
3276 // Runs wxValidator for the selected property
3277 bool wxPropertyGrid::DoEditorValidate()
3278 {
3279     return true;
3280 }
3281
3282 // -----------------------------------------------------------------------
3283
3284 void wxPropertyGrid::HandleCustomEditorEvent( wxEvent &event )
3285 {
3286     // It is possible that this handler receives event even before
3287     // the control has been properly initialized. Let's skip the
3288     // event handling in that case.
3289     if ( !m_pState )
3290         return;
3291
3292     wxPGProperty* selected = GetSelection();
3293
3294     // Somehow, event is handled after property has been deselected.
3295     // Possibly, but very rare.
3296     if ( !selected ||
3297           selected->HasFlag(wxPG_PROP_BEING_DELETED) ||
3298           // Also don't handle editor event if wxEVT_PG_CHANGED or
3299           // similar is currently doing something (showing a
3300           // message box, for instance).
3301           m_processedEvent )
3302         return;
3303
3304     if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )
3305         return;
3306
3307     wxVariant pendingValue(selected->GetValueRef());
3308     wxWindow* wnd = GetEditorControl();
3309     wxWindow* editorWnd = wxDynamicCast(event.GetEventObject(), wxWindow);
3310     int selFlags = 0;
3311     bool wasUnspecified = selected->IsValueUnspecified();
3312     int usesAutoUnspecified = selected->UsesAutoUnspecified();
3313     bool valueIsPending = false;
3314
3315     m_chgInfo_changedProperty = NULL;
3316
3317     m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED|wxPG_FL_VALUE_CHANGE_IN_EVENT);
3318
3319     //
3320     // Filter out excess wxTextCtrl modified events
3321     if ( event.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED &&
3322          wnd &&
3323          wnd->IsKindOf(CLASSINFO(wxTextCtrl)) )
3324     {
3325         wxTextCtrl* tc = (wxTextCtrl*) wnd;
3326
3327         wxString newTcValue = tc->GetValue();
3328         if ( m_prevTcValue == newTcValue )
3329             return;
3330
3331         m_prevTcValue = newTcValue;
3332     }
3333
3334     SetInternalFlag(wxPG_FL_IN_HANDLECUSTOMEDITOREVENT);
3335
3336     bool validationFailure = false;
3337     bool buttonWasHandled = false;
3338
3339     //
3340     // Try common button handling
3341     if ( m_wndEditor2 && event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
3342     {
3343         wxPGEditorDialogAdapter* adapter = selected->GetEditorDialog();
3344
3345         if ( adapter )
3346         {
3347             buttonWasHandled = true;
3348             // Store as res2, as previously (and still currently alternatively)
3349             // dialogs can be shown by handling wxEVT_COMMAND_BUTTON_CLICKED
3350             // in wxPGProperty::OnEvent().
3351             adapter->ShowDialog( this, selected );
3352             delete adapter;
3353         }
3354     }
3355
3356     if ( !buttonWasHandled )
3357     {
3358         if ( wnd || m_wndEditor2 )
3359         {
3360             // First call editor class' event handler.
3361             const wxPGEditor* editor = selected->GetEditorClass();
3362
3363             if ( editor->OnEvent( this, selected, editorWnd, event ) )
3364             {
3365                 // If changes, validate them
3366                 if ( DoEditorValidate() )
3367                 {
3368                     if ( editor->GetValueFromControl( pendingValue,
3369                                                       selected,
3370                                                       wnd ) )
3371                         valueIsPending = true;
3372                 }
3373                 else
3374                 {
3375                     validationFailure = true;
3376                 }
3377             }
3378         }
3379
3380         // Then the property's custom handler (must be always called, unless
3381         // validation failed).
3382         if ( !validationFailure )
3383             buttonWasHandled = selected->OnEvent( this, editorWnd, event );
3384     }
3385
3386     // SetValueInEvent(), as called in one of the functions referred above
3387     // overrides editor's value.
3388     if ( m_iFlags & wxPG_FL_VALUE_CHANGE_IN_EVENT )
3389     {
3390         valueIsPending = true;
3391         pendingValue = m_changeInEventValue;
3392         selFlags |= wxPG_SEL_DIALOGVAL;
3393     }
3394
3395     if ( !validationFailure && valueIsPending )
3396         if ( !PerformValidation(selected, pendingValue) )
3397             validationFailure = true;
3398
3399     if ( validationFailure)
3400     {
3401         OnValidationFailure(selected, pendingValue);
3402     }
3403     else if ( valueIsPending )
3404     {
3405         selFlags |= ( !wasUnspecified && selected->IsValueUnspecified() && usesAutoUnspecified ) ? wxPG_SEL_SETUNSPEC : 0;
3406
3407         DoPropertyChanged(selected, selFlags);
3408         EditorsValueWasNotModified();
3409
3410         // Regardless of editor type, unfocus editor on
3411         // text-editing related enter press.
3412         if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
3413         {
3414             SetFocusOnCanvas();
3415         }
3416     }
3417     else
3418     {
3419         // No value after all
3420
3421         // Regardless of editor type, unfocus editor on
3422         // text-editing related enter press.
3423         if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
3424         {
3425             SetFocusOnCanvas();
3426         }
3427
3428         // Let unhandled button click events go to the parent
3429         if ( !buttonWasHandled && event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
3430         {
3431             wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED,GetId());
3432             GetEventHandler()->AddPendingEvent(evt);
3433         }
3434     }
3435
3436     ClearInternalFlag(wxPG_FL_IN_HANDLECUSTOMEDITOREVENT);
3437 }
3438
3439 // -----------------------------------------------------------------------
3440 // wxPropertyGrid editor control helper methods
3441 // -----------------------------------------------------------------------
3442
3443 wxRect wxPropertyGrid::GetEditorWidgetRect( wxPGProperty* p, int column ) const
3444 {
3445     int itemy = p->GetY2(m_lineHeight);
3446     int splitterX = m_pState->DoGetSplitterPosition(column-1);
3447     int colEnd = splitterX + m_pState->m_colWidths[column];
3448     int imageOffset = 0;
3449
3450     int vx, vy;  // Top left corner of client
3451     GetViewStart(&vx, &vy);
3452     vy *= wxPG_PIXELS_PER_UNIT;
3453
3454     // TODO: If custom image detection changes from current, change this.
3455     if ( m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE )
3456     {
3457         //m_iFlags |= wxPG_FL_CUR_USES_CUSTOM_IMAGE;
3458         int iw = p->OnMeasureImage().x;
3459         if ( iw < 1 )
3460             iw = wxPG_CUSTOM_IMAGE_WIDTH;
3461         imageOffset = p->GetImageOffset(iw);
3462     }
3463
3464     return wxRect
3465       (
3466         splitterX+imageOffset+wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1,
3467         itemy-vy,
3468         colEnd-splitterX-wxPG_XBEFOREWIDGET-wxPG_CONTROL_MARGIN-imageOffset-1,
3469         m_lineHeight-1
3470       );
3471 }
3472
3473 // -----------------------------------------------------------------------
3474
3475 wxRect wxPropertyGrid::GetImageRect( wxPGProperty* p, int item ) const
3476 {
3477     wxSize sz = GetImageSize(p, item);
3478     return wxRect(wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
3479                   wxPG_CUSTOM_IMAGE_SPACINGY,
3480                   sz.x,
3481                   sz.y);
3482 }
3483
3484 // return size of custom paint image
3485 wxSize wxPropertyGrid::GetImageSize( wxPGProperty* p, int item ) const
3486 {
3487     // If called with NULL property, then return default image
3488     // size for properties that use image.
3489     if ( !p )
3490         return wxSize(wxPG_CUSTOM_IMAGE_WIDTH,wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight));
3491
3492     wxSize cis = p->OnMeasureImage(item);
3493
3494     int choiceCount = p->m_choices.GetCount();
3495     int comVals = p->GetDisplayedCommonValueCount();
3496     if ( item >= choiceCount && comVals > 0 )
3497     {
3498         unsigned int cvi = item-choiceCount;
3499         cis = GetCommonValue(cvi)->GetRenderer()->GetImageSize(NULL, 1, cvi);
3500     }
3501     else if ( item >= 0 && choiceCount == 0 )
3502         return wxSize(0, 0);
3503
3504     if ( cis.x < 0 )
3505     {
3506         if ( cis.x <= -1 )
3507             cis.x = wxPG_CUSTOM_IMAGE_WIDTH;
3508     }
3509     if ( cis.y <= 0 )
3510     {
3511         if ( cis.y >= -1 )
3512             cis.y = wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight);
3513         else
3514             cis.y = -cis.y;
3515     }
3516     return cis;
3517 }
3518
3519 // -----------------------------------------------------------------------
3520
3521 // takes scrolling into account
3522 void wxPropertyGrid::ImprovedClientToScreen( int* px, int* py )
3523 {
3524     int vx, vy;
3525     GetViewStart(&vx,&vy);
3526     vy*=wxPG_PIXELS_PER_UNIT;
3527     vx*=wxPG_PIXELS_PER_UNIT;
3528     *px -= vx;
3529     *py -= vy;
3530     ClientToScreen( px, py );
3531 }
3532
3533 // -----------------------------------------------------------------------
3534
3535 wxPropertyGridHitTestResult wxPropertyGrid::HitTest( const wxPoint& pt ) const
3536 {
3537     wxPoint pt2;
3538     GetViewStart(&pt2.x,&pt2.y);
3539     pt2.x *= wxPG_PIXELS_PER_UNIT;
3540     pt2.y *= wxPG_PIXELS_PER_UNIT;
3541     pt2.x += pt.x;
3542     pt2.y += pt.y;
3543
3544     return m_pState->HitTest(pt2);
3545 }
3546
3547 // -----------------------------------------------------------------------
3548
3549 // custom set cursor
3550 void wxPropertyGrid::CustomSetCursor( int type, bool override )
3551 {
3552     if ( type == m_curcursor && !override ) return;
3553
3554     wxCursor* cursor = &wxPG_DEFAULT_CURSOR;
3555
3556     if ( type == wxCURSOR_SIZEWE )
3557         cursor = m_cursorSizeWE;
3558
3559     SetCursor( *cursor );
3560
3561     m_curcursor = type;
3562 }
3563
3564 // -----------------------------------------------------------------------
3565 // wxPropertyGrid property selection, editor creation
3566 // -----------------------------------------------------------------------
3567
3568 //
3569 // This class forwards events from property editor controls to wxPropertyGrid.
3570 class wxPropertyGridEditorEventForwarder : public wxEvtHandler
3571 {
3572 public:
3573     wxPropertyGridEditorEventForwarder( wxPropertyGrid* propGrid )
3574         : wxEvtHandler(), m_propGrid(propGrid)
3575     {
3576     }
3577
3578     virtual ~wxPropertyGridEditorEventForwarder()
3579     {
3580     }
3581
3582 private:
3583     bool ProcessEvent( wxEvent& event )
3584     {
3585         // Always skip
3586         event.Skip();
3587
3588         m_propGrid->HandleCustomEditorEvent(event);
3589
3590         return wxEvtHandler::ProcessEvent(event);
3591     }
3592
3593     wxPropertyGrid*         m_propGrid;
3594 };
3595
3596 // Setups event handling for child control
3597 void wxPropertyGrid::SetupChildEventHandling( wxWindow* argWnd )
3598 {
3599     wxWindowID id = argWnd->GetId();
3600
3601     if ( argWnd == m_wndEditor )
3602     {
3603         argWnd->Connect(id, wxEVT_MOTION,
3604             wxMouseEventHandler(wxPropertyGrid::OnMouseMoveChild),
3605             NULL, this);
3606         argWnd->Connect(id, wxEVT_LEFT_UP,
3607             wxMouseEventHandler(wxPropertyGrid::OnMouseUpChild),
3608             NULL, this);
3609         argWnd->Connect(id, wxEVT_LEFT_DOWN,
3610             wxMouseEventHandler(wxPropertyGrid::OnMouseClickChild),
3611             NULL, this);
3612         argWnd->Connect(id, wxEVT_RIGHT_UP,
3613             wxMouseEventHandler(wxPropertyGrid::OnMouseRightClickChild),
3614             NULL, this);
3615         argWnd->Connect(id, wxEVT_ENTER_WINDOW,
3616             wxMouseEventHandler(wxPropertyGrid::OnMouseEntry),
3617             NULL, this);
3618         argWnd->Connect(id, wxEVT_LEAVE_WINDOW,
3619             wxMouseEventHandler(wxPropertyGrid::OnMouseEntry),
3620             NULL, this);
3621     }
3622
3623     wxPropertyGridEditorEventForwarder* forwarder;
3624     forwarder = new wxPropertyGridEditorEventForwarder(this);
3625     argWnd->PushEventHandler(forwarder);
3626
3627     argWnd->Connect(id, wxEVT_KEY_DOWN,
3628         wxCharEventHandler(wxPropertyGrid::OnChildKeyDown),
3629         NULL, this);
3630 }
3631
3632 void wxPropertyGrid::DestroyEditorWnd( wxWindow* wnd )
3633 {
3634     if ( !wnd )
3635         return;
3636
3637     wnd->Hide();
3638
3639     // Do not free editors immediately (for sake of processing events)
3640     wxPendingDelete.Append(wnd);
3641 }
3642
3643 void wxPropertyGrid::FreeEditors()
3644 {
3645     //
3646     // Return focus back to canvas from children (this is required at least for
3647     // GTK+, which, unlike Windows, clears focus when control is destroyed
3648     // instead of moving it to closest parent).
3649     wxWindow* focus = wxWindow::FindFocus();
3650     if ( focus )
3651     {
3652         wxWindow* parent = focus->GetParent();
3653         while ( parent )
3654         {
3655             if ( parent == this )
3656             {
3657                 SetFocusOnCanvas();
3658                 break;
3659             }
3660             parent = parent->GetParent();
3661         }
3662     }
3663
3664     // Do not free editors immediately if processing events
3665     if ( m_wndEditor2 )
3666     {
3667         wxEvtHandler* handler = m_wndEditor2->PopEventHandler(false);
3668         m_wndEditor2->Hide();
3669         wxPendingDelete.Append( handler );
3670         DestroyEditorWnd(m_wndEditor2);
3671         m_wndEditor2 = NULL;
3672     }
3673
3674     if ( m_wndEditor )
3675     {
3676         wxEvtHandler* handler = m_wndEditor->PopEventHandler(false);
3677         m_wndEditor->Hide();
3678         wxPendingDelete.Append( handler );
3679         DestroyEditorWnd(m_wndEditor);
3680         m_wndEditor = NULL;
3681     }
3682 }
3683
3684 // Call with NULL to de-select property
3685 bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
3686 {
3687     /*
3688     if (p)
3689     {
3690         wxLogDebug(wxT("SelectProperty( %s (%s[%i]) )"),p->m_label.c_str(),
3691             p->m_parent->m_label.c_str(),p->GetIndexInParent());
3692     }
3693     else
3694     {
3695         wxLogDebug(wxT("SelectProperty( NULL, -1 )"));
3696     }
3697     */
3698
3699     if ( m_inDoSelectProperty )
3700         return true;
3701
3702     m_inDoSelectProperty = 1;
3703
3704     if ( !m_pState )
3705     {
3706         m_inDoSelectProperty = 0;
3707         return false;
3708     }
3709
3710     wxArrayPGProperty prevSelection = m_pState->m_selection;
3711     wxPGProperty* prevFirstSel;
3712
3713     if ( prevSelection.size() > 0 )
3714         prevFirstSel = prevSelection[0];
3715     else
3716         prevFirstSel = NULL;
3717
3718     if ( prevFirstSel && prevFirstSel->HasFlag(wxPG_PROP_BEING_DELETED) )
3719         prevFirstSel = NULL;
3720
3721     // Always send event, as this is indirect call
3722     DoEndLabelEdit(true, wxPG_SEL_NOVALIDATE);
3723
3724 /*
3725     if ( prevFirstSel )
3726         wxPrintf( "Selected %s\n", prevFirstSel->GetClassInfo()->GetClassName() );
3727     else
3728         wxPrintf( "None selected\n" );
3729
3730     if (p)
3731         wxPrintf( "P =  %s\n", p->GetClassInfo()->GetClassName() );
3732     else
3733         wxPrintf( "P = NULL\n" );
3734 */
3735
3736     // If we are frozen, then just set the values.
3737     if ( m_frozen )
3738     {
3739         m_iFlags &= ~(wxPG_FL_ABNORMAL_EDITOR);
3740         m_editorFocused = 0;
3741         m_pState->DoSetSelection(p);
3742
3743         // If frozen, always free controls. But don't worry, as Thaw will
3744         // recall SelectProperty to recreate them.
3745         FreeEditors();
3746
3747         // Prevent any further selection measures in this call
3748         p = NULL;
3749     }
3750     else
3751     {
3752         // Is it the same?
3753         if ( prevFirstSel == p &&
3754              prevSelection.size() <= 1 &&
3755              !(flags & wxPG_SEL_FORCE) )
3756         {
3757             // Only set focus if not deselecting
3758             if ( p )
3759             {
3760                 if ( flags & wxPG_SEL_FOCUS )
3761                 {
3762                     if ( m_wndEditor )
3763                     {
3764                         m_wndEditor->SetFocus();
3765                         m_editorFocused = 1;
3766                     }
3767                 }
3768                 else
3769                 {
3770                     SetFocusOnCanvas();
3771                 }
3772             }
3773
3774             m_inDoSelectProperty = 0;
3775             return true;
3776         }
3777
3778         //
3779         // First, deactivate previous
3780         if ( prevFirstSel )
3781         {
3782             OnValidationFailureReset(prevFirstSel);
3783
3784             // Must double-check if this is an selected in case of forceswitch
3785             if ( p != prevFirstSel )
3786             {
3787                 if ( !CommitChangesFromEditor(flags) )
3788                 {
3789                     // Validation has failed, so we can't exit the previous editor
3790                     //::wxMessageBox(_("Please correct the value or press ESC to cancel the edit."),
3791                     //               _("Invalid Value"),wxOK|wxICON_ERROR);
3792                     m_inDoSelectProperty = 0;
3793                     return false;
3794                 }
3795             }
3796
3797             FreeEditors();
3798
3799             m_iFlags &= ~(wxPG_FL_ABNORMAL_EDITOR);
3800             EditorsValueWasNotModified();
3801         }
3802
3803         SetInternalFlag(wxPG_FL_IN_SELECT_PROPERTY);
3804
3805         m_pState->DoSetSelection(p);
3806
3807         // Redraw unselected
3808         for ( unsigned int i=0; i<prevSelection.size(); i++ )
3809         {
3810             DrawItem(prevSelection[i]);
3811         }
3812
3813         //
3814         // Then, activate the one given.
3815         if ( p )
3816         {
3817             int propY = p->GetY2(m_lineHeight);
3818
3819             int splitterX = GetSplitterPosition();
3820             m_editorFocused = 0;
3821             m_iFlags |= wxPG_FL_PRIMARY_FILLS_ENTIRE;
3822             if ( p != prevFirstSel )
3823                 m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
3824
3825             wxASSERT( m_wndEditor == NULL );
3826
3827             //
3828             // Only create editor for non-disabled non-caption
3829             if ( !p->IsCategory() && !(p->m_flags & wxPG_PROP_DISABLED) )
3830             {
3831             // do this for non-caption items
3832
3833                 m_selColumn = 1;
3834
3835                 // Do we need to paint the custom image, if any?
3836                 m_iFlags &= ~(wxPG_FL_CUR_USES_CUSTOM_IMAGE);
3837                 if ( (p->m_flags & wxPG_PROP_CUSTOMIMAGE) &&
3838                      !p->GetEditorClass()->CanContainCustomImage()
3839                    )
3840                     m_iFlags |= wxPG_FL_CUR_USES_CUSTOM_IMAGE;
3841
3842                 wxRect grect = GetEditorWidgetRect(p, m_selColumn);
3843                 wxPoint goodPos = grect.GetPosition();
3844
3845                 const wxPGEditor* editor = p->GetEditorClass();
3846                 wxCHECK_MSG(editor, false,
3847                     wxT("NULL editor class not allowed"));
3848
3849                 m_iFlags &= ~wxPG_FL_FIXED_WIDTH_EDITOR;
3850
3851                 wxPGWindowList wndList =
3852                     editor->CreateControls(this,
3853                                            p,
3854                                            goodPos,
3855                                            grect.GetSize());
3856
3857                 m_wndEditor = wndList.m_primary;
3858                 m_wndEditor2 = wndList.m_secondary;
3859                 wxWindow* primaryCtrl = GetEditorControl();
3860
3861                 //
3862                 // Essentially, primaryCtrl == m_wndEditor
3863                 //
3864
3865                 // NOTE: It is allowed for m_wndEditor to be NULL - in this
3866                 //       case value is drawn as normal, and m_wndEditor2 is
3867                 //       assumed to be a right-aligned button that triggers
3868                 //       a separate editorCtrl window.
3869
3870                 if ( m_wndEditor )
3871                 {
3872                     wxASSERT_MSG( m_wndEditor->GetParent() == GetPanel(),
3873                                   "CreateControls must use result of "
3874                                   "wxPropertyGrid::GetPanel() as parent "
3875                                   "of controls." );
3876
3877                     // Set validator, if any
3878                 #if wxUSE_VALIDATORS
3879                     wxValidator* validator = p->GetValidator();
3880                     if ( validator )
3881                         primaryCtrl->SetValidator(*validator);
3882                 #endif
3883
3884                     if ( m_wndEditor->GetSize().y > (m_lineHeight+6) )
3885                         m_iFlags |= wxPG_FL_ABNORMAL_EDITOR;
3886
3887                     // If it has modified status, use bold font
3888                     // (must be done before capturing m_ctrlXAdjust)
3889                     if ( (p->m_flags & wxPG_PROP_MODIFIED) &&
3890                          (m_windowStyle & wxPG_BOLD_MODIFIED) )
3891                         SetCurControlBoldFont();
3892
3893                     // Store x relative to splitter (we'll need it).
3894                     m_ctrlXAdjust = m_wndEditor->GetPosition().x - splitterX;
3895
3896                     // Check if background clear is not necessary
3897                     wxPoint pos = m_wndEditor->GetPosition();
3898                     if ( pos.x > (splitterX+1) || pos.y > propY )
3899                     {
3900                         m_iFlags &= ~(wxPG_FL_PRIMARY_FILLS_ENTIRE);
3901                     }
3902
3903                     m_wndEditor->SetSizeHints(3, 3);
3904
3905                     SetupChildEventHandling(primaryCtrl);
3906
3907                     // Focus and select all (wxTextCtrl, wxComboBox etc)
3908                     if ( flags & wxPG_SEL_FOCUS )
3909                     {
3910                         primaryCtrl->SetFocus();
3911
3912                         p->GetEditorClass()->OnFocus(p, primaryCtrl);
3913                     }
3914                 }
3915
3916                 if ( m_wndEditor2 )
3917                 {
3918                     wxASSERT_MSG( m_wndEditor2->GetParent() == GetPanel(),
3919                                   "CreateControls must use result of "
3920                                   "wxPropertyGrid::GetPanel() as parent "
3921                                   "of controls." );
3922
3923                     // Get proper id for wndSecondary
3924                     m_wndSecId = m_wndEditor2->GetId();
3925                     wxWindowList children = m_wndEditor2->GetChildren();
3926                     wxWindowList::iterator node = children.begin();
3927                     if ( node != children.end() )
3928                         m_wndSecId = ((wxWindow*)*node)->GetId();
3929
3930                     m_wndEditor2->SetSizeHints(3,3);
3931
3932                     m_wndEditor2->Show();
3933
3934                     SetupChildEventHandling(m_wndEditor2);
3935
3936                     // If no primary editor, focus to button to allow
3937                     // it to interprete ENTER etc.
3938                     // NOTE: Due to problems focusing away from it, this
3939                     //       has been disabled.
3940                     /*
3941                     if ( (flags & wxPG_SEL_FOCUS) && !m_wndEditor )
3942                         m_wndEditor2->SetFocus();
3943                     */
3944                 }
3945
3946                 if ( flags & wxPG_SEL_FOCUS )
3947                     m_editorFocused = 1;
3948
3949             }
3950             else
3951             {
3952                 // Make sure focus is in grid canvas (important for wxGTK,
3953                 // at least)
3954                 SetFocusOnCanvas();
3955             }
3956
3957             EditorsValueWasNotModified();
3958
3959             // If it's inside collapsed section, expand parent, scroll, etc.
3960             // Also, if it was partially visible, scroll it into view.
3961             if ( !(flags & wxPG_SEL_NONVISIBLE) )
3962                 EnsureVisible( p );
3963
3964             if ( m_wndEditor )
3965             {
3966                 m_wndEditor->Show(true);
3967             }
3968
3969             if ( !(flags & wxPG_SEL_NO_REFRESH) )
3970                 DrawItem(p);
3971         }
3972         else
3973         {
3974             // Make sure focus is in grid canvas
3975             SetFocusOnCanvas();
3976         }
3977
3978         ClearInternalFlag(wxPG_FL_IN_SELECT_PROPERTY);
3979     }
3980
3981 #if wxUSE_STATUSBAR
3982
3983     //
3984     // Show help text in status bar.
3985     //   (if found and grid not embedded in manager with help box and
3986     //    style wxPG_EX_HELP_AS_TOOLTIPS is not used).
3987     //
3988
3989     if ( !(GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS) )
3990     {
3991         wxStatusBar* statusbar = NULL;
3992         if ( !(m_iFlags & wxPG_FL_NOSTATUSBARHELP) )
3993         {
3994             wxFrame* frame = wxDynamicCast(::wxGetTopLevelParent(this),wxFrame);
3995             if ( frame )
3996                 statusbar = frame->GetStatusBar();
3997         }
3998
3999         if ( statusbar )
4000         {
4001             const wxString* pHelpString = (const wxString*) NULL;
4002
4003             if ( p )
4004             {
4005                 pHelpString = &p->GetHelpString();
4006                 if ( pHelpString->length() )
4007                 {
4008                     // Set help box text.
4009                     statusbar->SetStatusText( *pHelpString );
4010                     m_iFlags |= wxPG_FL_STRING_IN_STATUSBAR;
4011                 }
4012             }
4013
4014             if ( (!pHelpString || !pHelpString->length()) &&
4015                  (m_iFlags & wxPG_FL_STRING_IN_STATUSBAR) )
4016             {
4017                 // Clear help box - but only if it was written
4018                 // by us at previous time.
4019                 statusbar->SetStatusText( m_emptyString );
4020                 m_iFlags &= ~(wxPG_FL_STRING_IN_STATUSBAR);
4021             }
4022         }
4023     }
4024 #endif
4025
4026     m_inDoSelectProperty = 0;
4027
4028     // call wx event handler (here so that it also occurs on deselection)
4029     if ( !(flags & wxPG_SEL_DONT_SEND_EVENT) )
4030         SendEvent( wxEVT_PG_SELECTED, p, NULL );
4031
4032     return true;
4033 }
4034
4035 // -----------------------------------------------------------------------
4036
4037 bool wxPropertyGrid::UnfocusEditor()
4038 {
4039     wxPGProperty* selected = GetSelection();
4040
4041     if ( !selected || !m_wndEditor || m_frozen )
4042         return true;
4043
4044     if ( !CommitChangesFromEditor(0) )
4045         return false;
4046
4047     SetFocusOnCanvas();
4048     DrawItem(selected);
4049
4050     return true;
4051 }
4052
4053 // -----------------------------------------------------------------------
4054
4055 void wxPropertyGrid::RefreshEditor()
4056 {
4057     wxPGProperty* p = GetSelection();
4058     if ( !p )
4059         return;
4060
4061     wxWindow* wnd = GetEditorControl();
4062     if ( !wnd )
4063         return;
4064
4065     // Set editor font boldness - must do this before
4066     // calling UpdateControl().
4067     if ( HasFlag(wxPG_BOLD_MODIFIED) )
4068     {
4069         if ( p->HasFlag(wxPG_PROP_MODIFIED) )
4070             wnd->SetFont(GetCaptionFont());
4071         else
4072             wnd->SetFont(GetFont());
4073     }
4074
4075     const wxPGEditor* editorClass = p->GetEditorClass();
4076
4077     editorClass->UpdateControl(p, wnd);
4078
4079     if ( p->IsValueUnspecified() )
4080         editorClass ->SetValueToUnspecified(p, wnd);
4081 }
4082
4083 // -----------------------------------------------------------------------
4084
4085 bool wxPropertyGrid::SelectProperty( wxPGPropArg id, bool focus )
4086 {
4087     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
4088
4089     int flags = wxPG_SEL_DONT_SEND_EVENT;
4090     if ( focus )
4091         flags |= wxPG_SEL_FOCUS;
4092
4093     return DoSelectProperty(p, flags);
4094 }
4095
4096 // -----------------------------------------------------------------------
4097 // wxPropertyGrid expand/collapse state
4098 // -----------------------------------------------------------------------
4099
4100 bool wxPropertyGrid::DoCollapse( wxPGProperty* p, bool sendEvents )
4101 {
4102     wxPGProperty* pwc = wxStaticCast(p, wxPGProperty);
4103     wxPGProperty* selected = GetSelection();
4104
4105     // If active editor was inside collapsed section, then disable it
4106     if ( selected && selected->IsSomeParent(p) )
4107     {
4108         DoClearSelection();
4109     }
4110
4111     // Store dont-center-splitter flag 'cause we need to temporarily set it
4112     bool prevDontCenterSplitter = m_pState->m_dontCenterSplitter;
4113     m_pState->m_dontCenterSplitter = true;
4114
4115     bool res = m_pState->DoCollapse(pwc);
4116
4117     if ( res )
4118     {
4119         if ( sendEvents )
4120             SendEvent( wxEVT_PG_ITEM_COLLAPSED, p );
4121
4122         RecalculateVirtualSize();
4123         Refresh();
4124     }
4125
4126     m_pState->m_dontCenterSplitter = prevDontCenterSplitter;
4127
4128     return res;
4129 }
4130
4131 // -----------------------------------------------------------------------
4132
4133 bool wxPropertyGrid::DoExpand( wxPGProperty* p, bool sendEvents )
4134 {
4135     wxCHECK_MSG( p, false, wxT("invalid property id") );
4136
4137     wxPGProperty* pwc = (wxPGProperty*)p;
4138
4139     // Store dont-center-splitter flag 'cause we need to temporarily set it
4140     bool prevDontCenterSplitter = m_pState->m_dontCenterSplitter;
4141     m_pState->m_dontCenterSplitter = true;
4142
4143     bool res = m_pState->DoExpand(pwc);
4144
4145     if ( res )
4146     {
4147         if ( sendEvents )
4148             SendEvent( wxEVT_PG_ITEM_EXPANDED, p );
4149
4150         RecalculateVirtualSize();
4151         Refresh();
4152     }
4153
4154     m_pState->m_dontCenterSplitter = prevDontCenterSplitter;
4155
4156     return res;
4157 }
4158
4159 // -----------------------------------------------------------------------
4160
4161 bool wxPropertyGrid::DoHideProperty( wxPGProperty* p, bool hide, int flags )
4162 {
4163     if ( m_frozen )
4164         return m_pState->DoHideProperty(p, hide, flags);
4165
4166     wxArrayPGProperty selection = m_pState->m_selection;  // Must use a copy
4167     int selRemoveCount = 0;
4168     for ( unsigned int i=0; i<selection.size(); i++ )
4169     {
4170         wxPGProperty* selected = selection[i];
4171         if ( selected == p || selected->IsSomeParent(p) )
4172         {
4173             if ( !DoRemoveFromSelection(p, flags) )
4174                 return false;
4175             selRemoveCount += 1;
4176         }
4177     }
4178
4179     m_pState->DoHideProperty(p, hide, flags);
4180
4181     RecalculateVirtualSize();
4182     Refresh();
4183
4184     return true;
4185 }
4186
4187
4188 // -----------------------------------------------------------------------
4189 // wxPropertyGrid size related methods
4190 // -----------------------------------------------------------------------
4191
4192 void wxPropertyGrid::RecalculateVirtualSize( int forceXPos )
4193 {
4194     if ( (m_iFlags & wxPG_FL_RECALCULATING_VIRTUAL_SIZE) ||
4195          m_frozen ||
4196          !m_pState )
4197         return;
4198
4199     //
4200     // If virtual height was changed, then recalculate editor control position(s)
4201     if ( m_pState->m_vhCalcPending )
4202         CorrectEditorWidgetPosY();
4203
4204     m_pState->EnsureVirtualHeight();
4205
4206     wxASSERT_LEVEL_2_MSG(
4207         m_pState->GetVirtualHeight() == m_pState->GetActualVirtualHeight(),
4208         "VirtualHeight and ActualVirtualHeight should match"
4209     );
4210
4211     m_iFlags |= wxPG_FL_RECALCULATING_VIRTUAL_SIZE;
4212
4213     int x = m_pState->m_width;
4214     int y = m_pState->m_virtualHeight;
4215
4216     int width, height;
4217     GetClientSize(&width,&height);
4218
4219     // Now adjust virtual size.
4220     SetVirtualSize(x, y);
4221
4222     int xAmount = 0;
4223     int xPos = 0;
4224
4225     //
4226     // Adjust scrollbars
4227     if ( HasVirtualWidth() )
4228     {
4229         xAmount = x/wxPG_PIXELS_PER_UNIT;
4230         xPos = GetScrollPos( wxHORIZONTAL );
4231     }
4232
4233     if ( forceXPos != -1 )
4234         xPos = forceXPos;
4235     // xPos too high?
4236     else if ( xPos > (xAmount-(width/wxPG_PIXELS_PER_UNIT)) )
4237         xPos = 0;
4238
4239     int yAmount = y / wxPG_PIXELS_PER_UNIT;
4240     int yPos = GetScrollPos( wxVERTICAL );
4241
4242     SetScrollbars( wxPG_PIXELS_PER_UNIT, wxPG_PIXELS_PER_UNIT,
4243                    xAmount, yAmount, xPos, yPos, true );
4244
4245     // Must re-get size now
4246     GetClientSize(&width,&height);
4247
4248     if ( !HasVirtualWidth() )
4249     {
4250         m_pState->SetVirtualWidth(width);
4251         x = width;
4252     }
4253
4254     m_width = width;
4255     m_height = height;
4256
4257     m_pState->CheckColumnWidths();
4258
4259     if ( GetSelection() )
4260         CorrectEditorWidgetSizeX();
4261
4262     m_iFlags &= ~wxPG_FL_RECALCULATING_VIRTUAL_SIZE;
4263 }
4264
4265 // -----------------------------------------------------------------------
4266
4267 void wxPropertyGrid::OnResize( wxSizeEvent& event )
4268 {
4269     if ( !(m_iFlags & wxPG_FL_INITIALIZED) )
4270         return;
4271
4272     int width, height;
4273     GetClientSize(&width, &height);
4274
4275     m_width = width;
4276     m_height = height;
4277
4278 #if wxPG_DOUBLE_BUFFER
4279     if ( !(GetExtraStyle() & wxPG_EX_NATIVE_DOUBLE_BUFFERING) )
4280     {
4281         int dblh = (m_lineHeight*2);
4282         if ( !m_doubleBuffer )
4283         {
4284             // Create double buffer bitmap to draw on, if none
4285             int w = (width>250)?width:250;
4286             int h = height + dblh;
4287             h = (h>400)?h:400;
4288             m_doubleBuffer = new wxBitmap( w, h );
4289         }
4290         else
4291         {
4292             int w = m_doubleBuffer->GetWidth();
4293             int h = m_doubleBuffer->GetHeight();
4294
4295             // Double buffer must be large enough
4296             if ( w < width || h < (height+dblh) )
4297             {
4298                 if ( w < width ) w = width;
4299                 if ( h < (height+dblh) ) h = height + dblh;
4300                 delete m_doubleBuffer;
4301                 m_doubleBuffer = new wxBitmap( w, h );
4302             }
4303         }
4304     }
4305
4306 #endif
4307
4308     m_pState->OnClientWidthChange( width, event.GetSize().x - m_ncWidth, true );
4309     m_ncWidth = event.GetSize().x;
4310
4311     if ( !m_frozen )
4312     {
4313         if ( m_pState->m_itemsAdded )
4314             PrepareAfterItemsAdded();
4315         else
4316             // Without this, virtual size (atleast under wxGTK) will be skewed
4317             RecalculateVirtualSize();
4318
4319         Refresh();
4320     }
4321 }
4322
4323 // -----------------------------------------------------------------------
4324
4325 void wxPropertyGrid::SetVirtualWidth( int width )
4326 {
4327     if ( width == -1 )
4328     {
4329         // Disable virtual width
4330         width = GetClientSize().x;
4331         ClearInternalFlag(wxPG_FL_HAS_VIRTUAL_WIDTH);
4332     }
4333     else
4334     {
4335         // Enable virtual width
4336         SetInternalFlag(wxPG_FL_HAS_VIRTUAL_WIDTH);
4337     }
4338     m_pState->SetVirtualWidth( width );
4339 }
4340
4341 void wxPropertyGrid::SetFocusOnCanvas()
4342 {
4343     SetFocusIgnoringChildren();
4344     m_editorFocused = 0;
4345 }
4346
4347 // -----------------------------------------------------------------------
4348 // wxPropertyGrid mouse event handling
4349 // -----------------------------------------------------------------------
4350
4351 // selFlags uses same values DoSelectProperty's flags
4352 // Returns true if event was vetoed.
4353 bool wxPropertyGrid::SendEvent( int eventType, wxPGProperty* p,
4354                                 wxVariant* pValue,
4355                                 unsigned int selFlags,
4356                                 unsigned int column )
4357 {
4358     // selFlags should have wxPG_SEL_NOVALIDATE if event is not
4359     // vetoable.
4360
4361     // Send property grid event of specific type and with specific property
4362     wxPropertyGridEvent evt( eventType, m_eventObject->GetId() );
4363     evt.SetPropertyGrid(this);
4364     evt.SetEventObject(m_eventObject);
4365     evt.SetProperty(p);
4366     evt.SetColumn(column);
4367     if ( eventType == wxEVT_PG_CHANGING )
4368     {
4369         wxASSERT( pValue );
4370         evt.SetCanVeto(true);
4371         m_validationInfo.m_pValue = pValue;
4372         evt.SetupValidationInfo();
4373     }
4374     else
4375     {
4376         if ( p )
4377             evt.SetPropertyValue(p->GetValue());
4378
4379         if ( !(selFlags & wxPG_SEL_NOVALIDATE) )
4380             evt.SetCanVeto(true);
4381     }
4382
4383     m_processedEvent = &evt;
4384     m_eventObject->HandleWindowEvent(evt);
4385     m_processedEvent = NULL;
4386
4387     return evt.WasVetoed();
4388 }
4389
4390 // -----------------------------------------------------------------------
4391
4392 // Return false if should be skipped
4393 bool wxPropertyGrid::HandleMouseClick( int x, unsigned int y, wxMouseEvent &event )
4394 {
4395     bool res = true;
4396
4397     // Need to set focus?
4398     if ( !(m_iFlags & wxPG_FL_FOCUSED) )
4399     {
4400         SetFocusOnCanvas();
4401     }
4402
4403     wxPropertyGridPageState* state = m_pState;
4404     int splitterHit;
4405     int splitterHitOffset;
4406     int columnHit = state->HitTestH( x, &splitterHit, &splitterHitOffset );
4407
4408     wxPGProperty* p = DoGetItemAtY(y);
4409
4410     if ( p )
4411     {
4412         int depth = (int)p->GetDepth() - 1;
4413
4414         int marginEnds = m_marginWidth + ( depth * m_subgroup_extramargin );
4415
4416         if ( x >= marginEnds )
4417         {
4418             // Outside margin.
4419
4420             if ( p->IsCategory() )
4421             {
4422                 // This is category.
4423                 wxPropertyCategory* pwc = (wxPropertyCategory*)p;
4424
4425                 int textX = m_marginWidth + ((unsigned int)((pwc->m_depth-1)*m_subgroup_extramargin));
4426
4427                 // Expand, collapse, activate etc. if click on text or left of splitter.
4428                 if ( x >= textX
4429                      &&
4430                      ( x < (textX+pwc->GetTextExtent(this, m_captionFont)+(wxPG_CAPRECTXMARGIN*2)) ||
4431                        columnHit == 0
4432                      )
4433                     )
4434                 {
4435                     if ( !AddToSelectionFromInputEvent( p,
4436                                                         columnHit,
4437                                                         &event ) )
4438                         return res;
4439
4440                     // On double-click, expand/collapse.
4441                     if ( event.ButtonDClick() && !(m_windowStyle & wxPG_HIDE_MARGIN) )
4442                     {
4443                         if ( pwc->IsExpanded() ) DoCollapse( p, true );
4444                         else DoExpand( p, true );
4445                     }
4446                 }
4447             }
4448             else if ( splitterHit == -1 )
4449             {
4450             // Click on value.
4451                 unsigned int selFlag = 0;
4452                 if ( columnHit == 1 )
4453                 {
4454                     m_iFlags |= wxPG_FL_ACTIVATION_BY_CLICK;
4455                     selFlag = wxPG_SEL_FOCUS;
4456                 }
4457                 if ( !AddToSelectionFromInputEvent( p,
4458                                                     columnHit,
4459                                                     &event,
4460                                                     selFlag ) )
4461                     return res;
4462
4463                 m_iFlags &= ~(wxPG_FL_ACTIVATION_BY_CLICK);
4464
4465                 if ( p->GetChildCount() && !p->IsCategory() )
4466                     // On double-click, expand/collapse.
4467                     if ( event.ButtonDClick() && !(m_windowStyle & wxPG_HIDE_MARGIN) )
4468                     {
4469                         wxPGProperty* pwc = (wxPGProperty*)p;
4470                         if ( pwc->IsExpanded() ) DoCollapse( p, true );
4471                         else DoExpand( p, true );
4472                     }
4473
4474                 res = false;
4475             }
4476             else
4477             {
4478             // click on splitter
4479                 if ( !(m_windowStyle & wxPG_STATIC_SPLITTER) )
4480                 {
4481                     if ( event.GetEventType() == wxEVT_LEFT_DCLICK )
4482                     {
4483                         // Double-clicking the splitter causes auto-centering
4484                         if ( m_pState->GetColumnCount() <= 2 )
4485                         {
4486                             CenterSplitter( true );
4487
4488                             SendEvent(wxEVT_PG_COL_DRAGGING,
4489                                       m_propHover,
4490                                       NULL,
4491                                       wxPG_SEL_NOVALIDATE,
4492                                       (unsigned int)m_draggedSplitter);
4493                         }
4494                     }
4495                     else if ( m_dragStatus == 0 )
4496                     {
4497                         //
4498                         // Begin draggin the splitter
4499                         //
4500
4501                         // send event
4502                         DoEndLabelEdit(true, wxPG_SEL_NOVALIDATE);
4503
4504                         // Allow application to veto dragging
4505                         if ( !SendEvent(wxEVT_PG_COL_BEGIN_DRAG,
4506                                         p, NULL, 0,
4507                                         (unsigned int)splitterHit) )
4508                         {
4509                             if ( m_wndEditor )
4510                             {
4511                                 // Changes must be committed here or the
4512                                 // value won't be drawn correctly
4513                                 if ( !CommitChangesFromEditor() )
4514                                     return res;
4515
4516                                 m_wndEditor->Show ( false );
4517                             }
4518
4519                             if ( !(m_iFlags & wxPG_FL_MOUSE_CAPTURED) )
4520                             {
4521                                 CaptureMouse();
4522                                 m_iFlags |= wxPG_FL_MOUSE_CAPTURED;
4523                             }
4524
4525                             m_dragStatus = 1;
4526                             m_draggedSplitter = splitterHit;
4527                             m_dragOffset = splitterHitOffset;
4528
4529                         #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
4530                             // Fixes button disappearance bug
4531                             if ( m_wndEditor2 )
4532                                 m_wndEditor2->Show ( false );
4533                         #endif
4534
4535                             m_startingSplitterX = x - splitterHitOffset;
4536                         }
4537                     }
4538                 }
4539             }
4540         }
4541         else
4542         {
4543         // Click on margin.
4544             if ( p->GetChildCount() )
4545             {
4546                 int nx = x + m_marginWidth - marginEnds; // Normalize x.
4547
4548                 // Fine tune cell button x
4549                 if ( !p->IsCategory() )
4550                     nx -= IN_CELL_EXPANDER_BUTTON_X_ADJUST;
4551
4552                 if ( (nx >= m_gutterWidth && nx < (m_gutterWidth+m_iconWidth)) )
4553                 {
4554                     int y2 = y % m_lineHeight;
4555                     if ( (y2 >= m_buttonSpacingY && y2 < (m_buttonSpacingY+m_iconHeight)) )
4556                     {
4557                         // On click on expander button, expand/collapse
4558                         if ( ((wxPGProperty*)p)->IsExpanded() )
4559                             DoCollapse( p, true );
4560                         else
4561                             DoExpand( p, true );
4562                     }
4563                 }
4564             }
4565         }
4566     }
4567     return res;
4568 }
4569
4570 // -----------------------------------------------------------------------
4571
4572 bool wxPropertyGrid::HandleMouseRightClick( int WXUNUSED(x),
4573                                             unsigned int WXUNUSED(y),
4574                                             wxMouseEvent& event )
4575 {
4576     if ( m_propHover )
4577     {
4578         // Select property here as well
4579         wxPGProperty* p = m_propHover;
4580         AddToSelectionFromInputEvent(p, m_colHover, &event);
4581
4582         // Send right click event.
4583         SendEvent( wxEVT_PG_RIGHT_CLICK, p );
4584
4585         return true;
4586     }
4587     return false;
4588 }
4589
4590 // -----------------------------------------------------------------------
4591
4592 bool wxPropertyGrid::HandleMouseDoubleClick( int WXUNUSED(x),
4593                                              unsigned int WXUNUSED(y),
4594                                              wxMouseEvent& event )
4595 {
4596     if ( m_propHover )
4597     {
4598         // Select property here as well
4599         wxPGProperty* p = m_propHover;
4600
4601         AddToSelectionFromInputEvent(p, m_colHover, &event);
4602
4603         // Send double-click event.
4604         SendEvent( wxEVT_PG_DOUBLE_CLICK, m_propHover );
4605
4606         return true;
4607     }
4608     return false;
4609 }
4610
4611 // -----------------------------------------------------------------------
4612
4613 #if wxPG_SUPPORT_TOOLTIPS
4614
4615 void wxPropertyGrid::SetToolTip( const wxString& tipString )
4616 {
4617     if ( tipString.length() )
4618     {
4619         wxScrolledWindow::SetToolTip(tipString);
4620     }
4621     else
4622     {
4623     #if wxPG_ALLOW_EMPTY_TOOLTIPS
4624         wxScrolledWindow::SetToolTip( m_emptyString );
4625     #else
4626         wxScrolledWindow::SetToolTip( NULL );
4627     #endif
4628     }
4629 }
4630
4631 #endif // #if wxPG_SUPPORT_TOOLTIPS
4632
4633 // -----------------------------------------------------------------------
4634
4635 // Return false if should be skipped
4636 bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y,
4637                                       wxMouseEvent &event )
4638 {
4639     // Safety check (needed because mouse capturing may
4640     // otherwise freeze the control)
4641     if ( m_dragStatus > 0 && !event.Dragging() )
4642     {
4643         HandleMouseUp(x, y, event);
4644     }
4645
4646     wxPropertyGridPageState* state = m_pState;
4647     int splitterHit;
4648     int splitterHitOffset;
4649     int columnHit = state->HitTestH( x, &splitterHit, &splitterHitOffset );
4650     int splitterX = x - splitterHitOffset;
4651
4652     m_colHover = columnHit;
4653
4654     if ( m_dragStatus > 0 )
4655     {
4656         if ( x > (m_marginWidth + wxPG_DRAG_MARGIN) &&
4657              x < (m_pState->m_width - wxPG_DRAG_MARGIN) )
4658         {
4659
4660             int newSplitterX = x - m_dragOffset;
4661             int splitterX = x - splitterHitOffset;
4662
4663             // Splitter redraw required?
4664             if ( newSplitterX != splitterX )
4665             {
4666                 // Move everything
4667                 DoSetSplitterPosition(newSplitterX,
4668                                       m_draggedSplitter,
4669                                       wxPG_SPLITTER_REFRESH |
4670                                       wxPG_SPLITTER_FROM_EVENT);
4671
4672                 SendEvent(wxEVT_PG_COL_DRAGGING,
4673                           m_propHover,
4674                           NULL,
4675                           wxPG_SEL_NOVALIDATE,
4676                           (unsigned int)m_draggedSplitter);
4677             }
4678
4679             m_dragStatus = 2;
4680         }
4681
4682         return false;
4683     }
4684     else
4685     {
4686
4687         int ih = m_lineHeight;
4688         int sy = y;
4689
4690     #if wxPG_SUPPORT_TOOLTIPS
4691         wxPGProperty* prevHover = m_propHover;
4692         unsigned char prevSide = m_mouseSide;
4693     #endif
4694         int curPropHoverY = y - (y % ih);
4695
4696         // On which item it hovers
4697         if ( !m_propHover
4698              ||
4699              ( sy < m_propHoverY || sy >= (m_propHoverY+ih) )
4700            )
4701         {
4702             // Mouse moves on another property
4703
4704             m_propHover = DoGetItemAtY(y);
4705             m_propHoverY = curPropHoverY;
4706
4707             // Send hover event
4708             SendEvent( wxEVT_PG_HIGHLIGHTED, m_propHover );
4709         }
4710
4711     #if wxPG_SUPPORT_TOOLTIPS
4712         // Store which side we are on
4713         m_mouseSide = 0;
4714         if ( columnHit == 1 )
4715             m_mouseSide = 2;
4716         else if ( columnHit == 0 )
4717             m_mouseSide = 1;
4718
4719         //
4720         // If tooltips are enabled, show label or value as a tip
4721         // in case it doesn't otherwise show in full length.
4722         //
4723         if ( m_windowStyle & wxPG_TOOLTIPS )
4724         {
4725             wxToolTip* tooltip = GetToolTip();
4726
4727             if ( m_propHover != prevHover || prevSide != m_mouseSide )
4728             {
4729                 if ( m_propHover && !m_propHover->IsCategory() )
4730                 {
4731
4732                     if ( GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS )
4733                     {
4734                         // Show help string as a tooltip
4735                         wxString tipString = m_propHover->GetHelpString();
4736
4737                         SetToolTip(tipString);
4738                     }
4739                     else
4740                     {
4741                         // Show cropped value string as a tooltip
4742                         wxString tipString;
4743                         int space = 0;
4744
4745                         if ( m_mouseSide == 1 )
4746                         {
4747                             tipString = m_propHover->m_label;
4748                             space = splitterX-m_marginWidth-3;
4749                         }
4750                         else if ( m_mouseSide == 2 )
4751                         {
4752                             tipString = m_propHover->GetDisplayedString();
4753
4754                             space = m_width - splitterX;
4755                             if ( m_propHover->m_flags & wxPG_PROP_CUSTOMIMAGE )
4756                                 space -= wxPG_CUSTOM_IMAGE_WIDTH +
4757                                          wxCC_CUSTOM_IMAGE_MARGIN1 +
4758                                          wxCC_CUSTOM_IMAGE_MARGIN2;
4759                         }
4760
4761                         if ( space )
4762                         {
4763                             int tw, th;
4764                             GetTextExtent( tipString, &tw, &th, 0, 0 );
4765                             if ( tw > space )
4766                             {
4767                                 SetToolTip( tipString );
4768                             }
4769                         }
4770                         else
4771                         {
4772                             if ( tooltip )
4773                             {
4774                             #if wxPG_ALLOW_EMPTY_TOOLTIPS
4775                                 SetToolTip( m_emptyString );
4776                             #else
4777                                 wxScrolledWindow::SetToolTip( NULL );
4778                             #endif
4779                             }
4780                         }
4781
4782                     }
4783                 }
4784                 else
4785                 {
4786                     if ( tooltip )
4787                     {
4788                     #if wxPG_ALLOW_EMPTY_TOOLTIPS
4789                         SetToolTip( m_emptyString );
4790                     #else
4791                         wxScrolledWindow::SetToolTip( NULL );
4792                     #endif
4793                     }
4794                 }
4795             }
4796         }
4797     #endif
4798
4799         if ( splitterHit == -1 ||
4800              !m_propHover ||
4801              HasFlag(wxPG_STATIC_SPLITTER) )
4802         {
4803             // hovering on something else
4804             if ( m_curcursor != wxCURSOR_ARROW )
4805                 CustomSetCursor( wxCURSOR_ARROW );
4806         }
4807         else
4808         {
4809             // Do not allow splitter cursor on caption items.
4810             // (also not if we were dragging and its started
4811             // outside the splitter region)
4812
4813             if ( !m_propHover->IsCategory() &&
4814                  !event.Dragging() )
4815             {
4816
4817                 // hovering on splitter
4818
4819                 // NB: Condition disabled since MouseLeave event (from the
4820                 //     editor control) cannot be reliably detected.
4821                 //if ( m_curcursor != wxCURSOR_SIZEWE )
4822                 CustomSetCursor( wxCURSOR_SIZEWE, true );
4823
4824                 return false;
4825             }
4826             else
4827             {
4828                 // hovering on something else
4829                 if ( m_curcursor != wxCURSOR_ARROW )
4830                     CustomSetCursor( wxCURSOR_ARROW );
4831             }
4832         }
4833
4834         //
4835         // Multi select by dragging
4836         //
4837         if ( (GetExtraStyle() & wxPG_EX_MULTIPLE_SELECTION) &&
4838              event.LeftIsDown() &&
4839              m_propHover &&
4840              GetSelection() &&
4841              columnHit != 1 &&
4842              !state->DoIsPropertySelected(m_propHover) )
4843         {
4844             // Additional requirement is that the hovered property
4845             // is adjacent to edges of selection.
4846             const wxArrayPGProperty& selection = GetSelectedProperties();
4847
4848             // Since categories cannot be selected along with 'other'
4849             // properties, exclude them from iterator flags.
4850             int iterFlags = wxPG_ITERATE_VISIBLE & (~wxPG_PROP_CATEGORY);
4851
4852             for ( int i=(selection.size()-1); i>=0; i-- )
4853             {
4854                 // TODO: This could be optimized by keeping track of
4855                 //       which properties are at the edges of selection.
4856                 wxPGProperty* selProp = selection[i];
4857                 if ( state->ArePropertiesAdjacent(m_propHover, selProp,
4858                                                   iterFlags) )
4859                 {
4860                     DoAddToSelection(m_propHover);
4861                     break;
4862                 }
4863             }
4864         }
4865     }
4866     return true;
4867 }
4868
4869 // -----------------------------------------------------------------------
4870
4871 // Also handles Leaving event
4872 bool wxPropertyGrid::HandleMouseUp( int x, unsigned int WXUNUSED(y),
4873                                     wxMouseEvent &WXUNUSED(event) )
4874 {
4875     wxPropertyGridPageState* state = m_pState;
4876     bool res = false;
4877
4878     int splitterHit;
4879     int splitterHitOffset;
4880     state->HitTestH( x, &splitterHit, &splitterHitOffset );
4881
4882     // No event type check - basicly calling this method should
4883     // just stop dragging.
4884     // Left up after dragged?
4885     if ( m_dragStatus >= 1 )
4886     {
4887     //
4888     // End Splitter Dragging
4889     //
4890         // DO NOT ENABLE FOLLOWING LINE!
4891         // (it is only here as a reminder to not to do it)
4892         //splitterX = x;
4893
4894         SendEvent(wxEVT_PG_COL_END_DRAG,
4895                   m_propHover,
4896                   NULL,
4897                   wxPG_SEL_NOVALIDATE,
4898                   (unsigned int)m_draggedSplitter);
4899
4900         // Disable splitter auto-centering
4901         state->m_dontCenterSplitter = true;
4902
4903         // This is necessary to return cursor
4904         if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
4905         {
4906             ReleaseMouse();
4907             m_iFlags &= ~(wxPG_FL_MOUSE_CAPTURED);
4908         }
4909
4910         // Set back the default cursor, if necessary
4911         if ( splitterHit == -1 ||
4912              !m_propHover )
4913         {
4914             CustomSetCursor( wxCURSOR_ARROW );
4915         }
4916
4917         m_dragStatus = 0;
4918
4919         // Control background needs to be cleared
4920         wxPGProperty* selected = GetSelection();
4921         if ( !(m_iFlags & wxPG_FL_PRIMARY_FILLS_ENTIRE) && selected )
4922             DrawItem( selected );
4923
4924         if ( m_wndEditor )
4925         {
4926             m_wndEditor->Show ( true );
4927         }
4928
4929     #if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
4930         // Fixes button disappearance bug
4931         if ( m_wndEditor2 )
4932             m_wndEditor2->Show ( true );
4933     #endif
4934
4935         // This clears the focus.
4936         m_editorFocused = 0;
4937
4938     }
4939     return res;
4940 }
4941
4942 // -----------------------------------------------------------------------
4943
4944 bool wxPropertyGrid::OnMouseCommon( wxMouseEvent& event, int* px, int* py )
4945 {
4946     int splitterX = GetSplitterPosition();
4947
4948     int ux, uy;
4949     CalcUnscrolledPosition( event.m_x, event.m_y, &ux, &uy );
4950
4951     wxWindow* wnd = GetEditorControl();
4952
4953     // Hide popup on clicks
4954     if ( event.GetEventType() != wxEVT_MOTION )
4955         if ( wnd && wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
4956         {
4957             ((wxOwnerDrawnComboBox*)wnd)->HidePopup();
4958         }
4959
4960     wxRect r;
4961     if ( wnd )
4962         r = wnd->GetRect();
4963     if ( wnd == NULL || m_dragStatus ||
4964          (
4965            ux <= (splitterX + wxPG_SPLITTERX_DETECTMARGIN2) ||
4966            ux >= (r.x+r.width) ||
4967            event.m_y < r.y ||
4968            event.m_y >= (r.y+r.height)
4969          )
4970        )
4971     {
4972         *px = ux;
4973         *py = uy;
4974         return true;
4975     }
4976     else
4977     {
4978         if ( m_curcursor != wxCURSOR_ARROW ) CustomSetCursor ( wxCURSOR_ARROW );
4979     }
4980     return false;
4981 }
4982
4983 // -----------------------------------------------------------------------
4984
4985 void wxPropertyGrid::OnMouseClick( wxMouseEvent &event )
4986 {
4987     int x, y;
4988     if ( OnMouseCommon( event, &x, &y ) )
4989     {
4990         HandleMouseClick(x,y,event);
4991     }
4992     event.Skip();
4993 }
4994
4995 // -----------------------------------------------------------------------
4996
4997 void wxPropertyGrid::OnMouseRightClick( wxMouseEvent &event )
4998 {
4999     int x, y;
5000     CalcUnscrolledPosition( event.m_x, event.m_y, &x, &y );
5001     HandleMouseRightClick(x,y,event);
5002     event.Skip();
5003 }
5004
5005 // -----------------------------------------------------------------------
5006
5007 void wxPropertyGrid::OnMouseDoubleClick( wxMouseEvent &event )
5008 {
5009     // Always run standard mouse-down handler as well
5010     OnMouseClick(event);
5011
5012     int x, y;
5013     CalcUnscrolledPosition( event.m_x, event.m_y, &x, &y );
5014     HandleMouseDoubleClick(x,y,event);
5015     event.Skip();
5016 }
5017
5018 // -----------------------------------------------------------------------
5019
5020 void wxPropertyGrid::OnMouseMove( wxMouseEvent &event )
5021 {
5022     int x, y;
5023     if ( OnMouseCommon( event, &x, &y ) )
5024     {
5025         HandleMouseMove(x,y,event);
5026     }
5027     event.Skip();
5028 }
5029
5030 // -----------------------------------------------------------------------
5031
5032 void wxPropertyGrid::OnMouseUp( wxMouseEvent &event )
5033 {
5034     int x, y;
5035     if ( OnMouseCommon( event, &x, &y ) )
5036     {
5037         HandleMouseUp(x,y,event);
5038     }
5039     event.Skip();
5040 }
5041
5042 // -----------------------------------------------------------------------
5043
5044 void wxPropertyGrid::OnMouseEntry( wxMouseEvent &event )
5045 {
5046     // This may get called from child control as well, so event's
5047     // mouse position cannot be relied on.
5048
5049     if ( event.Entering() )
5050     {
5051         if ( !(m_iFlags & wxPG_FL_MOUSE_INSIDE) )
5052         {
5053             // TODO: Fix this (detect parent and only do
5054             //   cursor trick if it is a manager).
5055             wxASSERT( GetParent() );
5056             GetParent()->SetCursor(wxNullCursor);
5057
5058             m_iFlags |= wxPG_FL_MOUSE_INSIDE;
5059         }
5060         else
5061             GetParent()->SetCursor(wxNullCursor);
5062     }
5063     else if ( event.Leaving() )
5064     {
5065         // Without this, wxSpinCtrl editor will sometimes have wrong cursor
5066         SetCursor( wxNullCursor );
5067
5068         // Get real cursor position
5069         wxPoint pt = ScreenToClient(::wxGetMousePosition());
5070
5071         if ( ( pt.x <= 0 || pt.y <= 0 || pt.x >= m_width || pt.y >= m_height ) )
5072         {
5073             {
5074                 if ( (m_iFlags & wxPG_FL_MOUSE_INSIDE) )
5075                 {
5076                     m_iFlags &= ~(wxPG_FL_MOUSE_INSIDE);
5077                 }
5078
5079                 if ( m_dragStatus )
5080                     wxPropertyGrid::HandleMouseUp ( -1, 10000, event );
5081             }
5082         }
5083     }
5084
5085     event.Skip();
5086 }
5087
5088 // -----------------------------------------------------------------------
5089
5090 // Common code used by various OnMouseXXXChild methods.
5091 bool wxPropertyGrid::OnMouseChildCommon( wxMouseEvent &event, int* px, int *py )
5092 {
5093     wxWindow* topCtrlWnd = (wxWindow*)event.GetEventObject();
5094     wxASSERT( topCtrlWnd );
5095     int x, y;
5096     event.GetPosition(&x,&y);
5097
5098     int splitterX = GetSplitterPosition();
5099
5100     wxRect r = topCtrlWnd->GetRect();
5101     if ( !m_dragStatus &&
5102          x > (splitterX-r.x+wxPG_SPLITTERX_DETECTMARGIN2) &&
5103          y >= 0 && y < r.height \
5104        )
5105     {
5106         if ( m_curcursor != wxCURSOR_ARROW ) CustomSetCursor ( wxCURSOR_ARROW );
5107         event.Skip();
5108     }
5109     else
5110     {
5111         CalcUnscrolledPosition( event.m_x + r.x, event.m_y + r.y, \
5112             px, py );
5113         return true;
5114     }
5115     return false;
5116 }
5117
5118 void wxPropertyGrid::OnMouseClickChild( wxMouseEvent &event )
5119 {
5120     int x,y;
5121     if ( OnMouseChildCommon(event,&x,&y) )
5122     {
5123         bool res = HandleMouseClick(x,y,event);
5124         if ( !res ) event.Skip();
5125     }
5126 }
5127
5128 void wxPropertyGrid::OnMouseRightClickChild( wxMouseEvent &event )
5129 {
5130     int x,y;
5131     wxASSERT( m_wndEditor );
5132     // These coords may not be exact (about +-2),
5133     // but that should not matter (right click is about item, not position).
5134     wxPoint pt = m_wndEditor->GetPosition();
5135     CalcUnscrolledPosition( event.m_x + pt.x, event.m_y + pt.y, &x, &y );
5136
5137     // FIXME: Used to set m_propHover to selection here. Was it really
5138     //        necessary?
5139
5140     bool res = HandleMouseRightClick(x,y,event);
5141     if ( !res ) event.Skip();
5142 }
5143
5144 void wxPropertyGrid::OnMouseMoveChild( wxMouseEvent &event )
5145 {
5146     int x,y;
5147     if ( OnMouseChildCommon(event,&x,&y) )
5148     {
5149         bool res = HandleMouseMove(x,y,event);
5150         if ( !res ) event.Skip();
5151     }
5152 }
5153
5154 void wxPropertyGrid::OnMouseUpChild( wxMouseEvent &event )
5155 {
5156     int x,y;
5157     if ( OnMouseChildCommon(event,&x,&y) )
5158     {
5159         bool res = HandleMouseUp(x,y,event);
5160         if ( !res ) event.Skip();
5161     }
5162 }
5163
5164 // -----------------------------------------------------------------------
5165 // wxPropertyGrid keyboard event handling
5166 // -----------------------------------------------------------------------
5167
5168 int wxPropertyGrid::KeyEventToActions(wxKeyEvent &event, int* pSecond) const
5169 {
5170     // Translates wxKeyEvent to wxPG_ACTION_XXX
5171
5172     int keycode = event.GetKeyCode();
5173     int modifiers = event.GetModifiers();
5174
5175     wxASSERT( !(modifiers&~(0xFFFF)) );
5176
5177     int hashMapKey = (keycode & 0xFFFF) | ((modifiers & 0xFFFF) << 16);
5178
5179     wxPGHashMapI2I::const_iterator it = m_actionTriggers.find(hashMapKey);
5180
5181     if ( it == m_actionTriggers.end() )
5182         return 0;
5183
5184     if ( pSecond )
5185     {
5186         int second = (it->second>>16) & 0xFFFF;
5187         *pSecond = second;
5188     }
5189
5190     return (it->second & 0xFFFF);
5191 }
5192
5193 void wxPropertyGrid::AddActionTrigger( int action, int keycode, int modifiers )
5194 {
5195     wxASSERT( !(modifiers&~(0xFFFF)) );
5196
5197     int hashMapKey = (keycode & 0xFFFF) | ((modifiers & 0xFFFF) << 16);
5198
5199     wxPGHashMapI2I::iterator it = m_actionTriggers.find(hashMapKey);
5200
5201     if ( it != m_actionTriggers.end() )
5202     {
5203         // This key combination is already used
5204
5205         // Can add secondary?
5206         wxASSERT_MSG( !(it->second&~(0xFFFF)),
5207                       wxT("You can only add up to two separate actions per key combination.") );
5208
5209         action = it->second | (action<<16);
5210     }
5211
5212     m_actionTriggers[hashMapKey] = action;
5213 }
5214
5215 void wxPropertyGrid::ClearActionTriggers( int action )
5216 {
5217     wxPGHashMapI2I::iterator it;
5218     bool didSomething;
5219
5220     do
5221     {
5222         didSomething = false;
5223
5224         for ( it = m_actionTriggers.begin();
5225               it != m_actionTriggers.end();
5226               it++ )
5227         {
5228             if ( it->second == action )
5229             {
5230                 m_actionTriggers.erase(it);
5231                 didSomething = true;
5232                 break;
5233             }
5234         }
5235     }
5236     while ( didSomething );
5237 }
5238
5239 void wxPropertyGrid::HandleKeyEvent( wxKeyEvent &event, bool fromChild )
5240 {
5241     //
5242     // Handles key event when editor control is not focused.
5243     //
5244
5245     wxCHECK2(!m_frozen, return);
5246
5247     // Travelsal between items, collapsing/expanding, etc.
5248     wxPGProperty* selected = GetSelection();
5249     int keycode = event.GetKeyCode();
5250     bool editorFocused = IsEditorFocused();
5251
5252     if ( keycode == WXK_TAB )
5253     {
5254         wxWindow* mainControl;
5255
5256         if ( HasInternalFlag(wxPG_FL_IN_MANAGER) )
5257             mainControl = GetParent();
5258         else
5259             mainControl = this;
5260
5261         if ( !event.ShiftDown() )
5262         {
5263             if ( !editorFocused && m_wndEditor )
5264             {
5265                 DoSelectProperty( selected, wxPG_SEL_FOCUS );
5266             }
5267             else
5268             {
5269                 // Tab traversal workaround for platforms on which
5270                 // wxWindow::Navigate() may navigate into first child
5271                 // instead of next sibling. Does not work perfectly
5272                 // in every scenario (for instance, when property grid
5273                 // is either first or last control).
5274             #if defined(__WXGTK__)
5275                 wxWindow* sibling = mainControl->GetNextSibling();
5276                 if ( sibling )
5277                     sibling->SetFocusFromKbd();
5278             #else
5279                 Navigate(wxNavigationKeyEvent::IsForward);
5280             #endif
5281             }
5282         }
5283         else
5284         {
5285             if ( editorFocused )
5286             {
5287                 UnfocusEditor();
5288             }
5289             else
5290             {
5291             #if defined(__WXGTK__)
5292                 wxWindow* sibling = mainControl->GetPrevSibling();
5293                 if ( sibling )
5294                     sibling->SetFocusFromKbd();
5295             #else
5296                 Navigate(wxNavigationKeyEvent::IsBackward);
5297             #endif
5298             }
5299         }
5300
5301         return;
5302     }
5303
5304     // Ignore Alt and Control when they are down alone
5305     if ( keycode == WXK_ALT ||
5306          keycode == WXK_CONTROL )
5307     {
5308         event.Skip();
5309         return;
5310     }
5311
5312     int secondAction;
5313     int action = KeyEventToActions(event, &secondAction);
5314
5315     if ( editorFocused && action == wxPG_ACTION_CANCEL_EDIT )
5316     {
5317         //
5318         // Esc cancels any changes
5319         if ( IsEditorsValueModified() )
5320         {
5321             EditorsValueWasNotModified();
5322
5323             // Update the control as well
5324             selected->GetEditorClass()->
5325                 SetControlStringValue( selected,
5326                                        GetEditorControl(),
5327                                        selected->GetDisplayedString() );
5328         }
5329
5330         OnValidationFailureReset(selected);
5331
5332         UnfocusEditor();
5333         return;
5334     }
5335
5336     // Except for TAB and ESC, handle child control events in child control
5337     if ( fromChild )
5338     {
5339         // Only propagate event if it had modifiers
5340         if ( !event.HasModifiers() )
5341         {
5342             event.StopPropagation();
5343         }
5344         event.Skip();
5345         return;
5346     }
5347
5348     bool wasHandled = false;
5349
5350     if ( selected )
5351     {
5352         // Show dialog?
5353         if ( ButtonTriggerKeyTest(action, event) )
5354             return;
5355
5356         wxPGProperty* p = selected;
5357
5358         // Travel and expand/collapse
5359         int selectDir = -2;
5360
5361         if ( p->GetChildCount() )
5362         {
5363             if ( action == wxPG_ACTION_COLLAPSE_PROPERTY || secondAction == wxPG_ACTION_COLLAPSE_PROPERTY )
5364             {
5365                 if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Collapse(p) )
5366                     wasHandled = true;
5367             }
5368             else if ( action == wxPG_ACTION_EXPAND_PROPERTY || secondAction == wxPG_ACTION_EXPAND_PROPERTY )
5369             {
5370                 if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Expand(p) )
5371                     wasHandled = true;
5372             }
5373         }
5374
5375         if ( !wasHandled )
5376         {
5377             if ( action == wxPG_ACTION_PREV_PROPERTY || secondAction == wxPG_ACTION_PREV_PROPERTY )
5378             {
5379                 selectDir = -1;
5380             }
5381             else if ( action == wxPG_ACTION_NEXT_PROPERTY || secondAction == wxPG_ACTION_NEXT_PROPERTY )
5382             {
5383                 selectDir = 1;
5384             }
5385         }
5386
5387         if ( selectDir >= -1 )
5388         {
5389             p = wxPropertyGridIterator::OneStep( m_pState, wxPG_ITERATE_VISIBLE, p, selectDir );
5390             if ( p )
5391                 DoSelectProperty(p);
5392             wasHandled = true;
5393         }
5394     }
5395     else
5396     {
5397         // If nothing was selected, select the first item now
5398         // (or navigate out of tab).
5399         if ( action != wxPG_ACTION_CANCEL_EDIT && secondAction != wxPG_ACTION_CANCEL_EDIT )
5400         {
5401             wxPGProperty* p = wxPropertyGridInterface::GetFirst();
5402             if ( p ) DoSelectProperty(p);
5403             wasHandled = true;
5404         }
5405     }
5406
5407     if ( !wasHandled )
5408         event.Skip();
5409 }
5410
5411 // -----------------------------------------------------------------------
5412
5413 void wxPropertyGrid::OnKey( wxKeyEvent &event )
5414 {
5415     // If there was editor open and focused, then this event should not
5416     // really be processed here.
5417     if ( IsEditorFocused() )
5418     {
5419         // However, if event had modifiers, it is probably still best
5420         // to skip it.
5421         if ( event.HasModifiers() )
5422             event.Skip();
5423         else
5424             event.StopPropagation();
5425         return;
5426     }
5427
5428     HandleKeyEvent(event, false);
5429 }
5430
5431 // -----------------------------------------------------------------------
5432
5433 bool wxPropertyGrid::ButtonTriggerKeyTest( int action, wxKeyEvent& event )
5434 {
5435     if ( action == -1 )
5436     {
5437         int secondAction;
5438         action = KeyEventToActions(event, &secondAction);
5439     }
5440
5441     // Does the keycode trigger button?
5442     if ( action == wxPG_ACTION_PRESS_BUTTON &&
5443          m_wndEditor2 )
5444     {
5445         wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED, m_wndEditor2->GetId());
5446         GetEventHandler()->AddPendingEvent(evt);
5447         return true;
5448     }
5449
5450     return false;
5451 }
5452
5453 // -----------------------------------------------------------------------
5454
5455 void wxPropertyGrid::OnChildKeyDown( wxKeyEvent &event )
5456 {
5457     HandleKeyEvent(event, true);
5458 }
5459
5460 // -----------------------------------------------------------------------
5461 // wxPropertyGrid miscellaneous event handling
5462 // -----------------------------------------------------------------------
5463
5464 void wxPropertyGrid::OnIdle( wxIdleEvent& WXUNUSED(event) )
5465 {
5466     //
5467     // Check if the focus is in this control or one of its children
5468     wxWindow* newFocused = wxWindow::FindFocus();
5469
5470     if ( newFocused != m_curFocused )
5471         HandleFocusChange( newFocused );
5472
5473     //
5474     // Check if top-level parent has changed
5475     if ( GetExtraStyle() & wxPG_EX_ENABLE_TLP_TRACKING )
5476     {
5477         wxWindow* tlp = ::wxGetTopLevelParent(this);
5478         if ( tlp != m_tlp )
5479             OnTLPChanging(tlp);
5480     }
5481 }
5482
5483 bool wxPropertyGrid::IsEditorFocused() const
5484 {
5485     wxWindow* focus = wxWindow::FindFocus();
5486
5487     if ( focus == m_wndEditor || focus == m_wndEditor2 ||
5488          focus == GetEditorControl() )
5489          return true;
5490
5491     return false;
5492 }
5493
5494 // Called by focus event handlers. newFocused is the window that becomes focused.
5495 void wxPropertyGrid::HandleFocusChange( wxWindow* newFocused )
5496 {
5497     unsigned int oldFlags = m_iFlags;
5498
5499     m_iFlags &= ~(wxPG_FL_FOCUSED);
5500
5501     wxWindow* parent = newFocused;
5502
5503     // This must be one of nextFocus' parents.
5504     while ( parent )
5505     {
5506         // Use m_eventObject, which is either wxPropertyGrid or
5507         // wxPropertyGridManager, as appropriate.
5508         if ( parent == m_eventObject )
5509         {
5510             m_iFlags |= wxPG_FL_FOCUSED;
5511             break;
5512         }
5513         parent = parent->GetParent();
5514     }
5515
5516     m_curFocused = newFocused;
5517
5518     if ( (m_iFlags & wxPG_FL_FOCUSED) !=
5519          (oldFlags & wxPG_FL_FOCUSED) )
5520     {
5521         if ( !(m_iFlags & wxPG_FL_FOCUSED) )
5522         {
5523             // Need to store changed value
5524             CommitChangesFromEditor();
5525         }
5526         else
5527         {
5528             /*
5529             //
5530             // Preliminary code for tab-order respecting
5531             // tab-traversal (but should be moved to
5532             // OnNav handler)
5533             //
5534             wxWindow* prevFocus = event.GetWindow();
5535             wxWindow* useThis = this;
5536             if ( m_iFlags & wxPG_FL_IN_MANAGER )
5537                 useThis = GetParent();
5538
5539             if ( prevFocus &&
5540                  prevFocus->GetParent() == useThis->GetParent() )
5541             {
5542                 wxList& children = useThis->GetParent()->GetChildren();
5543
5544                 wxNode* node = children.Find(prevFocus);
5545
5546                 if ( node->GetNext() &&
5547                      useThis == node->GetNext()->GetData() )
5548                     DoSelectProperty(GetFirst());
5549                 else if ( node->GetPrevious () &&
5550                           useThis == node->GetPrevious()->GetData() )
5551                     DoSelectProperty(GetLastProperty());
5552
5553             }
5554             */
5555         }
5556
5557         // Redraw selected
5558         wxPGProperty* selected = GetSelection();
5559         if ( selected && (m_iFlags & wxPG_FL_INITIALIZED) )
5560             DrawItem( selected );
5561     }
5562 }
5563
5564 void wxPropertyGrid::OnFocusEvent( wxFocusEvent& event )
5565 {
5566     if ( event.GetEventType() == wxEVT_SET_FOCUS )
5567         HandleFocusChange((wxWindow*)event.GetEventObject());
5568     // Line changed to "else" when applying wxPropertyGrid patch #1675902
5569     //else if ( event.GetWindow() )
5570     else
5571         HandleFocusChange(event.GetWindow());
5572
5573     event.Skip();
5574 }
5575
5576 // -----------------------------------------------------------------------
5577
5578 void wxPropertyGrid::OnChildFocusEvent( wxChildFocusEvent& event )
5579 {
5580     HandleFocusChange((wxWindow*)event.GetEventObject());
5581     event.Skip();
5582 }
5583
5584 // -----------------------------------------------------------------------
5585
5586 void wxPropertyGrid::OnScrollEvent( wxScrollWinEvent &event )
5587 {
5588     m_iFlags |= wxPG_FL_SCROLLED;
5589
5590     event.Skip();
5591 }
5592
5593 // -----------------------------------------------------------------------
5594
5595 void wxPropertyGrid::OnCaptureChange( wxMouseCaptureChangedEvent& WXUNUSED(event) )
5596 {
5597     if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
5598     {
5599         m_iFlags &= ~(wxPG_FL_MOUSE_CAPTURED);
5600     }
5601 }
5602
5603 // -----------------------------------------------------------------------
5604 // Property editor related functions
5605 // -----------------------------------------------------------------------
5606
5607 // noDefCheck = true prevents infinite recursion.
5608 wxPGEditor* wxPropertyGrid::DoRegisterEditorClass( wxPGEditor* editorClass,
5609                                                    const wxString& editorName,
5610                                                    bool noDefCheck )
5611 {
5612     wxASSERT( editorClass );
5613
5614     if ( !noDefCheck && wxPGGlobalVars->m_mapEditorClasses.empty() )
5615         RegisterDefaultEditors();
5616
5617     wxString name = editorName;
5618     if ( name.length() == 0 )
5619         name = editorClass->GetName();
5620
5621     // Existing editor under this name?
5622     wxPGHashMapS2P::iterator vt_it = wxPGGlobalVars->m_mapEditorClasses.find(name);
5623
5624     if ( vt_it != wxPGGlobalVars->m_mapEditorClasses.end() )
5625     {
5626         // If this name was already used, try class name.
5627         name = editorClass->GetClassInfo()->GetClassName();
5628         vt_it = wxPGGlobalVars->m_mapEditorClasses.find(name);
5629     }
5630
5631     wxCHECK_MSG( vt_it == wxPGGlobalVars->m_mapEditorClasses.end(),
5632                  (wxPGEditor*) vt_it->second,
5633                  "Editor with given name was already registered" );
5634
5635     wxPGGlobalVars->m_mapEditorClasses[name] = (void*)editorClass;
5636
5637     return editorClass;
5638 }
5639
5640 // Use this in RegisterDefaultEditors.
5641 #define wxPGRegisterDefaultEditorClass(EDITOR) \
5642     if ( wxPGEditor_##EDITOR == NULL ) \
5643     { \
5644         wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
5645             new wxPG##EDITOR##Editor, true ); \
5646     }
5647
5648 // Registers all default editor classes
5649 void wxPropertyGrid::RegisterDefaultEditors()
5650 {
5651     wxPGRegisterDefaultEditorClass( TextCtrl );
5652     wxPGRegisterDefaultEditorClass( Choice );
5653     wxPGRegisterDefaultEditorClass( ComboBox );
5654     wxPGRegisterDefaultEditorClass( TextCtrlAndButton );
5655 #if wxPG_INCLUDE_CHECKBOX
5656     wxPGRegisterDefaultEditorClass( CheckBox );
5657 #endif
5658     wxPGRegisterDefaultEditorClass( ChoiceAndButton );
5659
5660     // Register SpinCtrl etc. editors before use
5661     RegisterAdditionalEditors();
5662 }
5663
5664 // -----------------------------------------------------------------------
5665 // wxPGStringTokenizer
5666 //   Needed to handle C-style string lists (e.g. "str1" "str2")
5667 // -----------------------------------------------------------------------
5668
5669 wxPGStringTokenizer::wxPGStringTokenizer( const wxString& str, wxChar delimeter )
5670     : m_str(&str), m_curPos(str.begin()), m_delimeter(delimeter)
5671 {
5672 }
5673
5674 wxPGStringTokenizer::~wxPGStringTokenizer()
5675 {
5676 }
5677
5678 bool wxPGStringTokenizer::HasMoreTokens()
5679 {
5680     const wxString& str = *m_str;
5681
5682     wxString::const_iterator i = m_curPos;
5683
5684     wxUniChar delim = m_delimeter;
5685     wxUniChar a;
5686     wxUniChar prev_a = wxT('\0');
5687
5688     bool inToken = false;
5689
5690     while ( i != str.end() )
5691     {
5692         a = *i;
5693
5694         if ( !inToken )
5695         {
5696             if ( a == delim )
5697             {
5698                 inToken = true;
5699                 m_readyToken.clear();
5700             }
5701         }
5702         else
5703         {
5704             if ( prev_a != wxT('\\') )
5705             {
5706                 if ( a != delim )
5707                 {
5708                     if ( a != wxT('\\') )
5709                         m_readyToken << a;
5710                 }
5711                 else
5712                 {
5713                     ++i;
5714                     m_curPos = i;
5715                     return true;
5716                 }
5717                 prev_a = a;
5718             }
5719             else
5720             {
5721                 m_readyToken << a;
5722                 prev_a = wxT('\0');
5723             }
5724         }
5725         ++i;
5726     }
5727
5728     m_curPos = str.end();
5729
5730     if ( inToken )
5731         return true;
5732
5733     return false;
5734 }
5735
5736 wxString wxPGStringTokenizer::GetNextToken()
5737 {
5738     return m_readyToken;
5739 }
5740
5741 // -----------------------------------------------------------------------
5742 // wxPGChoiceEntry
5743 // -----------------------------------------------------------------------
5744
5745 wxPGChoiceEntry::wxPGChoiceEntry()
5746     : wxPGCell(), m_value(wxPG_INVALID_VALUE)
5747 {
5748 }
5749
5750 // -----------------------------------------------------------------------
5751 // wxPGChoicesData
5752 // -----------------------------------------------------------------------
5753
5754 wxPGChoicesData::wxPGChoicesData()
5755 {
5756 }
5757
5758 wxPGChoicesData::~wxPGChoicesData()
5759 {
5760     Clear();
5761 }
5762
5763 void wxPGChoicesData::Clear()
5764 {
5765     m_items.clear();
5766 }
5767
5768 void wxPGChoicesData::CopyDataFrom( wxPGChoicesData* data )
5769 {
5770     wxASSERT( m_items.size() == 0 );
5771
5772     m_items = data->m_items;
5773 }
5774
5775 wxPGChoiceEntry& wxPGChoicesData::Insert( int index,
5776                                           const wxPGChoiceEntry& item )
5777 {
5778     wxVector<wxPGChoiceEntry>::iterator it;
5779     if ( index == -1 )
5780     {
5781         it = m_items.end();
5782         index = (int) m_items.size();
5783     }
5784     else
5785     {
5786         it = m_items.begin() + index;
5787     }
5788
5789     m_items.insert(it, item);
5790
5791     wxPGChoiceEntry& ownEntry = m_items[index];
5792
5793     // Need to fix value?
5794     if ( ownEntry.GetValue() == wxPG_INVALID_VALUE )
5795         ownEntry.SetValue(index);
5796
5797     return ownEntry;
5798 }
5799
5800 // -----------------------------------------------------------------------
5801 // wxPropertyGridEvent
5802 // -----------------------------------------------------------------------
5803
5804 IMPLEMENT_DYNAMIC_CLASS(wxPropertyGridEvent, wxCommandEvent)
5805
5806
5807 wxDEFINE_EVENT( wxEVT_PG_SELECTED, wxPropertyGridEvent );
5808 wxDEFINE_EVENT( wxEVT_PG_CHANGING, wxPropertyGridEvent );
5809 wxDEFINE_EVENT( wxEVT_PG_CHANGED, wxPropertyGridEvent );
5810 wxDEFINE_EVENT( wxEVT_PG_HIGHLIGHTED, wxPropertyGridEvent );
5811 wxDEFINE_EVENT( wxEVT_PG_RIGHT_CLICK, wxPropertyGridEvent );
5812 wxDEFINE_EVENT( wxEVT_PG_PAGE_CHANGED, wxPropertyGridEvent );
5813 wxDEFINE_EVENT( wxEVT_PG_ITEM_EXPANDED, wxPropertyGridEvent );
5814 wxDEFINE_EVENT( wxEVT_PG_ITEM_COLLAPSED, wxPropertyGridEvent );
5815 wxDEFINE_EVENT( wxEVT_PG_DOUBLE_CLICK, wxPropertyGridEvent );
5816 wxDEFINE_EVENT( wxEVT_PG_LABEL_EDIT_BEGIN, wxPropertyGridEvent );
5817 wxDEFINE_EVENT( wxEVT_PG_LABEL_EDIT_ENDING, wxPropertyGridEvent );
5818 wxDEFINE_EVENT( wxEVT_PG_COL_BEGIN_DRAG, wxPropertyGridEvent );
5819 wxDEFINE_EVENT( wxEVT_PG_COL_DRAGGING, wxPropertyGridEvent );
5820 wxDEFINE_EVENT( wxEVT_PG_COL_END_DRAG, wxPropertyGridEvent );
5821
5822 // -----------------------------------------------------------------------
5823
5824 void wxPropertyGridEvent::Init()
5825 {
5826     m_validationInfo = NULL;
5827     m_column = 1;
5828     m_canVeto = false;
5829     m_wasVetoed = false;
5830 }
5831
5832 // -----------------------------------------------------------------------
5833
5834 wxPropertyGridEvent::wxPropertyGridEvent(wxEventType commandType, int id)
5835     : wxCommandEvent(commandType,id)
5836 {
5837     m_property = NULL;
5838     Init();
5839 }
5840
5841 // -----------------------------------------------------------------------
5842
5843 wxPropertyGridEvent::wxPropertyGridEvent(const wxPropertyGridEvent& event)
5844     : wxCommandEvent(event)
5845 {
5846     m_eventType = event.GetEventType();
5847     m_eventObject = event.m_eventObject;
5848     m_pg = event.m_pg;
5849     OnPropertyGridSet();
5850     m_property = event.m_property;
5851     m_validationInfo = event.m_validationInfo;
5852     m_canVeto = event.m_canVeto;
5853     m_wasVetoed = event.m_wasVetoed;
5854 }
5855
5856 // -----------------------------------------------------------------------
5857
5858 void wxPropertyGridEvent::OnPropertyGridSet()
5859 {
5860     if ( !m_pg )
5861         return;
5862
5863 #if wxUSE_THREADS
5864     wxCriticalSectionLocker(wxPGGlobalVars->m_critSect);
5865 #endif
5866     m_pg->m_liveEvents.push_back(this);
5867 }
5868
5869 // -----------------------------------------------------------------------
5870
5871 wxPropertyGridEvent::~wxPropertyGridEvent()
5872 {
5873     if ( m_pg )
5874     {
5875     #if wxUSE_THREADS
5876         wxCriticalSectionLocker(wxPGGlobalVars->m_critSect);
5877     #endif
5878
5879         // Use iterate from the back since it is more likely that the event
5880         // being desroyed is at the end of the array.
5881         wxVector<wxPropertyGridEvent*>& liveEvents = m_pg->m_liveEvents;
5882
5883         for ( int i = liveEvents.size()-1; i >= 0; i-- )
5884         {
5885             if ( liveEvents[i] == this )
5886             {
5887                 liveEvents.erase(liveEvents.begin() + i);
5888                 break;
5889             }
5890         }
5891     }
5892 }
5893
5894 // -----------------------------------------------------------------------
5895
5896 wxEvent* wxPropertyGridEvent::Clone() const
5897 {
5898     return new wxPropertyGridEvent( *this );
5899 }
5900
5901 // -----------------------------------------------------------------------
5902 // wxPropertyGridPopulator
5903 // -----------------------------------------------------------------------
5904
5905 wxPropertyGridPopulator::wxPropertyGridPopulator()
5906 {
5907     m_state = NULL;
5908     m_pg = NULL;
5909     wxPGGlobalVars->m_offline++;
5910 }
5911
5912 // -----------------------------------------------------------------------
5913
5914 void wxPropertyGridPopulator::SetState( wxPropertyGridPageState* state )
5915 {
5916     m_state = state;
5917     m_propHierarchy.clear();
5918 }
5919
5920 // -----------------------------------------------------------------------
5921
5922 void wxPropertyGridPopulator::SetGrid( wxPropertyGrid* pg )
5923 {
5924     m_pg = pg;
5925     pg->Freeze();
5926 }
5927
5928 // -----------------------------------------------------------------------
5929
5930 wxPropertyGridPopulator::~wxPropertyGridPopulator()
5931 {
5932     //
5933     // Free unused sets of choices
5934     wxPGHashMapS2P::iterator it;
5935
5936     for( it = m_dictIdChoices.begin(); it != m_dictIdChoices.end(); ++it )
5937     {
5938         wxPGChoicesData* data = (wxPGChoicesData*) it->second;
5939         data->DecRef();
5940     }
5941
5942     if ( m_pg )
5943     {
5944         m_pg->Thaw();
5945         m_pg->GetPanel()->Refresh();
5946     }
5947     wxPGGlobalVars->m_offline--;
5948 }
5949
5950 // -----------------------------------------------------------------------
5951
5952 wxPGProperty* wxPropertyGridPopulator::Add( const wxString& propClass,
5953                                             const wxString& propLabel,
5954                                             const wxString& propName,
5955                                             const wxString* propValue,
5956                                             wxPGChoices* pChoices )
5957 {
5958     wxClassInfo* classInfo = wxClassInfo::FindClass(propClass);
5959     wxPGProperty* parent = GetCurParent();
5960
5961     if ( parent->HasFlag(wxPG_PROP_AGGREGATE) )
5962     {
5963         ProcessError(wxString::Format(wxT("new children cannot be added to '%s'"),parent->GetName().c_str()));
5964         return NULL;
5965     }
5966
5967     if ( !classInfo || !classInfo->IsKindOf(CLASSINFO(wxPGProperty)) )
5968     {
5969         ProcessError(wxString::Format(wxT("'%s' is not valid property class"),propClass.c_str()));
5970         return NULL;
5971     }
5972
5973     wxPGProperty* property = (wxPGProperty*) classInfo->CreateObject();
5974
5975     property->SetLabel(propLabel);
5976     property->DoSetName(propName);
5977
5978     if ( pChoices && pChoices->IsOk() )
5979         property->SetChoices(*pChoices);
5980
5981     m_state->DoInsert(parent, -1, property);
5982
5983     if ( propValue )
5984         property->SetValueFromString( *propValue, wxPG_FULL_VALUE|
5985                                                   wxPG_PROGRAMMATIC_VALUE );
5986
5987     return property;
5988 }
5989
5990 // -----------------------------------------------------------------------
5991
5992 void wxPropertyGridPopulator::AddChildren( wxPGProperty* property )
5993 {
5994     m_propHierarchy.push_back(property);
5995     DoScanForChildren();
5996     m_propHierarchy.pop_back();
5997 }
5998
5999 // -----------------------------------------------------------------------
6000
6001 wxPGChoices wxPropertyGridPopulator::ParseChoices( const wxString& choicesString,
6002                                                    const wxString& idString )
6003 {
6004     wxPGChoices choices;
6005
6006     // Using id?
6007     if ( choicesString[0] == wxT('@') )
6008     {
6009         wxString ids = choicesString.substr(1);
6010         wxPGHashMapS2P::iterator it = m_dictIdChoices.find(ids);
6011         if ( it == m_dictIdChoices.end() )
6012             ProcessError(wxString::Format(wxT("No choices defined for id '%s'"),ids.c_str()));
6013         else
6014             choices.AssignData((wxPGChoicesData*)it->second);
6015     }
6016     else
6017     {
6018         bool found = false;
6019         if ( idString.length() )
6020         {
6021             wxPGHashMapS2P::iterator it = m_dictIdChoices.find(idString);
6022             if ( it != m_dictIdChoices.end() )
6023             {
6024                 choices.AssignData((wxPGChoicesData*)it->second);
6025                 found = true;
6026             }
6027         }
6028
6029         if ( !found )
6030         {
6031             // Parse choices string
6032             wxString::const_iterator it = choicesString.begin();
6033             wxString label;
6034             wxString value;
6035             int state = 0;
6036             bool labelValid = false;
6037
6038             for ( ; it != choicesString.end(); ++it )
6039             {
6040                 wxChar c = *it;
6041
6042                 if ( state != 1 )
6043                 {
6044                     if ( c == wxT('"') )
6045                     {
6046                         if ( labelValid )
6047                         {
6048                             long l;
6049                             if ( !value.ToLong(&l, 0) ) l = wxPG_INVALID_VALUE;
6050                             choices.Add(label, l);
6051                         }
6052                         labelValid = false;
6053                         //wxLogDebug(wxT("%s, %s"),label.c_str(),value.c_str());
6054                         value.clear();
6055                         label.clear();
6056                         state = 1;
6057                     }
6058                     else if ( c == wxT('=') )
6059                     {
6060                         if ( labelValid )
6061                         {
6062                             state = 2;
6063                         }
6064                     }
6065                     else if ( state == 2 && (wxIsalnum(c) || c == wxT('x')) )
6066                     {
6067                         value << c;
6068                     }
6069                 }
6070                 else
6071                 {
6072                     if ( c == wxT('"') )
6073                     {
6074                         state = 0;
6075                         labelValid = true;
6076                     }
6077                     else
6078                         label << c;
6079                 }
6080             }
6081
6082             if ( labelValid )
6083             {
6084                 long l;
6085                 if ( !value.ToLong(&l, 0) ) l = wxPG_INVALID_VALUE;
6086                 choices.Add(label, l);
6087             }
6088
6089             if ( !choices.IsOk() )
6090             {
6091                 choices.EnsureData();
6092             }
6093
6094             // Assign to id
6095             if ( idString.length() )
6096                 m_dictIdChoices[idString] = choices.GetData();
6097         }
6098     }
6099
6100     return choices;
6101 }
6102
6103 // -----------------------------------------------------------------------
6104
6105 bool wxPropertyGridPopulator::ToLongPCT( const wxString& s, long* pval, long max )
6106 {
6107     if ( s.Last() == wxT('%') )
6108     {
6109         wxString s2 = s.substr(0,s.length()-1);
6110         long val;
6111         if ( s2.ToLong(&val, 10) )
6112         {
6113             *pval = (val*max)/100;
6114             return true;
6115         }
6116         return false;
6117     }
6118
6119     return s.ToLong(pval, 10);
6120 }
6121
6122 // -----------------------------------------------------------------------
6123
6124 bool wxPropertyGridPopulator::AddAttribute( const wxString& name,
6125                                             const wxString& type,
6126                                             const wxString& value )
6127 {
6128     int l = m_propHierarchy.size();
6129     if ( !l )
6130         return false;
6131
6132     wxPGProperty* p = m_propHierarchy[l-1];
6133     wxString valuel = value.Lower();
6134     wxVariant variant;
6135
6136     if ( type.length() == 0 )
6137     {
6138         long v;
6139
6140         // Auto-detect type
6141         if ( valuel == wxT("true") || valuel == wxT("yes") || valuel == wxT("1") )
6142             variant = true;
6143         else if ( valuel == wxT("false") || valuel == wxT("no") || valuel == wxT("0") )
6144             variant = false;
6145         else if ( value.ToLong(&v, 0) )
6146             variant = v;
6147         else
6148             variant = value;
6149     }
6150     else
6151     {
6152         if ( type == wxT("string") )
6153         {
6154             variant = value;
6155         }
6156         else if ( type == wxT("int") )
6157         {
6158             long v = 0;
6159             value.ToLong(&v, 0);
6160             variant = v;
6161         }
6162         else if ( type == wxT("bool") )
6163         {
6164             if ( valuel == wxT("true") || valuel == wxT("yes") || valuel == wxT("1") )
6165                 variant = true;
6166             else
6167                 variant = false;
6168         }
6169         else
6170         {
6171             ProcessError(wxString::Format(wxT("Invalid attribute type '%s'"),type.c_str()));
6172             return false;
6173         }
6174     }
6175
6176     p->SetAttribute( name, variant );
6177
6178     return true;
6179 }
6180
6181 // -----------------------------------------------------------------------
6182
6183 void wxPropertyGridPopulator::ProcessError( const wxString& msg )
6184 {
6185     wxLogError(_("Error in resource: %s"),msg.c_str());
6186 }
6187
6188 // -----------------------------------------------------------------------
6189
6190 #endif  // wxUSE_PROPGRID