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