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