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