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