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