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