]> git.saurik.com Git - wxWidgets.git/blob - src/propgrid/propgrid.cpp
projects / wxWidgets.git / blob
? search:


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