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