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