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