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