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