]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/propgrid/advprops.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix recreating of wxBitmapComboBox using untyped client data.
[wxWidgets.git] / src / propgrid / advprops.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/propgrid/advprops.cpp
3// Purpose: wxPropertyGrid Advanced Properties (font, colour, etc.)
4// Author: Jaakko Salli
5// Modified by:
6// Created: 2004-09-25
7// Copyright: (c) Jaakko Salli
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx/wx.h".
12#include "wx/wxprec.h"
13
14#ifdef __BORLANDC__
15 #pragma hdrstop
16#endif
17
18#if wxUSE_PROPGRID
19
20#ifndef WX_PRECOMP
21 #include "wx/defs.h"
22 #include "wx/object.h"
23 #include "wx/hash.h"
24 #include "wx/string.h"
25 #include "wx/log.h"
26 #include "wx/event.h"
27 #include "wx/window.h"
28 #include "wx/panel.h"
29 #include "wx/dc.h"
30 #include "wx/dcclient.h"
31 #include "wx/button.h"
32 #include "wx/pen.h"
33 #include "wx/brush.h"
34 #include "wx/cursor.h"
35 #include "wx/dialog.h"
36 #include "wx/settings.h"
37 #include "wx/msgdlg.h"
38 #include "wx/choice.h"
39 #include "wx/stattext.h"
40 #include "wx/textctrl.h"
41 #include "wx/scrolwin.h"
42 #include "wx/dirdlg.h"
43 #include "wx/combobox.h"
44 #include "wx/sizer.h"
45 #include "wx/textdlg.h"
46 #include "wx/filedlg.h"
47 #include "wx/intl.h"
48 #include "wx/wxcrtvararg.h"
49#endif
50
51#define __wxPG_SOURCE_FILE__
52
53#include "wx/propgrid/propgrid.h"
54
55#if wxPG_INCLUDE_ADVPROPS
56
57#include "wx/propgrid/advprops.h"
58
59#ifdef __WXMSW__
60 #include "wx/msw/private.h"
61 #include "wx/msw/dc.h"
62#endif
63
64#include "wx/odcombo.h"
65
66// -----------------------------------------------------------------------
67
68#if defined(__WXMSW__)
69 #define wxPG_CAN_DRAW_CURSOR 1
70#elif defined(__WXGTK__)
71 #define wxPG_CAN_DRAW_CURSOR 0
72#elif defined(__WXMAC__)
73 #define wxPG_CAN_DRAW_CURSOR 0
74#else
75 #define wxPG_CAN_DRAW_CURSOR 0
76#endif
77
78
79// -----------------------------------------------------------------------
80// Value type related
81// -----------------------------------------------------------------------
82
83
84// Implement dynamic class for type value.
85IMPLEMENT_DYNAMIC_CLASS(wxColourPropertyValue, wxObject)
86
87bool operator == (const wxColourPropertyValue& a, const wxColourPropertyValue& b)
88{
89 return ( ( a.m_colour == b.m_colour ) && (a.m_type == b.m_type) );
90}
91
92bool operator == (const wxArrayInt& array1, const wxArrayInt& array2)
93{
94 if ( array1.size() != array2.size() )
95 return false;
96 size_t i;
97 for ( i=0; i<array1.size(); i++ )
98 {
99 if ( array1[i] != array2[i] )
100 return false;
101 }
102 return true;
103}
104
105// -----------------------------------------------------------------------
106// wxSpinCtrl-based property editor
107// -----------------------------------------------------------------------
108
109#if wxUSE_SPINBTN
110
111
112#ifdef __WXMSW__
113 #define IS_MOTION_SPIN_SUPPORTED 1
114#else
115 #define IS_MOTION_SPIN_SUPPORTED 0
116#endif
117
118#if IS_MOTION_SPIN_SUPPORTED
119
120//
121// This class implements ability to rapidly change "spin" value
122// by moving mouse when one of the spin buttons is depressed.
123class wxPGSpinButton : public wxSpinButton
124{
125public:
126 wxPGSpinButton() : wxSpinButton()
127 {
128 m_bLeftDown = false;
129 m_hasCapture = false;
130 m_spins = 1;
131
132 Connect( wxEVT_LEFT_DOWN,
133 wxMouseEventHandler(wxPGSpinButton::OnMouseEvent) );
134 Connect( wxEVT_LEFT_UP,
135 wxMouseEventHandler(wxPGSpinButton::OnMouseEvent) );
136 Connect( wxEVT_MOTION,
137 wxMouseEventHandler(wxPGSpinButton::OnMouseEvent) );
138 Connect( wxEVT_MOUSE_CAPTURE_LOST,
139 wxMouseCaptureLostEventHandler(wxPGSpinButton::OnMouseCaptureLost) );
140 }
141
142 int GetSpins() const
143 {
144 return m_spins;
145 }
146
147private:
148 wxPoint m_ptPosition;
149
150 // Having a separate spins variable allows us to handle validation etc. for
151 // multiple spin events at once (with quick mouse movements there could be
152 // hundreds of 'spins' being done at once). Technically things like this
153 // should be stored in event (wxSpinEvent in this case), but there probably
154 // isn't anything there that can be reliably reused.
155 int m_spins;
156
157 bool m_bLeftDown;
158
159 // SpinButton seems to be a special for mouse capture, so we may need track
160 // privately whether mouse is actually captured.
161 bool m_hasCapture;
162
163 void Capture()
164 {
165 if ( !m_hasCapture )
166 {
167 CaptureMouse();
168 m_hasCapture = true;
169 }
170
171 SetCursor(wxCURSOR_SIZENS);
172 }
173 void Release()
174 {
175 m_bLeftDown = false;
176
177 if ( m_hasCapture )
178 {
179 ReleaseMouse();
180 m_hasCapture = false;
181 }
182
183 wxWindow *parent = GetParent();
184 if ( parent )
185 SetCursor(parent->GetCursor());
186 else
187 SetCursor(wxNullCursor);
188 }
189
190 void OnMouseEvent(wxMouseEvent& event)
191 {
192 if ( event.GetEventType() == wxEVT_LEFT_DOWN )
193 {
194 m_bLeftDown = true;
195 m_ptPosition = event.GetPosition();
196 }
197 else if ( event.GetEventType() == wxEVT_LEFT_UP )
198 {
199 Release();
200 m_bLeftDown = false;
201 }
202 else if ( event.GetEventType() == wxEVT_MOTION )
203 {
204 if ( m_bLeftDown )
205 {
206 int dy = m_ptPosition.y - event.GetPosition().y;
207 if ( dy )
208 {
209 Capture();
210 m_ptPosition = event.GetPosition();
211
212 wxSpinEvent evtscroll( (dy >= 0) ? wxEVT_SCROLL_LINEUP :
213 wxEVT_SCROLL_LINEDOWN,
214 GetId() );
215 evtscroll.SetEventObject(this);
216
217 wxASSERT( m_spins == 1 );
218
219 m_spins = abs(dy);
220 GetEventHandler()->ProcessEvent(evtscroll);
221 m_spins = 1;
222 }
223 }
224 }
225
226 event.Skip();
227 }
228 void OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
229 {
230 Release();
231 }
232};
233
234#endif // IS_MOTION_SPIN_SUPPORTED
235
236
237WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(SpinCtrl,
238 wxPGSpinCtrlEditor,
239 wxPGEditor)
240
241
242// Destructor. It is useful to reset the global pointer in it.
243wxPGSpinCtrlEditor::~wxPGSpinCtrlEditor()
244{
245 wxPG_EDITOR(SpinCtrl) = NULL;
246}
247
248// Create controls and initialize event handling.
249wxPGWindowList wxPGSpinCtrlEditor::CreateControls( wxPropertyGrid* propgrid, wxPGProperty* property,
250 const wxPoint& pos, const wxSize& sz ) const
251{
252 const int margin = 1;
253 wxSize butSz(18, sz.y);
254 wxSize tcSz(sz.x - butSz.x - margin, sz.y);
255 wxPoint butPos(pos.x + tcSz.x + margin, pos.y);
256
257 wxSpinButton* wnd2;
258
259#if IS_MOTION_SPIN_SUPPORTED
260 if ( property->GetAttributeAsLong(wxT("MotionSpin"), 0) )
261 {
262 wnd2 = new wxPGSpinButton();
263 }
264 else
265#endif
266 {
267 wnd2 = new wxSpinButton();
268 }
269
270#ifdef __WXMSW__
271 wnd2->Hide();
272#endif
273 wnd2->Create( propgrid->GetPanel(), wxPG_SUBID2, butPos, butSz, wxSP_VERTICAL );
274
275 wnd2->SetRange( INT_MIN, INT_MAX );
276 wnd2->SetValue( 0 );
277
278 wxWindow* wnd1 = wxPGTextCtrlEditor::CreateControls(propgrid, property, pos, tcSz).m_primary;
279#if wxUSE_VALIDATORS
280 // Let's add validator to make sure only numbers can be entered
281 wxTextValidator validator(wxFILTER_NUMERIC, &m_tempString);
282 wnd1->SetValidator(validator);
283#endif
284
285 return wxPGWindowList(wnd1, wnd2);
286}
287
288// Control's events are redirected here
289bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
290 wxWindow* wnd, wxEvent& event ) const
291{
292 int evtType = event.GetEventType();
293 int keycode = -1;
294 int spins = 1;
295 bool bigStep = false;
296
297 if ( evtType == wxEVT_KEY_DOWN )
298 {
299 wxKeyEvent& keyEvent = (wxKeyEvent&)event;
300 keycode = keyEvent.GetKeyCode();
301
302 if ( keycode == WXK_UP )
303 evtType = wxEVT_SCROLL_LINEUP;
304 else if ( keycode == WXK_DOWN )
305 evtType = wxEVT_SCROLL_LINEDOWN;
306 else if ( keycode == WXK_PAGEUP )
307 {
308 evtType = wxEVT_SCROLL_LINEUP;
309 bigStep = true;
310 }
311 else if ( keycode == WXK_PAGEDOWN )
312 {
313 evtType = wxEVT_SCROLL_LINEDOWN;
314 bigStep = true;
315 }
316 }
317
318 if ( evtType == wxEVT_SCROLL_LINEUP || evtType == wxEVT_SCROLL_LINEDOWN )
319 {
320 #if IS_MOTION_SPIN_SUPPORTED
321 if ( property->GetAttributeAsLong(wxT("MotionSpin"), 0) )
322 {
323 wxPGSpinButton* spinButton =
324 (wxPGSpinButton*) propgrid->GetEditorControlSecondary();
325
326 if ( spinButton )
327 spins = spinButton->GetSpins();
328 }
329 #endif
330
331 wxString s;
332 // Can't use wnd since it might be clipper window
333 wxTextCtrl* tc = wxDynamicCast(propgrid->GetEditorControl(), wxTextCtrl);
334
335 if ( tc )
336 s = tc->GetValue();
337 else
338 s = property->GetValueAsString(wxPG_FULL_VALUE);
339
340 int mode = wxPG_PROPERTY_VALIDATION_SATURATE;
341
342 if ( property->GetAttributeAsLong(wxT("Wrap"), 0) )
343 mode = wxPG_PROPERTY_VALIDATION_WRAP;
344
345 if ( property->GetValueType() == wxT("double") )
346 {
347 double v_d;
348 double step = property->GetAttributeAsDouble(wxT("Step"), 1.0);
349
350 // Try double
351 if ( s.ToDouble(&v_d) )
352 {
353 if ( bigStep )
354 step *= 10.0;
355
356 step *= (double) spins;
357
358 if ( evtType == wxEVT_SCROLL_LINEUP ) v_d += step;
359 else v_d -= step;
360
361 // Min/Max check
362 wxFloatProperty::DoValidation(property, v_d, NULL, mode);
363
364 wxPropertyGrid::DoubleToString(s, v_d, 6, true, NULL);
365 }
366 else
367 {
368 return false;
369 }
370 }
371 else
372 {
373 wxLongLong_t v_ll;
374 wxLongLong_t step = property->GetAttributeAsLong(wxT("Step"), 1);
375
376 // Try (long) long
377 if ( s.ToLongLong(&v_ll, 10) )
378 {
379 if ( bigStep )
380 step *= 10;
381
382 step *= spins;
383
384 if ( evtType == wxEVT_SCROLL_LINEUP ) v_ll += step;
385 else v_ll -= step;
386
387 // Min/Max check
388 wxIntProperty::DoValidation(property, v_ll, NULL, mode);
389
390 s = wxLongLong(v_ll).ToString();
391 }
392 else
393 {
394 return false;
395 }
396 }
397
398 if ( tc )
399 {
400 int ip = tc->GetInsertionPoint();
401 int lp = tc->GetLastPosition();
402 tc->SetValue(s);
403 tc->SetInsertionPoint(ip+(tc->GetLastPosition()-lp));
404 }
405
406 return true;
407 }
408
409 return wxPGTextCtrlEditor::OnEvent(propgrid,property,wnd,event);
410}
411
412#endif // wxUSE_SPINBTN
413
414
415// -----------------------------------------------------------------------
416// wxDatePickerCtrl-based property editor
417// -----------------------------------------------------------------------
418
419#if wxUSE_DATEPICKCTRL
420
421
422#include "wx/datectrl.h"
423#include "wx/dateevt.h"
424
425class wxPGDatePickerCtrlEditor : public wxPGEditor
426{
427 DECLARE_DYNAMIC_CLASS(wxPGDatePickerCtrlEditor)
428public:
429 virtual ~wxPGDatePickerCtrlEditor();
430
431 wxString GetName() const;
432 virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
433 wxPGProperty* property,
434 const wxPoint& pos,
435 const wxSize& size) const;
436 virtual void UpdateControl( wxPGProperty* property, wxWindow* wnd ) const;
437 virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
438 wxWindow* wnd, wxEvent& event ) const;
439 virtual bool GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* wnd ) const;
440 virtual void SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* wnd ) const;
441};
442
443
444WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(DatePickerCtrl,
445 wxPGDatePickerCtrlEditor,
446 wxPGEditor)
447
448
449wxPGDatePickerCtrlEditor::~wxPGDatePickerCtrlEditor()
450{
451 wxPG_EDITOR(DatePickerCtrl) = NULL;
452}
453
454wxPGWindowList wxPGDatePickerCtrlEditor::CreateControls( wxPropertyGrid* propgrid,
455 wxPGProperty* property,
456 const wxPoint& pos,
457 const wxSize& sz ) const
458{
459 wxCHECK_MSG( wxDynamicCast(property, wxDateProperty),
460 NULL,
461 wxT("DatePickerCtrl editor can only be used with wxDateProperty or derivative.") );
462
463 wxDateProperty* prop = wxDynamicCast(property, wxDateProperty);
464
465 // Use two stage creation to allow cleaner display on wxMSW
466 wxDatePickerCtrl* ctrl = new wxDatePickerCtrl();
467#ifdef __WXMSW__
468 ctrl->Hide();
469 wxSize useSz = wxDefaultSize;
470 useSz.x = sz.x;
471#else
472 wxSize useSz = sz;
473#endif
474
475 wxDateTime dateValue(wxInvalidDateTime);
476
477 wxVariant value = prop->GetValue();
478 if ( value.GetType() == wxT("datetime") )
479 dateValue = value.GetDateTime();
480
481 ctrl->Create(propgrid->GetPanel(),
482 wxPG_SUBID1,
483 dateValue,
484 pos,
485 useSz,
486 prop->GetDatePickerStyle() | wxNO_BORDER);
487
488#ifdef __WXMSW__
489 ctrl->Show();
490#endif
491
492 return ctrl;
493}
494
495// Copies value from property to control
496void wxPGDatePickerCtrlEditor::UpdateControl( wxPGProperty* property,
497 wxWindow* wnd ) const
498{
499 wxDatePickerCtrl* ctrl = (wxDatePickerCtrl*) wnd;
500 wxASSERT( wxDynamicCast(ctrl, wxDatePickerCtrl) );
501
502 wxDateTime dateValue(wxInvalidDateTime);
503 wxVariant v(property->GetValue());
504 if ( v.GetType() == wxT("datetime") )
505 dateValue = v.GetDateTime();
506
507 ctrl->SetValue( dateValue );
508}
509
510// Control's events are redirected here
511bool wxPGDatePickerCtrlEditor::OnEvent( wxPropertyGrid* WXUNUSED(propgrid),
512 wxPGProperty* WXUNUSED(property),
513 wxWindow* WXUNUSED(wnd),
514 wxEvent& event ) const
515{
516 if ( event.GetEventType() == wxEVT_DATE_CHANGED )
517 return true;
518
519 return false;
520}
521
522bool wxPGDatePickerCtrlEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* WXUNUSED(property), wxWindow* wnd ) const
523{
524 wxDatePickerCtrl* ctrl = (wxDatePickerCtrl*) wnd;
525 wxASSERT( wxDynamicCast(ctrl, wxDatePickerCtrl) );
526
527 variant = ctrl->GetValue();
528
529 return true;
530}
531
532void wxPGDatePickerCtrlEditor::SetValueToUnspecified( wxPGProperty* property,
533 wxWindow* wnd ) const
534{
535 wxDatePickerCtrl* ctrl = (wxDatePickerCtrl*) wnd;
536 wxASSERT( wxDynamicCast(ctrl, wxDatePickerCtrl) );
537
538 wxDateProperty* prop = wxDynamicCast(property, wxDateProperty);
539
540 if ( prop )
541 {
542 int datePickerStyle = prop->GetDatePickerStyle();
543 if ( datePickerStyle & wxDP_ALLOWNONE )
544 ctrl->SetValue(wxInvalidDateTime);
545 }
546}
547
548#endif // wxUSE_DATEPICKCTRL
549
550
551// -----------------------------------------------------------------------
552// wxFontProperty
553// -----------------------------------------------------------------------
554
555#include "wx/fontdlg.h"
556#include "wx/fontenum.h"
557
558//
559// NB: Do not use wxS here since unlike wxT it doesn't translate to wxChar*
560//
561
562static const wxChar* const gs_fp_es_family_labels[] = {
563 wxT("Default"), wxT("Decorative"),
564 wxT("Roman"), wxT("Script"),
565 wxT("Swiss"), wxT("Modern"),
566 wxT("Teletype"), wxT("Unknown"),
567 (const wxChar*) NULL
568};
569
570static const long gs_fp_es_family_values[] = {
571 wxFONTFAMILY_DEFAULT, wxFONTFAMILY_DECORATIVE,
572 wxFONTFAMILY_ROMAN, wxFONTFAMILY_SCRIPT,
573 wxFONTFAMILY_SWISS, wxFONTFAMILY_MODERN,
574 wxFONTFAMILY_TELETYPE, wxFONTFAMILY_UNKNOWN
575};
576
577static const wxChar* const gs_fp_es_style_labels[] = {
578 wxT("Normal"),
579 wxT("Slant"),
580 wxT("Italic"),
581 (const wxChar*) NULL
582};
583
584static const long gs_fp_es_style_values[] = {
585 wxNORMAL,
586 wxSLANT,
587 wxITALIC
588};
589
590static const wxChar* const gs_fp_es_weight_labels[] = {
591 wxT("Normal"),
592 wxT("Light"),
593 wxT("Bold"),
594 (const wxChar*) NULL
595};
596
597static const long gs_fp_es_weight_values[] = {
598 wxNORMAL,
599 wxLIGHT,
600 wxBOLD
601};
602
603// Class body is in advprops.h
604
605
606WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFontProperty,wxPGProperty,
607 wxFont,const wxFont&,TextCtrlAndButton)
608
609
610wxFontProperty::wxFontProperty( const wxString& label, const wxString& name,
611 const wxFont& value )
612 : wxPGProperty(label,name)
613{
614 SetValue(WXVARIANT(value));
615
616 // Initialize font family choices list
617 if ( !wxPGGlobalVars->m_fontFamilyChoices )
618 {
619 wxArrayString faceNames = wxFontEnumerator::GetFacenames();
620
621 faceNames.Sort();
622
623 wxPGGlobalVars->m_fontFamilyChoices = new wxPGChoices(faceNames);
624 }
625
626 wxString emptyString(wxEmptyString);
627
628 wxFont font;
629 font << m_value;
630
631 AddPrivateChild( new wxIntProperty( _("Point Size"),
632 wxS("Point Size"),(long)font.GetPointSize() ) );
633
634 wxString faceName = font.GetFaceName();
635 // If font was not in there, add it now
636 if ( !faceName.empty() &&
637 wxPGGlobalVars->m_fontFamilyChoices->Index(faceName) == wxNOT_FOUND )
638 wxPGGlobalVars->m_fontFamilyChoices->AddAsSorted(faceName);
639
640 wxPGProperty* p = new wxEnumProperty(_("Face Name"), wxS("Face Name"),
641 *wxPGGlobalVars->m_fontFamilyChoices);
642
643 p->SetValueFromString(faceName, wxPG_FULL_VALUE);
644
645 AddPrivateChild( p );
646
647 AddPrivateChild( new wxEnumProperty(_("Style"), wxS("Style"),
648 gs_fp_es_style_labels,gs_fp_es_style_values,
649 font.GetStyle()) );
650
651 AddPrivateChild( new wxEnumProperty(_("Weight"), wxS("Weight"),
652 gs_fp_es_weight_labels,gs_fp_es_weight_values,
653 font.GetWeight()) );
654
655 AddPrivateChild( new wxBoolProperty(_("Underlined"), wxS("Underlined"),
656 font.GetUnderlined()) );
657
658 AddPrivateChild( new wxEnumProperty(_("Family"), wxS("PointSize"),
659 gs_fp_es_family_labels,gs_fp_es_family_values,
660 font.GetFamily()) );
661}
662
663wxFontProperty::~wxFontProperty() { }
664
665void wxFontProperty::OnSetValue()
666{
667 wxFont font;
668 font << m_value;
669
670 if ( !font.IsOk() )
671 {
672 m_value << *wxNORMAL_FONT;
673 }
674}
675
676wxString wxFontProperty::ValueToString( wxVariant& value,
677 int argFlags ) const
678{
679 return wxPGProperty::ValueToString(value, argFlags);
680}
681
682bool wxFontProperty::OnEvent( wxPropertyGrid* propgrid, wxWindow* WXUNUSED(primary),
683 wxEvent& event )
684{
685 if ( propgrid->IsMainButtonEvent(event) )
686 {
687 // Update value from last minute changes
688 wxVariant useValue = propgrid->GetUncommittedPropertyValue();
689
690 wxFontData data;
691 wxFont font;
692
693 if ( useValue.GetType() == wxS("wxFont") )
694 font << useValue;
695
696 data.SetInitialFont( font );
697 data.SetColour(*wxBLACK);
698
699 wxFontDialog dlg(propgrid, data);
700 if ( dlg.ShowModal() == wxID_OK )
701 {
702 propgrid->EditorsValueWasModified();
703
704 wxVariant variant;
705 variant << dlg.GetFontData().GetChosenFont();
706 SetValueInEvent( variant );
707 return true;
708 }
709 }
710 return false;
711}
712
713void wxFontProperty::RefreshChildren()
714{
715 if ( !GetChildCount() ) return;
716 wxFont font;
717 font << m_value;
718 Item(0)->SetValue( (long)font.GetPointSize() );
719 Item(1)->SetValueFromString( font.GetFaceName(), wxPG_FULL_VALUE );
720 Item(2)->SetValue( (long)font.GetStyle() );
721 Item(3)->SetValue( (long)font.GetWeight() );
722 Item(4)->SetValue( font.GetUnderlined() );
723 Item(5)->SetValue( (long)font.GetFamily() );
724}
725
726wxVariant wxFontProperty::ChildChanged( wxVariant& thisValue,
727 int ind,
728 wxVariant& childValue ) const
729{
730 wxFont font;
731 font << thisValue;
732
733 if ( ind == 0 )
734 {
735 font.SetPointSize( childValue.GetLong() );
736 }
737 else if ( ind == 1 )
738 {
739 wxString faceName;
740 int faceIndex = childValue.GetLong();
741
742 if ( faceIndex >= 0 )
743 faceName = wxPGGlobalVars->m_fontFamilyChoices->GetLabel(faceIndex);
744
745 font.SetFaceName( faceName );
746 }
747 else if ( ind == 2 )
748 {
749 int st = childValue.GetLong();
750 if ( st != wxFONTSTYLE_NORMAL &&
751 st != wxFONTSTYLE_SLANT &&
752 st != wxFONTSTYLE_ITALIC )
753 st = wxFONTWEIGHT_NORMAL;
754 font.SetStyle( st );
755 }
756 else if ( ind == 3 )
757 {
758 int wt = childValue.GetLong();
759 if ( wt != wxFONTWEIGHT_NORMAL &&
760 wt != wxFONTWEIGHT_LIGHT &&
761 wt != wxFONTWEIGHT_BOLD )
762 wt = wxFONTWEIGHT_NORMAL;
763 font.SetWeight( wt );
764 }
765 else if ( ind == 4 )
766 {
767 font.SetUnderlined( childValue.GetBool() );
768 }
769 else if ( ind == 5 )
770 {
771 int fam = childValue.GetLong();
772 if ( fam < wxDEFAULT ||
773 fam > wxTELETYPE )
774 fam = wxDEFAULT;
775 font.SetFamily( fam );
776 }
777
778 wxVariant newVariant;
779 newVariant << font;
780 return newVariant;
781}
782
783/*
784wxSize wxFontProperty::OnMeasureImage() const
785{
786 return wxSize(-1,-1);
787}
788
789void wxFontProperty::OnCustomPaint(wxDC& dc,
790 const wxRect& rect,
791 wxPGPaintData& paintData)
792{
793 wxString drawFace;
794 if ( paintData.m_choiceItem >= 0 )
795 drawFace = wxPGGlobalVars->m_fontFamilyChoices->GetLabel(paintData.m_choiceItem);
796 else
797 drawFace = m_value_wxFont.GetFaceName();
798
799 if ( !drawFace.empty() )
800 {
801 // Draw the background
802 dc.SetBrush( wxColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)) );
803 //dc.SetBrush( *wxWHITE_BRUSH );
804 //dc.SetPen( *wxMEDIUM_GREY_PEN );
805 dc.DrawRectangle( rect );
806
807 wxFont oldFont = dc.GetFont();
808 wxFont drawFont(oldFont.GetPointSize(),
809 wxDEFAULT,wxNORMAL,wxBOLD,false,drawFace);
810 dc.SetFont(drawFont);
811
812 dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT) );
813 dc.DrawText( wxT("Aa"), rect.x+2, rect.y+1 );
814
815 dc.SetFont(oldFont);
816 }
817 else
818 {
819 // No file - just draw a white box
820 dc.SetBrush ( *wxWHITE_BRUSH );
821 dc.DrawRectangle ( rect );
822 }
823}
824*/
825
826
827// -----------------------------------------------------------------------
828// wxSystemColourProperty
829// -----------------------------------------------------------------------
830
831// wxEnumProperty based classes cannot use wxPG_PROP_CLASS_SPECIFIC_1
832#define wxPG_PROP_HIDE_CUSTOM_COLOUR wxPG_PROP_CLASS_SPECIFIC_2
833
834#include "wx/colordlg.h"
835
836//#define wx_cp_es_syscolours_len 25
837static const wxChar* const gs_cp_es_syscolour_labels[] = {
838 wxT("AppWorkspace"),
839 wxT("ActiveBorder"),
840 wxT("ActiveCaption"),
841 wxT("ButtonFace"),
842 wxT("ButtonHighlight"),
843 wxT("ButtonShadow"),
844 wxT("ButtonText"),
845 wxT("CaptionText"),
846 wxT("ControlDark"),
847 wxT("ControlLight"),
848 wxT("Desktop"),
849 wxT("GrayText"),
850 wxT("Highlight"),
851 wxT("HighlightText"),
852 wxT("InactiveBorder"),
853 wxT("InactiveCaption"),
854 wxT("InactiveCaptionText"),
855 wxT("Menu"),
856 wxT("Scrollbar"),
857 wxT("Tooltip"),
858 wxT("TooltipText"),
859 wxT("Window"),
860 wxT("WindowFrame"),
861 wxT("WindowText"),
862 wxT("Custom"),
863 (const wxChar*) NULL
864};
865
866static const long gs_cp_es_syscolour_values[] = {
867 wxSYS_COLOUR_APPWORKSPACE,
868 wxSYS_COLOUR_ACTIVEBORDER,
869 wxSYS_COLOUR_ACTIVECAPTION,
870 wxSYS_COLOUR_BTNFACE,
871 wxSYS_COLOUR_BTNHIGHLIGHT,
872 wxSYS_COLOUR_BTNSHADOW,
873 wxSYS_COLOUR_BTNTEXT ,
874 wxSYS_COLOUR_CAPTIONTEXT,
875 wxSYS_COLOUR_3DDKSHADOW,
876 wxSYS_COLOUR_3DLIGHT,
877 wxSYS_COLOUR_BACKGROUND,
878 wxSYS_COLOUR_GRAYTEXT,
879 wxSYS_COLOUR_HIGHLIGHT,
880 wxSYS_COLOUR_HIGHLIGHTTEXT,
881 wxSYS_COLOUR_INACTIVEBORDER,
882 wxSYS_COLOUR_INACTIVECAPTION,
883 wxSYS_COLOUR_INACTIVECAPTIONTEXT,
884 wxSYS_COLOUR_MENU,
885 wxSYS_COLOUR_SCROLLBAR,
886 wxSYS_COLOUR_INFOBK,
887 wxSYS_COLOUR_INFOTEXT,
888 wxSYS_COLOUR_WINDOW,
889 wxSYS_COLOUR_WINDOWFRAME,
890 wxSYS_COLOUR_WINDOWTEXT,
891 wxPG_COLOUR_CUSTOM
892};
893
894
895IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxColourPropertyValue, WXDLLIMPEXP_PROPGRID)
896
897
898// Class body is in advprops.h
899
900WX_PG_IMPLEMENT_PROPERTY_CLASS(wxSystemColourProperty,wxEnumProperty,
901 wxColourPropertyValue,const wxColourPropertyValue&,Choice)
902
903
904void wxSystemColourProperty::Init( int type, const wxColour& colour )
905{
906 wxColourPropertyValue cpv;
907
908 if ( colour.IsOk() )
909 cpv.Init( type, colour );
910 else
911 cpv.Init( type, *wxWHITE );
912
913 m_flags |= wxPG_PROP_STATIC_CHOICES; // Colour selection cannot be changed.
914
915 m_value << cpv;
916
917 OnSetValue();
918}
919
920
921static wxPGChoices gs_wxSystemColourProperty_choicesCache;
922
923
924wxSystemColourProperty::wxSystemColourProperty( const wxString& label, const wxString& name,
925 const wxColourPropertyValue& value )
926 : wxEnumProperty( label,
927 name,
928 gs_cp_es_syscolour_labels,
929 gs_cp_es_syscolour_values,
930 &gs_wxSystemColourProperty_choicesCache )
931{
932 if ( &value )
933 Init( value.m_type, value.m_colour );
934 else
935 Init( wxPG_COLOUR_CUSTOM, *wxWHITE );
936}
937
938
939wxSystemColourProperty::wxSystemColourProperty( const wxString& label, const wxString& name,
940 const wxChar* const* labels, const long* values, wxPGChoices* choicesCache,
941 const wxColourPropertyValue& value )
942 : wxEnumProperty( label, name, labels, values, choicesCache )
943{
944 if ( &value )
945 Init( value.m_type, value.m_colour );
946 else
947 Init( wxPG_COLOUR_CUSTOM, *wxWHITE );
948}
949
950
951wxSystemColourProperty::wxSystemColourProperty( const wxString& label, const wxString& name,
952 const wxChar* const* labels, const long* values, wxPGChoices* choicesCache,
953 const wxColour& value )
954 : wxEnumProperty( label, name, labels, values, choicesCache )
955{
956 if ( &value )
957 Init( wxPG_COLOUR_CUSTOM, value );
958 else
959 Init( wxPG_COLOUR_CUSTOM, *wxWHITE );
960}
961
962
963wxSystemColourProperty::~wxSystemColourProperty() { }
964
965
966wxColourPropertyValue wxSystemColourProperty::GetVal( const wxVariant* pVariant ) const
967{
968 if ( !pVariant )
969 pVariant = &m_value;
970
971 if ( pVariant->IsNull() )
972 return wxColourPropertyValue(wxPG_COLOUR_UNSPECIFIED, wxColour());
973
974 if ( pVariant->GetType() == wxS("wxColourPropertyValue") )
975 {
976 wxColourPropertyValue v;
977 v << *pVariant;
978 return v;
979 }
980
981 wxColour col;
982 bool variantProcessed = true;
983
984 if ( pVariant->GetType() == wxS("wxColour*") )
985 {
986 wxColour* pCol = wxStaticCast(pVariant->GetWxObjectPtr(), wxColour);
987 col = *pCol;
988 }
989 else if ( pVariant->GetType() == wxS("wxColour") )
990 {
991 col << *pVariant;
992 }
993 else if ( pVariant->GetType() == wxArrayInt_VariantType )
994 {
995 // This code is mostly needed for wxPython bindings, which
996 // may offer tuple of integers as colour value.
997 wxArrayInt arr;
998 arr << *pVariant;
999
1000 if ( arr.size() >= 3 )
1001 {
1002 int r, g, b;
1003 int a = 255;
1004
1005 r = arr[0];
1006 g = arr[1];
1007 b = arr[2];
1008 if ( arr.size() >= 4 )
1009 a = arr[3];
1010
1011 col = wxColour(r, g, b, a);
1012 }
1013 else
1014 {
1015 variantProcessed = false;
1016 }
1017 }
1018 else
1019 {
1020 variantProcessed = false;
1021 }
1022
1023 if ( !variantProcessed )
1024 return wxColourPropertyValue(wxPG_COLOUR_UNSPECIFIED, wxColour());
1025
1026 wxColourPropertyValue v2( wxPG_COLOUR_CUSTOM, col );
1027
1028 int colInd = ColToInd(col);
1029 if ( colInd != wxNOT_FOUND )
1030 v2.m_type = colInd;
1031
1032 return v2;
1033}
1034
1035wxVariant wxSystemColourProperty::DoTranslateVal( wxColourPropertyValue& v ) const
1036{
1037 wxVariant variant;
1038 variant << v;
1039 return variant;
1040}
1041
1042int wxSystemColourProperty::ColToInd( const wxColour& colour ) const
1043{
1044 size_t i;
1045 size_t i_max = m_choices.GetCount();
1046
1047 if ( !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1048 i_max -= 1;
1049
1050 for ( i=0; i<i_max; i++ )
1051 {
1052 int ind = m_choices[i].GetValue();
1053
1054 if ( colour == GetColour(ind) )
1055 {
1056 /*wxLogDebug(wxT("%s(%s): Index %i for ( getcolour(%i,%i,%i), colour(%i,%i,%i))"),
1057 GetClassName(),GetLabel().c_str(),
1058 (int)i,(int)GetColour(ind).Red(),(int)GetColour(ind).Green(),(int)GetColour(ind).Blue(),
1059 (int)colour.Red(),(int)colour.Green(),(int)colour.Blue());*/
1060 return ind;
1061 }
1062 }
1063 return wxNOT_FOUND;
1064}
1065
1066void wxSystemColourProperty::OnSetValue()
1067{
1068 // Convert from generic wxobject ptr to wxPGVariantDataColour
1069 if ( m_value.GetType() == wxS("wxColour*") )
1070 {
1071 wxColour* pCol = wxStaticCast(m_value.GetWxObjectPtr(), wxColour);
1072 m_value << *pCol;
1073 }
1074
1075 wxColourPropertyValue val = GetVal(&m_value);
1076
1077 if ( val.m_type == wxPG_COLOUR_UNSPECIFIED )
1078 {
1079 m_value.MakeNull();
1080 return;
1081 }
1082 else
1083 {
1084
1085 if ( val.m_type < wxPG_COLOUR_WEB_BASE )
1086 val.m_colour = GetColour( val.m_type );
1087
1088 m_value = TranslateVal(val);
1089 }
1090
1091 int ind = wxNOT_FOUND;
1092
1093 if ( m_value.GetType() == wxS("wxColourPropertyValue") )
1094 {
1095 wxColourPropertyValue cpv;
1096 cpv << m_value;
1097 wxColour col = cpv.m_colour;
1098
1099 if ( !col.IsOk() )
1100 {
1101 SetValueToUnspecified();
1102 SetIndex(wxNOT_FOUND);
1103 return;
1104 }
1105
1106 if ( cpv.m_type < wxPG_COLOUR_WEB_BASE ||
1107 (m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1108 {
1109 ind = GetIndexForValue(cpv.m_type);
1110 }
1111 else
1112 {
1113 cpv.m_type = wxPG_COLOUR_CUSTOM;
1114 ind = GetCustomColourIndex();
1115 }
1116 }
1117 else
1118 {
1119 wxColour col;
1120 col << m_value;
1121
1122 if ( !col.IsOk() )
1123 {
1124 SetValueToUnspecified();
1125 SetIndex(wxNOT_FOUND);
1126 return;
1127 }
1128
1129 ind = ColToInd(col);
1130
1131 if ( ind == wxNOT_FOUND &&
1132 !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1133 ind = GetCustomColourIndex();
1134 }
1135
1136 SetIndex(ind);
1137}
1138
1139
1140wxColour wxSystemColourProperty::GetColour( int index ) const
1141{
1142 return wxSystemSettings::GetColour( (wxSystemColour)index );
1143}
1144
1145wxString wxSystemColourProperty::ColourToString( const wxColour& col,
1146 int index,
1147 int argFlags ) const
1148{
1149
1150 if ( index == wxNOT_FOUND )
1151 {
1152
1153 if ( (argFlags & wxPG_FULL_VALUE) ||
1154 GetAttributeAsLong(wxPG_COLOUR_HAS_ALPHA, 0) )
1155 {
1156 return wxString::Format(wxS("(%i,%i,%i,%i)"),
1157 (int)col.Red(),
1158 (int)col.Green(),
1159 (int)col.Blue(),
1160 (int)col.Alpha());
1161 }
1162 else
1163 {
1164 return wxString::Format(wxS("(%i,%i,%i)"),
1165 (int)col.Red(),
1166 (int)col.Green(),
1167 (int)col.Blue());
1168 }
1169 }
1170 else
1171 {
1172 return m_choices.GetLabel(index);
1173 }
1174}
1175
1176wxString wxSystemColourProperty::ValueToString( wxVariant& value,
1177 int argFlags ) const
1178{
1179 wxColourPropertyValue val = GetVal(&value);
1180
1181 int index;
1182
1183 if ( argFlags & wxPG_VALUE_IS_CURRENT )
1184 {
1185 // GetIndex() only works reliably if wxPG_VALUE_IS_CURRENT flag is set,
1186 // but we should use it whenever possible.
1187 index = GetIndex();
1188
1189 // If custom colour was selected, use invalid index, so that
1190 // ColourToString() will return properly formatted colour text.
1191 if ( index == GetCustomColourIndex() &&
1192 !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1193 index = wxNOT_FOUND;
1194 }
1195 else
1196 {
1197 index = m_choices.Index(val.m_type);
1198 }
1199
1200 return ColourToString(val.m_colour, index, argFlags);
1201}
1202
1203
1204wxSize wxSystemColourProperty::OnMeasureImage( int ) const
1205{
1206 return wxPG_DEFAULT_IMAGE_SIZE;
1207}
1208
1209
1210int wxSystemColourProperty::GetCustomColourIndex() const
1211{
1212 return m_choices.GetCount() - 1;
1213}
1214
1215
1216bool wxSystemColourProperty::QueryColourFromUser( wxVariant& variant ) const
1217{
1218 wxASSERT( m_value.GetType() != wxPG_VARIANT_TYPE_STRING );
1219 bool res = false;
1220
1221 wxPropertyGrid* propgrid = GetGrid();
1222 wxASSERT( propgrid );
1223
1224 // Must only occur when user triggers event
1225 if ( !(propgrid->GetInternalFlags() & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT) )
1226 return res;
1227
1228 wxColourPropertyValue val = GetVal();
1229
1230 val.m_type = wxPG_COLOUR_CUSTOM;
1231
1232 wxColourData data;
1233 data.SetChooseFull(true);
1234 data.SetColour(val.m_colour);
1235 int i;
1236 for ( i = 0; i < 16; i++)
1237 {
1238 wxColour colour(i*16, i*16, i*16);
1239 data.SetCustomColour(i, colour);
1240 }
1241
1242 wxColourDialog dialog(propgrid, &data);
1243 if ( dialog.ShowModal() == wxID_OK )
1244 {
1245 wxColourData retData = dialog.GetColourData();
1246 val.m_colour = retData.GetColour();
1247
1248 variant = DoTranslateVal(val);
1249
1250 SetValueInEvent(variant);
1251
1252 res = true;
1253 }
1254
1255 return res;
1256}
1257
1258
1259bool wxSystemColourProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
1260{
1261 int index = number;
1262 int type = m_choices.GetValue(index);
1263
1264 if ( type == wxPG_COLOUR_CUSTOM )
1265 {
1266 QueryColourFromUser(variant);
1267 }
1268 else
1269 {
1270 variant = TranslateVal( type, GetColour(type) );
1271 }
1272
1273 return true;
1274}
1275
1276// Need to do some extra event handling.
1277bool wxSystemColourProperty::OnEvent( wxPropertyGrid* propgrid,
1278 wxWindow* WXUNUSED(primary),
1279 wxEvent& event )
1280{
1281 bool askColour = false;
1282
1283 if ( propgrid->IsMainButtonEvent(event) )
1284 {
1285 // We need to handle button click in case editor has been
1286 // switched to one that has wxButton as well.
1287 askColour = true;
1288 }
1289 else if ( event.GetEventType() == wxEVT_COMBOBOX )
1290 {
1291 // Must override index detection since at this point GetIndex()
1292 // will return old value.
1293 wxOwnerDrawnComboBox* cb =
1294 static_cast<wxOwnerDrawnComboBox*>(propgrid->GetEditorControl());
1295
1296 if ( cb )
1297 {
1298 int index = cb->GetSelection();
1299
1300 if ( index == GetCustomColourIndex() &&
1301 !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1302 askColour = true;
1303 }
1304 }
1305
1306 if ( askColour && !propgrid->WasValueChangedInEvent() )
1307 {
1308 wxVariant variant;
1309 if ( QueryColourFromUser(variant) )
1310 return true;
1311 }
1312 return false;
1313}
1314
1315/*class wxPGColourPropertyRenderer : public wxPGDefaultRenderer
1316{
1317public:
1318 virtual void Render( wxDC& dc, const wxRect& rect,
1319 const wxPropertyGrid* propertyGrid, wxPGProperty* property,
1320 int WXUNUSED(column), int item, int WXUNUSED(flags) ) const
1321 {
1322 wxASSERT( wxDynamicCast(property, wxSystemColourProperty) );
1323 wxSystemColourProperty* prop = wxStaticCast(property, wxSystemColourProperty);
1324
1325 dc.SetPen(*wxBLACK_PEN);
1326 if ( item >= 0 &&
1327 ( item < (int)(GetCustomColourIndex) || (prop->HasFlag(wxPG_PROP_HIDE_CUSTOM_COLOUR)))
1328 )
1329 {
1330 int colInd;
1331 const wxArrayInt& values = prop->GetValues();
1332 if ( values.GetChildCount() )
1333 colInd = values[item];
1334 else
1335 colInd = item;
1336 dc.SetBrush( wxColour( prop->GetColour( colInd ) ) );
1337 }
1338 else if ( !prop->IsValueUnspecified() )
1339 dc.SetBrush( prop->GetVal().m_colour );
1340 else
1341 dc.SetBrush( *wxWHITE );
1342
1343 wxRect imageRect = propertyGrid->GetImageRect(property, item);
1344 wxLogDebug(wxT("%i, %i"),imageRect.x,imageRect.y);
1345 dc.DrawRectangle( rect.x+imageRect.x, rect.y+imageRect.y,
1346 imageRect.width, imageRect.height );
1347
1348 wxString text;
1349 if ( item == -1 )
1350 text = property->GetValueAsString();
1351 else
1352 text = property->GetChoiceString(item);
1353 DrawText( dc, rect, imageRect.width, text );
1354 }
1355protected:
1356};
1357
1358wxPGColourPropertyRenderer g_wxPGColourPropertyRenderer;
1359
1360wxPGCellRenderer* wxSystemColourProperty::GetCellRenderer( int column ) const
1361{
1362 if ( column == 1 )
1363 return &g_wxPGColourPropertyRenderer;
1364 return wxEnumProperty::GetCellRenderer(column);
1365}*/
1366
1367void wxSystemColourProperty::OnCustomPaint( wxDC& dc, const wxRect& rect,
1368 wxPGPaintData& paintdata )
1369{
1370 wxColour col;
1371
1372 if ( paintdata.m_choiceItem >= 0 &&
1373 paintdata.m_choiceItem < (int)m_choices.GetCount() &&
1374 (paintdata.m_choiceItem != GetCustomColourIndex() ||
1375 m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1376 {
1377 int colInd = m_choices[paintdata.m_choiceItem].GetValue();
1378 col = GetColour( colInd );
1379 }
1380 else if ( !IsValueUnspecified() )
1381 {
1382 col = GetVal().m_colour;
1383 }
1384
1385 if ( col.IsOk() )
1386 {
1387 dc.SetBrush(col);
1388 dc.DrawRectangle(rect);
1389 }
1390}
1391
1392
1393bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& text, int argFlags ) const
1394{
1395 wxString custColName(m_choices.GetLabel(GetCustomColourIndex()));
1396 wxString colStr(text);
1397 colStr.Trim(true);
1398 colStr.Trim(false);
1399
1400 wxColour customColour;
1401 bool conversionSuccess = false;
1402
1403 if ( colStr != custColName )
1404 {
1405 if ( colStr.Find(wxS("(")) == 0 )
1406 {
1407 // Eliminate whitespace
1408 colStr.Replace(wxS(" "), wxEmptyString);
1409
1410 int commaCount = colStr.Freq(wxS(','));
1411 if ( commaCount == 2 )
1412 {
1413 // Convert (R,G,B) to rgb(R,G,B)
1414 colStr = wxS("rgb") + colStr;
1415 }
1416 else if ( commaCount == 3 )
1417 {
1418 // We have int alpha, CSS format that wxColour takes as
1419 // input processes float alpha. So, let's parse the colour
1420 // ourselves instead of trying to convert it to a format
1421 // that wxColour::FromString() understands.
1422 int r = -1, g = -1, b = -1, a = -1;
1423 wxSscanf(colStr, wxS("(%i,%i,%i,%i)"), &r, &g, &b, &a);
1424 customColour.Set(r, g, b, a);
1425 conversionSuccess = customColour.IsOk();
1426 }
1427 }
1428
1429 if ( !conversionSuccess )
1430 conversionSuccess = customColour.Set(colStr);
1431 }
1432
1433 if ( !conversionSuccess && m_choices.GetCount() &&
1434 !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) &&
1435 colStr == custColName )
1436 {
1437 if ( !(argFlags & wxPG_EDITABLE_VALUE ))
1438 {
1439 // This really should not occur...
1440 // wxASSERT(false);
1441 ResetNextIndex();
1442 return false;
1443 }
1444
1445 QueryColourFromUser(value);
1446 }
1447 else
1448 {
1449 wxColourPropertyValue val;
1450
1451 bool done = false;
1452
1453 if ( !conversionSuccess )
1454 {
1455 // Try predefined colour first
1456 bool res = wxEnumProperty::StringToValue(value,
1457 colStr,
1458 argFlags);
1459 if ( res && GetIndex() >= 0 )
1460 {
1461 val.m_type = GetIndex();
1462 if ( val.m_type < m_choices.GetCount() )
1463 val.m_type = m_choices[val.m_type].GetValue();
1464
1465 // Get proper colour for type.
1466 val.m_colour = GetColour(val.m_type);
1467
1468 done = true;
1469 }
1470 }
1471 else
1472 {
1473 val.m_type = wxPG_COLOUR_CUSTOM;
1474 val.m_colour = customColour;
1475 done = true;
1476 }
1477
1478 if ( !done )
1479 {
1480 ResetNextIndex();
1481 return false;
1482 }
1483
1484 value = DoTranslateVal(val);
1485 }
1486
1487 return true;
1488}
1489
1490
1491bool wxSystemColourProperty::DoSetAttribute( const wxString& name, wxVariant& value )
1492{
1493 if ( name == wxPG_COLOUR_ALLOW_CUSTOM )
1494 {
1495 int ival = value.GetLong();
1496
1497 if ( ival && (m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1498 {
1499 // Show custom choice
1500 m_choices.Insert(wxT("Custom"), GetCustomColourIndex(), wxPG_COLOUR_CUSTOM);
1501 m_flags &= ~(wxPG_PROP_HIDE_CUSTOM_COLOUR);
1502 }
1503 else if ( !ival && !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
1504 {
1505 // Hide custom choice
1506 m_choices.RemoveAt(GetCustomColourIndex());
1507 m_flags |= wxPG_PROP_HIDE_CUSTOM_COLOUR;
1508 }
1509 return true;
1510 }
1511 return false;
1512}
1513
1514
1515// -----------------------------------------------------------------------
1516// wxColourProperty
1517// -----------------------------------------------------------------------
1518
1519static const wxChar* const gs_cp_es_normcolour_labels[] = {
1520 wxT("Black"),
1521 wxT("Maroon"),
1522 wxT("Navy"),
1523 wxT("Purple"),
1524 wxT("Teal"),
1525 wxT("Gray"),
1526 wxT("Green"),
1527 wxT("Olive"),
1528 wxT("Brown"),
1529 wxT("Blue"),
1530 wxT("Fuchsia"),
1531 wxT("Red"),
1532 wxT("Orange"),
1533 wxT("Silver"),
1534 wxT("Lime"),
1535 wxT("Aqua"),
1536 wxT("Yellow"),
1537 wxT("White"),
1538 wxT("Custom"),
1539 (const wxChar*) NULL
1540};
1541
1542static const unsigned long gs_cp_es_normcolour_colours[] = {
1543 wxPG_COLOUR(0,0,0),
1544 wxPG_COLOUR(128,0,0),
1545 wxPG_COLOUR(0,0,128),
1546 wxPG_COLOUR(128,0,128),
1547 wxPG_COLOUR(0,128,128),
1548 wxPG_COLOUR(128,128,128),
1549 wxPG_COLOUR(0,128,0),
1550 wxPG_COLOUR(128,128,0),
1551 wxPG_COLOUR(166,124,81),
1552 wxPG_COLOUR(0,0,255),
1553 wxPG_COLOUR(255,0,255),
1554 wxPG_COLOUR(255,0,0),
1555 wxPG_COLOUR(247,148,28),
1556 wxPG_COLOUR(192,192,192),
1557 wxPG_COLOUR(0,255,0),
1558 wxPG_COLOUR(0,255,255),
1559 wxPG_COLOUR(255,255,0),
1560 wxPG_COLOUR(255,255,255),
1561 wxPG_COLOUR(0,0,0)
1562};
1563
1564WX_PG_IMPLEMENT_PROPERTY_CLASS(wxColourProperty, wxSystemColourProperty,
1565 wxColour, const wxColour&, TextCtrlAndButton)
1566
1567static wxPGChoices gs_wxColourProperty_choicesCache;
1568
1569wxColourProperty::wxColourProperty( const wxString& label,
1570 const wxString& name,
1571 const wxColour& value )
1572 : wxSystemColourProperty(label, name, gs_cp_es_normcolour_labels,
1573 NULL,
1574 &gs_wxColourProperty_choicesCache, value )
1575{
1576 Init( value );
1577
1578 m_flags |= wxPG_PROP_TRANSLATE_CUSTOM;
1579}
1580
1581wxColourProperty::~wxColourProperty()
1582{
1583}
1584
1585void wxColourProperty::Init( wxColour colour )
1586{
1587 if ( !colour.IsOk() )
1588 colour = *wxWHITE;
1589 wxVariant variant;
1590 variant << colour;
1591 m_value = variant;
1592 int ind = ColToInd(colour);
1593 if ( ind < 0 )
1594 ind = m_choices.GetCount() - 1;
1595 SetIndex( ind );
1596}
1597
1598wxString wxColourProperty::ValueToString( wxVariant& value,
1599 int argFlags ) const
1600{
1601 const wxPGEditor* editor = GetEditorClass();
1602 if ( editor != wxPGEditor_Choice &&
1603 editor != wxPGEditor_ChoiceAndButton &&
1604 editor != wxPGEditor_ComboBox )
1605 argFlags |= wxPG_PROPERTY_SPECIFIC;
1606
1607 return wxSystemColourProperty::ValueToString(value, argFlags);
1608}
1609
1610wxColour wxColourProperty::GetColour( int index ) const
1611{
1612 return gs_cp_es_normcolour_colours[m_choices.GetValue(index)];
1613}
1614
1615wxVariant wxColourProperty::DoTranslateVal( wxColourPropertyValue& v ) const
1616{
1617 wxVariant variant;
1618 variant << v.m_colour;
1619 return variant;
1620}
1621
1622// -----------------------------------------------------------------------
1623// wxCursorProperty
1624// -----------------------------------------------------------------------
1625
1626#define wxPG_CURSOR_IMAGE_WIDTH 32
1627
1628#define NUM_CURSORS 28
1629
1630//#define wx_cp_es_syscursors_len 28
1631static const wxChar* const gs_cp_es_syscursors_labels[NUM_CURSORS+1] = {
1632 wxT("Default"),
1633 wxT("Arrow"),
1634 wxT("Right Arrow"),
1635 wxT("Blank"),
1636 wxT("Bullseye"),
1637 wxT("Character"),
1638 wxT("Cross"),
1639 wxT("Hand"),
1640 wxT("I-Beam"),
1641 wxT("Left Button"),
1642 wxT("Magnifier"),
1643 wxT("Middle Button"),
1644 wxT("No Entry"),
1645 wxT("Paint Brush"),
1646 wxT("Pencil"),
1647 wxT("Point Left"),
1648 wxT("Point Right"),
1649 wxT("Question Arrow"),
1650 wxT("Right Button"),
1651 wxT("Sizing NE-SW"),
1652 wxT("Sizing N-S"),
1653 wxT("Sizing NW-SE"),
1654 wxT("Sizing W-E"),
1655 wxT("Sizing"),
1656 wxT("Spraycan"),
1657 wxT("Wait"),
1658 wxT("Watch"),
1659 wxT("Wait Arrow"),
1660 (const wxChar*) NULL
1661};
1662
1663static const long gs_cp_es_syscursors_values[NUM_CURSORS] = {
1664 wxCURSOR_NONE,
1665 wxCURSOR_ARROW,
1666 wxCURSOR_RIGHT_ARROW,
1667 wxCURSOR_BLANK,
1668 wxCURSOR_BULLSEYE,
1669 wxCURSOR_CHAR,
1670 wxCURSOR_CROSS,
1671 wxCURSOR_HAND,
1672 wxCURSOR_IBEAM,
1673 wxCURSOR_LEFT_BUTTON,
1674 wxCURSOR_MAGNIFIER,
1675 wxCURSOR_MIDDLE_BUTTON,
1676 wxCURSOR_NO_ENTRY,
1677 wxCURSOR_PAINT_BRUSH,
1678 wxCURSOR_PENCIL,
1679 wxCURSOR_POINT_LEFT,
1680 wxCURSOR_POINT_RIGHT,
1681 wxCURSOR_QUESTION_ARROW,
1682 wxCURSOR_RIGHT_BUTTON,
1683 wxCURSOR_SIZENESW,
1684 wxCURSOR_SIZENS,
1685 wxCURSOR_SIZENWSE,
1686 wxCURSOR_SIZEWE,
1687 wxCURSOR_SIZING,
1688 wxCURSOR_SPRAYCAN,
1689 wxCURSOR_WAIT,
1690 wxCURSOR_WATCH,
1691 wxCURSOR_ARROWWAIT
1692};
1693
1694IMPLEMENT_DYNAMIC_CLASS(wxCursorProperty, wxEnumProperty)
1695
1696wxCursorProperty::wxCursorProperty( const wxString& label, const wxString& name,
1697 int value )
1698 : wxEnumProperty( label,
1699 name,
1700 gs_cp_es_syscursors_labels,
1701 gs_cp_es_syscursors_values,
1702 value )
1703{
1704 m_flags |= wxPG_PROP_STATIC_CHOICES; // Cursor selection cannot be changed.
1705}
1706
1707wxCursorProperty::~wxCursorProperty()
1708{
1709}
1710
1711wxSize wxCursorProperty::OnMeasureImage( int item ) const
1712{
1713#if wxPG_CAN_DRAW_CURSOR
1714 if ( item != -1 && item < NUM_CURSORS )
1715 return wxSize(wxPG_CURSOR_IMAGE_WIDTH,wxPG_CURSOR_IMAGE_WIDTH);
1716#else
1717 wxUnusedVar(item);
1718#endif
1719 return wxSize(0,0);
1720}
1721
1722#if wxPG_CAN_DRAW_CURSOR
1723
1724void wxCursorProperty::OnCustomPaint( wxDC& dc,
1725 const wxRect& rect,
1726 wxPGPaintData& paintdata )
1727{
1728 // Background brush
1729 dc.SetBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE ) );
1730
1731 if ( paintdata.m_choiceItem >= 0 )
1732 {
1733 dc.DrawRectangle( rect );
1734
1735 if ( paintdata.m_choiceItem < NUM_CURSORS )
1736 {
1737 wxStockCursor cursorIndex =
1738 (wxStockCursor) gs_cp_es_syscursors_values[paintdata.m_choiceItem];
1739
1740 {
1741 if ( cursorIndex == wxCURSOR_NONE )
1742 cursorIndex = wxCURSOR_ARROW;
1743
1744 wxCursor cursor( cursorIndex );
1745
1746 #ifdef __WXMSW__
1747 HDC hDc = (HDC)((const wxMSWDCImpl *)dc.GetImpl())->GetHDC();
1748 ::DrawIconEx( hDc,
1749 rect.x,
1750 rect.y,
1751 (HICON)cursor.GetHandle(),
1752 0,
1753 0,
1754 0,
1755 NULL,
1756 #if !defined(__WXWINCE__)
1757 DI_COMPAT | DI_DEFAULTSIZE |
1758 #endif
1759 DI_NORMAL
1760 );
1761 #endif
1762 }
1763 }
1764 }
1765}
1766
1767#else
1768void wxCursorProperty::OnCustomPaint( wxDC&, const wxRect&, wxPGPaintData& ) { }
1769/*wxPGCellRenderer* wxCursorProperty::GetCellRenderer( int column ) const
1770{
1771 return wxEnumProperty::GetCellRenderer(column);
1772}*/
1773#endif
1774
1775// -----------------------------------------------------------------------
1776// wxImageFileProperty
1777// -----------------------------------------------------------------------
1778
1779#if wxUSE_IMAGE
1780
1781const wxString& wxPGGetDefaultImageWildcard()
1782{
1783 // Form the wildcard, if not done yet
1784 if ( wxPGGlobalVars->m_pDefaultImageWildcard.empty() )
1785 {
1786
1787 wxString str;
1788
1789 // TODO: This section may require locking (using global).
1790
1791 wxList& handlers = wxImage::GetHandlers();
1792
1793 wxList::iterator node;
1794
1795 // Let's iterate over the image handler list.
1796 //for ( wxList::Node *node = handlers.GetFirst(); node; node = node->GetNext() )
1797 for ( node = handlers.begin(); node != handlers.end(); ++node )
1798 {
1799 wxImageHandler *handler = (wxImageHandler*)*node;
1800
1801 wxString ext_lo = handler->GetExtension();
1802 wxString ext_up = ext_lo.Upper();
1803
1804 str.append( ext_up );
1805 str.append( wxT(" files (*.") );
1806 str.append( ext_up );
1807 str.append( wxT(")|*.") );
1808 str.append( ext_lo );
1809 str.append( wxT("|") );
1810 }
1811
1812 str.append ( wxT("All files (*.*)|*.*") );
1813
1814 wxPGGlobalVars->m_pDefaultImageWildcard = str;
1815 }
1816
1817 return wxPGGlobalVars->m_pDefaultImageWildcard;
1818}
1819
1820IMPLEMENT_DYNAMIC_CLASS(wxImageFileProperty, wxFileProperty)
1821
1822wxImageFileProperty::wxImageFileProperty( const wxString& label, const wxString& name,
1823 const wxString& value )
1824 : wxFileProperty(label,name,value)
1825{
1826 SetAttribute( wxPG_FILE_WILDCARD, wxPGGetDefaultImageWildcard() );
1827
1828 m_pImage = NULL;
1829 m_pBitmap = NULL;
1830}
1831
1832wxImageFileProperty::~wxImageFileProperty()
1833{
1834 if ( m_pBitmap )
1835 delete m_pBitmap;
1836 if ( m_pImage )
1837 delete m_pImage;
1838}
1839
1840void wxImageFileProperty::OnSetValue()
1841{
1842 wxFileProperty::OnSetValue();
1843
1844 // Delete old image
1845 wxDELETE(m_pImage);
1846 wxDELETE(m_pBitmap);
1847
1848 wxFileName filename = GetFileName();
1849
1850 // Create the image thumbnail
1851 if ( filename.FileExists() )
1852 {
1853 m_pImage = new wxImage( filename.GetFullPath() );
1854 }
1855}
1856
1857wxSize wxImageFileProperty::OnMeasureImage( int ) const
1858{
1859 return wxPG_DEFAULT_IMAGE_SIZE;
1860}
1861
1862void wxImageFileProperty::OnCustomPaint( wxDC& dc,
1863 const wxRect& rect,
1864 wxPGPaintData& )
1865{
1866 if ( m_pBitmap || (m_pImage && m_pImage->IsOk() ) )
1867 {
1868 // Draw the thumbnail
1869
1870 // Create the bitmap here because required size is not known in OnSetValue().
1871 if ( !m_pBitmap )
1872 {
1873 m_pImage->Rescale( rect.width, rect.height );
1874 m_pBitmap = new wxBitmap( *m_pImage );
1875 wxDELETE(m_pImage);
1876 }
1877
1878 dc.DrawBitmap( *m_pBitmap, rect.x, rect.y, false );
1879 }
1880 else
1881 {
1882 // No file - just draw a white box
1883 dc.SetBrush( *wxWHITE_BRUSH );
1884 dc.DrawRectangle ( rect );
1885 }
1886}
1887
1888#endif // wxUSE_IMAGE
1889
1890// -----------------------------------------------------------------------
1891// wxMultiChoiceProperty
1892// -----------------------------------------------------------------------
1893
1894#if wxUSE_CHOICEDLG
1895
1896#include "wx/choicdlg.h"
1897
1898WX_PG_IMPLEMENT_PROPERTY_CLASS(wxMultiChoiceProperty,wxPGProperty,
1899 wxArrayInt,const wxArrayInt&,TextCtrlAndButton)
1900
1901wxMultiChoiceProperty::wxMultiChoiceProperty( const wxString& label,
1902 const wxString& name,
1903 const wxPGChoices& choices,
1904 const wxArrayString& value)
1905 : wxPGProperty(label,name)
1906{
1907 m_choices.Assign(choices);
1908 SetValue(value);
1909}
1910
1911wxMultiChoiceProperty::wxMultiChoiceProperty( const wxString& label,
1912 const wxString& name,
1913 const wxArrayString& strings,
1914 const wxArrayString& value)
1915 : wxPGProperty(label,name)
1916{
1917 m_choices.Set(strings);
1918 SetValue(value);
1919}
1920
1921wxMultiChoiceProperty::wxMultiChoiceProperty( const wxString& label,
1922 const wxString& name,
1923 const wxArrayString& value)
1924 : wxPGProperty(label,name)
1925{
1926 wxArrayString strings;
1927 m_choices.Set(strings);
1928 SetValue(value);
1929}
1930
1931wxMultiChoiceProperty::~wxMultiChoiceProperty()
1932{
1933}
1934
1935void wxMultiChoiceProperty::OnSetValue()
1936{
1937 GenerateValueAsString(m_value, &m_display);
1938}
1939
1940wxString wxMultiChoiceProperty::ValueToString( wxVariant& value,
1941 int argFlags ) const
1942{
1943 // If possible, use cached string
1944 if ( argFlags & wxPG_VALUE_IS_CURRENT )
1945 return m_display;
1946
1947 wxString s;
1948 GenerateValueAsString(value, &s);
1949 return s;
1950}
1951
1952void wxMultiChoiceProperty::GenerateValueAsString( wxVariant& value,
1953 wxString* target ) const
1954{
1955 wxArrayString strings;
1956
1957 if ( value.GetType() == wxPG_VARIANT_TYPE_ARRSTRING )
1958 strings = value.GetArrayString();
1959
1960 wxString& tempStr = *target;
1961 unsigned int i;
1962 unsigned int itemCount = strings.size();
1963
1964 tempStr.Empty();
1965
1966 if ( itemCount )
1967 tempStr.append( wxT("\"") );
1968
1969 for ( i = 0; i < itemCount; i++ )
1970 {
1971 tempStr.append( strings[i] );
1972 tempStr.append( wxT("\"") );
1973 if ( i < (itemCount-1) )
1974 tempStr.append ( wxT(" \"") );
1975 }
1976}
1977
1978wxArrayInt wxMultiChoiceProperty::GetValueAsIndices() const
1979{
1980 wxVariant variant = GetValue();
1981 const wxArrayInt& valueArr = wxArrayIntRefFromVariant(variant);
1982 unsigned int i;
1983
1984 // Translate values to string indices.
1985 wxArrayInt selections;
1986
1987 if ( !m_choices.IsOk() || !m_choices.GetCount() || !(&valueArr) )
1988 {
1989 for ( i=0; i<valueArr.size(); i++ )
1990 selections.Add(-1);
1991 }
1992 else
1993 {
1994 for ( i=0; i<valueArr.size(); i++ )
1995 {
1996 int sIndex = m_choices.Index(valueArr[i]);
1997 if ( sIndex >= 0 )
1998 selections.Add(sIndex);
1999 }
2000 }
2001
2002 return selections;
2003}
2004
2005bool wxMultiChoiceProperty::OnEvent( wxPropertyGrid* propgrid,
2006 wxWindow* WXUNUSED(primary),
2007 wxEvent& event )
2008{
2009 if ( propgrid->IsMainButtonEvent(event) )
2010 {
2011 // Update the value
2012 wxVariant useValue = propgrid->GetUncommittedPropertyValue();
2013
2014 wxArrayString labels = m_choices.GetLabels();
2015 unsigned int choiceCount;
2016
2017 if ( m_choices.IsOk() )
2018 choiceCount = m_choices.GetCount();
2019 else
2020 choiceCount = 0;
2021
2022 // launch editor dialog
2023 wxMultiChoiceDialog dlg( propgrid,
2024 _("Make a selection:"),
2025 m_label,
2026 choiceCount,
2027 choiceCount?&labels[0]:NULL,
2028 wxCHOICEDLG_STYLE );
2029
2030 dlg.Move( propgrid->GetGoodEditorDialogPosition(this,dlg.GetSize()) );
2031
2032 wxArrayString strings = useValue.GetArrayString();
2033 wxArrayString extraStrings;
2034
2035 dlg.SetSelections(m_choices.GetIndicesForStrings(strings, &extraStrings));
2036
2037 if ( dlg.ShowModal() == wxID_OK && choiceCount )
2038 {
2039 int userStringMode = GetAttributeAsLong(wxT("UserStringMode"), 0);
2040
2041 wxArrayInt arrInt = dlg.GetSelections();
2042
2043 wxVariant variant;
2044
2045 // Strings that were not in list of choices
2046 wxArrayString value;
2047
2048 // Translate string indices to strings
2049
2050 unsigned int n;
2051 if ( userStringMode == 1 )
2052 {
2053 for (n=0;n<extraStrings.size();n++)
2054 value.push_back(extraStrings[n]);
2055 }
2056
2057 unsigned int i;
2058 for ( i=0; i<arrInt.size(); i++ )
2059 value.Add(m_choices.GetLabel(arrInt.Item(i)));
2060
2061 if ( userStringMode == 2 )
2062 {
2063 for (n=0;n<extraStrings.size();n++)
2064 value.push_back(extraStrings[n]);
2065 }
2066
2067 variant = WXVARIANT(value);
2068
2069 SetValueInEvent(variant);
2070
2071 return true;
2072 }
2073 }
2074 return false;
2075}
2076
2077bool wxMultiChoiceProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
2078{
2079 wxArrayString arr;
2080
2081 int userStringMode = GetAttributeAsLong(wxT("UserStringMode"), 0);
2082
2083 WX_PG_TOKENIZER2_BEGIN(text,wxT('"'))
2084 if ( userStringMode > 0 || (m_choices.IsOk() && m_choices.Index( token ) != wxNOT_FOUND) )
2085 arr.Add(token);
2086 WX_PG_TOKENIZER2_END()
2087
2088 wxVariant v( WXVARIANT(arr) );
2089 variant = v;
2090
2091 return true;
2092}
2093
2094#endif // wxUSE_CHOICEDLG
2095
2096
2097// -----------------------------------------------------------------------
2098// wxDateProperty
2099// -----------------------------------------------------------------------
2100
2101#if wxUSE_DATETIME
2102
2103
2104#if wxUSE_DATEPICKCTRL
2105 #define dtCtrl DatePickerCtrl
2106#else
2107 #define dtCtrl TextCtrl
2108#endif
2109
2110WX_PG_IMPLEMENT_PROPERTY_CLASS(wxDateProperty,
2111 wxPGProperty,
2112 wxDateTime,
2113 const wxDateTime&,
2114 dtCtrl)
2115
2116
2117wxString wxDateProperty::ms_defaultDateFormat;
2118
2119
2120wxDateProperty::wxDateProperty( const wxString& label,
2121 const wxString& name,
2122 const wxDateTime& value )
2123 : wxPGProperty(label,name)
2124{
2125 //wxPGRegisterDefaultValueType(wxDateTime)
2126
2127#if wxUSE_DATEPICKCTRL
2128 wxPGRegisterEditorClass(DatePickerCtrl);
2129
2130 m_dpStyle = wxDP_DEFAULT | wxDP_SHOWCENTURY;
2131#else
2132 m_dpStyle = 0;
2133#endif
2134
2135 SetValue( value );
2136}
2137
2138wxDateProperty::~wxDateProperty()
2139{
2140}
2141
2142void wxDateProperty::OnSetValue()
2143{
2144 //
2145 // Convert invalid dates to unspecified value
2146 if ( m_value.GetType() == wxT("datetime") )
2147 {
2148 if ( !m_value.GetDateTime().IsValid() )
2149 m_value.MakeNull();
2150 }
2151}
2152
2153bool wxDateProperty::StringToValue( wxVariant& variant, const wxString& text,
2154 int WXUNUSED(argFlags) ) const
2155{
2156 wxDateTime dt;
2157
2158 // FIXME: do we really want to return true from here if only part of the
2159 // string was parsed?
2160 const char* c = dt.ParseFormat(text);
2161
2162 if ( c )
2163 {
2164 variant = dt;
2165 return true;
2166 }
2167
2168 return false;
2169}
2170
2171wxString wxDateProperty::ValueToString( wxVariant& value,
2172 int argFlags ) const
2173{
2174 const wxChar* format = (const wxChar*) NULL;
2175
2176 wxDateTime dateTime = value.GetDateTime();
2177
2178 if ( !dateTime.IsValid() )
2179 return wxT("Invalid");
2180
2181 if ( ms_defaultDateFormat.empty() )
2182 {
2183#if wxUSE_DATEPICKCTRL
2184 bool showCentury = m_dpStyle & wxDP_SHOWCENTURY ? true : false;
2185#else
2186 bool showCentury = true;
2187#endif
2188 ms_defaultDateFormat = DetermineDefaultDateFormat( showCentury );
2189 }
2190
2191 if ( !m_format.empty() &&
2192 !(argFlags & wxPG_FULL_VALUE) )
2193 format = m_format.c_str();
2194
2195 // Determine default from locale
2196 // NB: This is really simple stuff, but can't figure anything
2197 // better without proper support in wxLocale
2198 if ( !format )
2199 format = ms_defaultDateFormat.c_str();
2200
2201 return dateTime.Format(format);
2202}
2203
2204wxString wxDateProperty::DetermineDefaultDateFormat( bool showCentury )
2205{
2206 // This code is basically copied from datectlg.cpp's SetFormat
2207 //
2208 wxString format;
2209
2210 wxDateTime dt;
2211 dt.ParseFormat(wxT("2003-10-13"), wxT("%Y-%m-%d"));
2212 wxString str(dt.Format(wxT("%x")));
2213
2214 const wxChar *p = str.c_str();
2215 while ( *p )
2216 {
2217 int n=wxAtoi(p);
2218 if (n == dt.GetDay())
2219 {
2220 format.Append(wxT("%d"));
2221 p += 2;
2222 }
2223 else if (n == (int)dt.GetMonth()+1)
2224 {
2225 format.Append(wxT("%m"));
2226 p += 2;
2227 }
2228 else if (n == dt.GetYear())
2229 {
2230 format.Append(wxT("%Y"));
2231 p += 4;
2232 }
2233 else if (n == (dt.GetYear() % 100))
2234 {
2235 if (showCentury)
2236 format.Append(wxT("%Y"));
2237 else
2238 format.Append(wxT("%y"));
2239 p += 2;
2240 }
2241 else
2242 format.Append(*p++);
2243 }
2244
2245 return format;
2246}
2247
2248bool wxDateProperty::DoSetAttribute( const wxString& name, wxVariant& value )
2249{
2250 if ( name == wxPG_DATE_FORMAT )
2251 {
2252 m_format = value.GetString();
2253 return true;
2254 }
2255 else if ( name == wxPG_DATE_PICKER_STYLE )
2256 {
2257 m_dpStyle = value.GetLong();
2258 ms_defaultDateFormat.clear(); // This may need recalculation
2259 return true;
2260 }
2261 return false;
2262}
2263
2264#endif // wxUSE_DATETIME
2265
2266
2267// -----------------------------------------------------------------------
2268// wxPropertyGridInterface
2269// -----------------------------------------------------------------------
2270
2271void wxPropertyGridInterface::InitAllTypeHandlers()
2272{
2273}
2274
2275// -----------------------------------------------------------------------
2276
2277void wxPropertyGridInterface::RegisterAdditionalEditors()
2278{
2279 // Register editor classes, if necessary.
2280 if ( wxPGGlobalVars->m_mapEditorClasses.empty() )
2281 wxPropertyGrid::RegisterDefaultEditors();
2282
2283#if wxUSE_SPINBTN
2284 wxPGRegisterEditorClass(SpinCtrl);
2285#endif
2286#if wxUSE_DATEPICKCTRL
2287 wxPGRegisterEditorClass(DatePickerCtrl);
2288#endif
2289}
2290
2291// -----------------------------------------------------------------------
2292
2293#endif // wxPG_INCLUDE_ADVPROPS
2294
2295#endif // wxUSE_PROPGRID
2296
wxWidgets (Impactor)