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