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