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