src/propgrid/propgrid.cpp

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