1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/propgrid/advprops.cpp
3 // Purpose: wxPropertyGrid Advanced Properties (font, colour, etc.)
4 // Author: Jaakko Salli
8 // Copyright: (c) Jaakko Salli
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx/wx.h".
13 #include "wx/wxprec.h"
23 #include "wx/object.h"
25 #include "wx/string.h"
28 #include "wx/window.h"
31 #include "wx/dcclient.h"
32 #include "wx/button.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"
46 #include "wx/textdlg.h"
47 #include "wx/filedlg.h"
49 #include "wx/wxcrtvararg.h"
52 #define __wxPG_SOURCE_FILE__
54 #include "wx/propgrid/propgrid.h"
56 #if wxPG_INCLUDE_ADVPROPS
58 #include "wx/propgrid/advprops.h"
61 #include "wx/msw/private.h"
62 #include "wx/msw/dc.h"
65 #include "wx/odcombo.h"
67 // -----------------------------------------------------------------------
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
76 #define wxPG_CAN_DRAW_CURSOR 0
80 // -----------------------------------------------------------------------
82 // -----------------------------------------------------------------------
85 // Implement dynamic class for type value.
86 IMPLEMENT_DYNAMIC_CLASS(wxColourPropertyValue
, wxObject
)
88 bool operator == (const wxColourPropertyValue
& a
, const wxColourPropertyValue
& b
)
90 return ( ( a
.m_colour
== b
.m_colour
) && (a
.m_type
== b
.m_type
) );
93 bool operator == (const wxArrayInt
& array1
, const wxArrayInt
& array2
)
95 if ( array1
.size() != array2
.size() )
98 for ( i
=0; i
<array1
.size(); i
++ )
100 if ( array1
[i
] != array2
[i
] )
106 // -----------------------------------------------------------------------
107 // wxSpinCtrl-based property editor
108 // -----------------------------------------------------------------------
114 #define IS_MOTION_SPIN_SUPPORTED 1
116 #define IS_MOTION_SPIN_SUPPORTED 0
119 #if IS_MOTION_SPIN_SUPPORTED
122 // This class implements ability to rapidly change "spin" value
123 // by moving mouse when one of the spin buttons is depressed.
124 class wxPGSpinButton
: public wxSpinButton
127 wxPGSpinButton() : wxSpinButton()
130 m_hasCapture
= false;
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
) );
149 wxPoint m_ptPosition
;
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.
160 // SpinButton seems to be a special for mouse capture, so we may need track
161 // privately whether mouse is actually captured.
172 SetCursor(wxCURSOR_SIZENS
);
181 m_hasCapture
= false;
184 wxWindow
*parent
= GetParent();
186 SetCursor(parent
->GetCursor());
188 SetCursor(wxNullCursor
);
191 void OnMouseEvent(wxMouseEvent
& event
)
193 if ( event
.GetEventType() == wxEVT_LEFT_DOWN
)
196 m_ptPosition
= event
.GetPosition();
198 else if ( event
.GetEventType() == wxEVT_LEFT_UP
)
203 else if ( event
.GetEventType() == wxEVT_MOTION
)
207 int dy
= m_ptPosition
.y
- event
.GetPosition().y
;
211 m_ptPosition
= event
.GetPosition();
213 wxSpinEvent
evtscroll( (dy
>= 0) ? wxEVT_SCROLL_LINEUP
:
214 wxEVT_SCROLL_LINEDOWN
,
216 evtscroll
.SetEventObject(this);
218 wxASSERT( m_spins
== 1 );
221 GetEventHandler()->ProcessEvent(evtscroll
);
229 void OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
235 #endif // IS_MOTION_SPIN_SUPPORTED
238 WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(SpinCtrl
,
243 // Trivial destructor.
244 wxPGSpinCtrlEditor::~wxPGSpinCtrlEditor()
249 // Create controls and initialize event handling.
250 wxPGWindowList
wxPGSpinCtrlEditor::CreateControls( wxPropertyGrid
* propgrid
, wxPGProperty
* property
,
251 const wxPoint
& pos
, const wxSize
& sz
) const
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
);
260 #if IS_MOTION_SPIN_SUPPORTED
261 if ( property
->GetAttributeAsLong(wxT("MotionSpin"), 0) )
263 wnd2
= new wxPGSpinButton();
268 wnd2
= new wxSpinButton();
274 wnd2
->Create( propgrid
->GetPanel(), wxPG_SUBID2
, butPos
, butSz
, wxSP_VERTICAL
);
276 wnd2
->SetRange( INT_MIN
, INT_MAX
);
279 wxWindow
* wnd1
= wxPGTextCtrlEditor::CreateControls(propgrid
, property
, pos
, tcSz
).m_primary
;
281 // Let's add validator to make sure only numbers can be entered
282 wxTextValidator
validator(wxFILTER_NUMERIC
, &m_tempString
);
283 wnd1
->SetValidator(validator
);
286 return wxPGWindowList(wnd1
, wnd2
);
289 // Control's events are redirected here
290 bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid
* propgrid
, wxPGProperty
* property
,
291 wxWindow
* wnd
, wxEvent
& event
) const
293 int evtType
= event
.GetEventType();
296 bool bigStep
= false;
298 if ( evtType
== wxEVT_KEY_DOWN
)
300 wxKeyEvent
& keyEvent
= (wxKeyEvent
&)event
;
301 keycode
= keyEvent
.GetKeyCode();
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
)
309 evtType
= wxEVT_SCROLL_LINEUP
;
312 else if ( keycode
== WXK_PAGEDOWN
)
314 evtType
= wxEVT_SCROLL_LINEDOWN
;
319 if ( evtType
== wxEVT_SCROLL_LINEUP
|| evtType
== wxEVT_SCROLL_LINEDOWN
)
321 #if IS_MOTION_SPIN_SUPPORTED
322 if ( property
->GetAttributeAsLong(wxT("MotionSpin"), 0) )
324 wxPGSpinButton
* spinButton
=
325 (wxPGSpinButton
*) propgrid
->GetEditorControlSecondary();
328 spins
= spinButton
->GetSpins();
333 // Can't use wnd since it might be clipper window
334 wxTextCtrl
* tc
= wxDynamicCast(propgrid
->GetEditorControl(), wxTextCtrl
);
339 s
= property
->GetValueAsString(wxPG_FULL_VALUE
);
341 int mode
= wxPG_PROPERTY_VALIDATION_SATURATE
;
343 if ( property
->GetAttributeAsLong(wxT("Wrap"), 0) )
344 mode
= wxPG_PROPERTY_VALIDATION_WRAP
;
346 if ( property
->GetValueType() == wxT("double") )
349 double step
= property
->GetAttributeAsDouble(wxT("Step"), 1.0);
352 if ( s
.ToDouble(&v_d
) )
357 step
*= (double) spins
;
359 if ( evtType
== wxEVT_SCROLL_LINEUP
) v_d
+= step
;
363 wxFloatProperty::DoValidation(property
, v_d
, NULL
, mode
);
365 wxPropertyGrid::DoubleToString(s
, v_d
, 6, true, NULL
);
375 wxLongLong_t step
= property
->GetAttributeAsLong(wxT("Step"), 1);
378 if ( s
.ToLongLong(&v_ll
, 10) )
385 if ( evtType
== wxEVT_SCROLL_LINEUP
) v_ll
+= step
;
389 wxIntProperty::DoValidation(property
, v_ll
, NULL
, mode
);
391 s
= wxLongLong(v_ll
).ToString();
401 int ip
= tc
->GetInsertionPoint();
402 int lp
= tc
->GetLastPosition();
404 tc
->SetInsertionPoint(ip
+(tc
->GetLastPosition()-lp
));
410 return wxPGTextCtrlEditor::OnEvent(propgrid
,property
,wnd
,event
);
413 #endif // wxUSE_SPINBTN
416 // -----------------------------------------------------------------------
417 // wxDatePickerCtrl-based property editor
418 // -----------------------------------------------------------------------
420 #if wxUSE_DATEPICKCTRL
423 #include "wx/datectrl.h"
424 #include "wx/dateevt.h"
426 class wxPGDatePickerCtrlEditor
: public wxPGEditor
428 DECLARE_DYNAMIC_CLASS(wxPGDatePickerCtrlEditor
)
430 virtual ~wxPGDatePickerCtrlEditor();
432 wxString
GetName() const;
433 virtual wxPGWindowList
CreateControls(wxPropertyGrid
* propgrid
,
434 wxPGProperty
* property
,
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;
445 WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(DatePickerCtrl
,
446 wxPGDatePickerCtrlEditor
,
450 wxPGDatePickerCtrlEditor::~wxPGDatePickerCtrlEditor()
454 wxPGWindowList
wxPGDatePickerCtrlEditor::CreateControls( wxPropertyGrid
* propgrid
,
455 wxPGProperty
* property
,
457 const wxSize
& sz
) const
459 wxCHECK_MSG( property
->IsKindOf(CLASSINFO(wxDateProperty
)),
461 wxT("DatePickerCtrl editor can only be used with wxDateProperty or derivative.") );
463 wxDateProperty
* prop
= wxDynamicCast(property
, wxDateProperty
);
465 // Use two stage creation to allow cleaner display on wxMSW
466 wxDatePickerCtrl
* ctrl
= new wxDatePickerCtrl();
469 wxSize useSz
= wxDefaultSize
;
475 wxDateTime
dateValue(wxInvalidDateTime
);
477 wxVariant value
= prop
->GetValue();
478 if ( value
.GetType() == wxT("datetime") )
479 dateValue
= value
.GetDateTime();
481 ctrl
->Create(propgrid
->GetPanel(),
486 prop
->GetDatePickerStyle() | wxNO_BORDER
);
495 // Copies value from property to control
496 void wxPGDatePickerCtrlEditor::UpdateControl( wxPGProperty
* property
,
497 wxWindow
* wnd
) const
499 wxDatePickerCtrl
* ctrl
= (wxDatePickerCtrl
*) wnd
;
500 wxASSERT( ctrl
&& ctrl
->IsKindOf(CLASSINFO(wxDatePickerCtrl
)) );
502 wxDateTime
dateValue(wxInvalidDateTime
);
503 wxVariant
v(property
->GetValue());
504 if ( v
.GetType() == wxT("datetime") )
505 dateValue
= v
.GetDateTime();
507 ctrl
->SetValue( dateValue
);
510 // Control's events are redirected here
511 bool wxPGDatePickerCtrlEditor::OnEvent( wxPropertyGrid
* WXUNUSED(propgrid
),
512 wxPGProperty
* WXUNUSED(property
),
513 wxWindow
* WXUNUSED(wnd
),
514 wxEvent
& event
) const
516 if ( event
.GetEventType() == wxEVT_DATE_CHANGED
)
522 bool wxPGDatePickerCtrlEditor::GetValueFromControl( wxVariant
& variant
, wxPGProperty
* WXUNUSED(property
), wxWindow
* wnd
) const
524 wxDatePickerCtrl
* ctrl
= (wxDatePickerCtrl
*) wnd
;
525 wxASSERT( ctrl
&& ctrl
->IsKindOf(CLASSINFO(wxDatePickerCtrl
)) );
527 variant
= ctrl
->GetValue();
532 void wxPGDatePickerCtrlEditor::SetValueToUnspecified( wxPGProperty
* property
,
533 wxWindow
* wnd
) const
535 wxDatePickerCtrl
* ctrl
= (wxDatePickerCtrl
*) wnd
;
536 wxASSERT( ctrl
&& ctrl
->IsKindOf(CLASSINFO(wxDatePickerCtrl
)) );
538 wxDateProperty
* prop
= wxDynamicCast(property
, wxDateProperty
);
542 int datePickerStyle
= prop
->GetDatePickerStyle();
543 if ( datePickerStyle
& wxDP_ALLOWNONE
)
544 ctrl
->SetValue(wxInvalidDateTime
);
548 #endif // wxUSE_DATEPICKCTRL
551 // -----------------------------------------------------------------------
553 // -----------------------------------------------------------------------
555 #include "wx/fontdlg.h"
556 #include "wx/fontenum.h"
558 static const wxChar
* gs_fp_es_family_labels
[] = {
559 wxS("Default"), wxS("Decorative"),
560 wxS("Roman"), wxS("Script"),
561 wxS("Swiss"), wxS("Modern"),
562 wxS("Teletype"), wxS("Unknown"),
566 static long gs_fp_es_family_values
[] = {
567 wxFONTFAMILY_DEFAULT
, wxFONTFAMILY_DECORATIVE
,
568 wxFONTFAMILY_ROMAN
, wxFONTFAMILY_SCRIPT
,
569 wxFONTFAMILY_SWISS
, wxFONTFAMILY_MODERN
,
570 wxFONTFAMILY_TELETYPE
, wxFONTFAMILY_UNKNOWN
573 static const wxChar
* gs_fp_es_style_labels
[] = {
580 static long gs_fp_es_style_values
[] = {
586 static const wxChar
* gs_fp_es_weight_labels
[] = {
593 static long gs_fp_es_weight_values
[] = {
599 // Class body is in advprops.h
602 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFontProperty
,wxPGProperty
,
603 wxFont
,const wxFont
&,TextCtrlAndButton
)
606 wxFontProperty::wxFontProperty( const wxString
& label
, const wxString
& name
,
607 const wxFont
& value
)
608 : wxPGProperty(label
,name
)
610 SetValue(WXVARIANT(value
));
612 // Initialize font family choices list
613 if ( !wxPGGlobalVars
->m_fontFamilyChoices
)
615 wxArrayString faceNames
= wxFontEnumerator::GetFacenames();
619 wxPGGlobalVars
->m_fontFamilyChoices
= new wxPGChoices(faceNames
);
622 wxString
emptyString(wxEmptyString
);
627 AddPrivateChild( new wxIntProperty( _("Point Size"),
628 wxS("Point Size"),(long)font
.GetPointSize() ) );
630 wxString faceName
= font
.GetFaceName();
631 // If font was not in there, add it now
632 if ( faceName
.length() &&
633 wxPGGlobalVars
->m_fontFamilyChoices
->Index(faceName
) == wxNOT_FOUND
)
634 wxPGGlobalVars
->m_fontFamilyChoices
->AddAsSorted(faceName
);
636 wxPGProperty
* p
= new wxEnumProperty(_("Face Name"), wxS("Face Name"),
637 *wxPGGlobalVars
->m_fontFamilyChoices
);
639 p
->SetValueFromString(faceName
, wxPG_FULL_VALUE
);
641 AddPrivateChild( p
);
643 AddPrivateChild( new wxEnumProperty(_("Style"), wxS("Style"),
644 gs_fp_es_style_labels
,gs_fp_es_style_values
,
647 AddPrivateChild( new wxEnumProperty(_("Weight"), wxS("Weight"),
648 gs_fp_es_weight_labels
,gs_fp_es_weight_values
,
651 AddPrivateChild( new wxBoolProperty(_("Underlined"), wxS("Underlined"),
652 font
.GetUnderlined()) );
654 AddPrivateChild( new wxEnumProperty(_("Family"), wxS("PointSize"),
655 gs_fp_es_family_labels
,gs_fp_es_family_values
,
659 wxFontProperty::~wxFontProperty() { }
661 void wxFontProperty::OnSetValue()
668 m_value
<< *wxNORMAL_FONT
;
672 wxString
wxFontProperty::ValueToString( wxVariant
& value
,
675 return wxPGProperty::ValueToString(value
, argFlags
);
678 bool wxFontProperty::OnEvent( wxPropertyGrid
* propgrid
, wxWindow
* WXUNUSED(primary
),
681 if ( propgrid
->IsMainButtonEvent(event
) )
683 // Update value from last minute changes
684 wxVariant useValue
= propgrid
->GetUncommittedPropertyValue();
689 data
.SetInitialFont( font
);
690 data
.SetColour(*wxBLACK
);
692 wxFontDialog
dlg(propgrid
, data
);
693 if ( dlg
.ShowModal() == wxID_OK
)
695 propgrid
->EditorsValueWasModified();
698 variant
<< dlg
.GetFontData().GetChosenFont();
699 SetValueInEvent( variant
);
706 void wxFontProperty::RefreshChildren()
708 if ( !GetChildCount() ) return;
711 Item(0)->SetValue( (long)font
.GetPointSize() );
712 Item(1)->SetValueFromString( font
.GetFaceName(), wxPG_FULL_VALUE
);
713 Item(2)->SetValue( (long)font
.GetStyle() );
714 Item(3)->SetValue( (long)font
.GetWeight() );
715 Item(4)->SetValue( font
.GetUnderlined() );
716 Item(5)->SetValue( (long)font
.GetFamily() );
719 wxVariant
wxFontProperty::ChildChanged( wxVariant
& thisValue
,
721 wxVariant
& childValue
) const
728 font
.SetPointSize( childValue
.GetLong() );
733 int faceIndex
= childValue
.GetLong();
735 if ( faceIndex
>= 0 )
736 faceName
= wxPGGlobalVars
->m_fontFamilyChoices
->GetLabel(faceIndex
);
738 font
.SetFaceName( faceName
);
742 int st
= childValue
.GetLong();
743 if ( st
!= wxFONTSTYLE_NORMAL
&&
744 st
!= wxFONTSTYLE_SLANT
&&
745 st
!= wxFONTSTYLE_ITALIC
)
746 st
= wxFONTWEIGHT_NORMAL
;
751 int wt
= childValue
.GetLong();
752 if ( wt
!= wxFONTWEIGHT_NORMAL
&&
753 wt
!= wxFONTWEIGHT_LIGHT
&&
754 wt
!= wxFONTWEIGHT_BOLD
)
755 wt
= wxFONTWEIGHT_NORMAL
;
756 font
.SetWeight( wt
);
760 font
.SetUnderlined( childValue
.GetBool() );
764 int fam
= childValue
.GetLong();
765 if ( fam
< wxDEFAULT
||
768 font
.SetFamily( fam
);
771 wxVariant newVariant
;
777 wxSize wxFontProperty::OnMeasureImage() const
779 return wxSize(-1,-1);
782 void wxFontProperty::OnCustomPaint(wxDC& dc,
784 wxPGPaintData& paintData)
787 if ( paintData.m_choiceItem >= 0 )
788 drawFace = wxPGGlobalVars->m_fontFamilyChoices->GetLabel(paintData.m_choiceItem);
790 drawFace = m_value_wxFont.GetFaceName();
792 if ( drawFace.length() )
794 // Draw the background
795 dc.SetBrush( wxColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)) );
796 //dc.SetBrush( *wxWHITE_BRUSH );
797 //dc.SetPen( *wxMEDIUM_GREY_PEN );
798 dc.DrawRectangle( rect );
800 wxFont oldFont = dc.GetFont();
801 wxFont drawFont(oldFont.GetPointSize(),
802 wxDEFAULT,wxNORMAL,wxBOLD,false,drawFace);
803 dc.SetFont(drawFont);
805 dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT) );
806 dc.DrawText( wxT("Aa"), rect.x+2, rect.y+1 );
812 // No file - just draw a white box
813 dc.SetBrush ( *wxWHITE_BRUSH );
814 dc.DrawRectangle ( rect );
820 // -----------------------------------------------------------------------
821 // wxSystemColourProperty
822 // -----------------------------------------------------------------------
824 // wxEnumProperty based classes cannot use wxPG_PROP_CLASS_SPECIFIC_1
825 #define wxPG_PROP_HIDE_CUSTOM_COLOUR wxPG_PROP_CLASS_SPECIFIC_2
827 #include "wx/colordlg.h"
829 //#define wx_cp_es_syscolours_len 25
830 static const wxChar
* gs_cp_es_syscolour_labels
[] = {
833 wxT("ActiveCaption"),
835 wxT("ButtonHighlight"),
844 wxT("HighlightText"),
845 wxT("InactiveBorder"),
846 wxT("InactiveCaption"),
847 wxT("InactiveCaptionText"),
859 static long gs_cp_es_syscolour_values
[] = {
860 wxSYS_COLOUR_APPWORKSPACE
,
861 wxSYS_COLOUR_ACTIVEBORDER
,
862 wxSYS_COLOUR_ACTIVECAPTION
,
863 wxSYS_COLOUR_BTNFACE
,
864 wxSYS_COLOUR_BTNHIGHLIGHT
,
865 wxSYS_COLOUR_BTNSHADOW
,
866 wxSYS_COLOUR_BTNTEXT
,
867 wxSYS_COLOUR_CAPTIONTEXT
,
868 wxSYS_COLOUR_3DDKSHADOW
,
869 wxSYS_COLOUR_3DLIGHT
,
870 wxSYS_COLOUR_BACKGROUND
,
871 wxSYS_COLOUR_GRAYTEXT
,
872 wxSYS_COLOUR_HIGHLIGHT
,
873 wxSYS_COLOUR_HIGHLIGHTTEXT
,
874 wxSYS_COLOUR_INACTIVEBORDER
,
875 wxSYS_COLOUR_INACTIVECAPTION
,
876 wxSYS_COLOUR_INACTIVECAPTIONTEXT
,
878 wxSYS_COLOUR_SCROLLBAR
,
880 wxSYS_COLOUR_INFOTEXT
,
882 wxSYS_COLOUR_WINDOWFRAME
,
883 wxSYS_COLOUR_WINDOWTEXT
,
888 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxColourPropertyValue
, WXDLLIMPEXP_PROPGRID
)
891 // Class body is in advprops.h
893 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxSystemColourProperty
,wxEnumProperty
,
894 wxColourPropertyValue
,const wxColourPropertyValue
&,Choice
)
897 void wxSystemColourProperty::Init( int type
, const wxColour
& colour
)
899 wxColourPropertyValue cpv
;
902 cpv
.Init( type
, colour
);
904 cpv
.Init( type
, *wxWHITE
);
906 m_flags
|= wxPG_PROP_STATIC_CHOICES
; // Colour selection cannot be changed.
914 static wxPGChoices gs_wxSystemColourProperty_choicesCache
;
917 wxSystemColourProperty::wxSystemColourProperty( const wxString
& label
, const wxString
& name
,
918 const wxColourPropertyValue
& value
)
919 : wxEnumProperty( label
,
921 gs_cp_es_syscolour_labels
,
922 gs_cp_es_syscolour_values
,
923 &gs_wxSystemColourProperty_choicesCache
)
926 Init( value
.m_type
, value
.m_colour
);
928 Init( wxPG_COLOUR_CUSTOM
, *wxWHITE
);
932 wxSystemColourProperty::wxSystemColourProperty( const wxString
& label
, const wxString
& name
,
933 const wxChar
** labels
, const long* values
, wxPGChoices
* choicesCache
,
934 const wxColourPropertyValue
& value
)
935 : wxEnumProperty( label
, name
, labels
, values
, choicesCache
)
938 Init( value
.m_type
, value
.m_colour
);
940 Init( wxPG_COLOUR_CUSTOM
, *wxWHITE
);
944 wxSystemColourProperty::wxSystemColourProperty( const wxString
& label
, const wxString
& name
,
945 const wxChar
** labels
, const long* values
, wxPGChoices
* choicesCache
,
946 const wxColour
& value
)
947 : wxEnumProperty( label
, name
, labels
, values
, choicesCache
)
950 Init( wxPG_COLOUR_CUSTOM
, value
);
952 Init( wxPG_COLOUR_CUSTOM
, *wxWHITE
);
956 wxSystemColourProperty::~wxSystemColourProperty() { }
959 wxColourPropertyValue
wxSystemColourProperty::GetVal( const wxVariant
* pVariant
) const
964 if ( pVariant
->IsNull() )
965 return wxColourPropertyValue(wxPG_COLOUR_UNSPECIFIED
, wxColour());
967 if ( pVariant
->GetType() == wxS("wxColourPropertyValue") )
969 wxColourPropertyValue v
;
975 bool variantProcessed
= true;
977 if ( pVariant
->GetType() == wxS("wxColour*") )
979 wxColour
* pCol
= wxStaticCast(pVariant
->GetWxObjectPtr(), wxColour
);
982 else if ( pVariant
->GetType() == wxS("wxColour") )
986 else if ( pVariant
->GetType() == wxArrayInt_VariantType
)
988 // This code is mostly needed for wxPython bindings, which
989 // may offer tuple of integers as colour value.
993 if ( arr
.size() >= 3 )
1001 if ( arr
.size() >= 4 )
1004 col
= wxColour(r
, g
, b
, a
);
1008 variantProcessed
= false;
1013 variantProcessed
= false;
1016 if ( !variantProcessed
)
1017 return wxColourPropertyValue(wxPG_COLOUR_UNSPECIFIED
, wxColour());
1019 wxColourPropertyValue
v2( wxPG_COLOUR_CUSTOM
, col
);
1021 int colInd
= ColToInd(col
);
1022 if ( colInd
!= wxNOT_FOUND
)
1028 wxVariant
wxSystemColourProperty::DoTranslateVal( wxColourPropertyValue
& v
) const
1035 int wxSystemColourProperty::ColToInd( const wxColour
& colour
) const
1038 size_t i_max
= m_choices
.GetCount();
1040 if ( !(m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1043 for ( i
=0; i
<i_max
; i
++ )
1045 int ind
= m_choices
[i
].GetValue();
1047 if ( colour
== GetColour(ind
) )
1049 /*wxLogDebug(wxT("%s(%s): Index %i for ( getcolour(%i,%i,%i), colour(%i,%i,%i))"),
1050 GetClassName(),GetLabel().c_str(),
1051 (int)i,(int)GetColour(ind).Red(),(int)GetColour(ind).Green(),(int)GetColour(ind).Blue(),
1052 (int)colour.Red(),(int)colour.Green(),(int)colour.Blue());*/
1059 void wxSystemColourProperty::OnSetValue()
1061 // Convert from generic wxobject ptr to wxPGVariantDataColour
1062 if ( m_value
.GetType() == wxS("wxColour*") )
1064 wxColour
* pCol
= wxStaticCast(m_value
.GetWxObjectPtr(), wxColour
);
1068 wxColourPropertyValue val
= GetVal(&m_value
);
1070 if ( val
.m_type
== wxPG_COLOUR_UNSPECIFIED
)
1078 if ( val
.m_type
< wxPG_COLOUR_WEB_BASE
)
1079 val
.m_colour
= GetColour( val
.m_type
);
1081 m_value
= TranslateVal(val
);
1084 int ind
= wxNOT_FOUND
;
1086 if ( m_value
.GetType() == wxS("wxColourPropertyValue") )
1088 wxColourPropertyValue cpv
;
1090 wxColour col
= cpv
.m_colour
;
1094 SetValueToUnspecified();
1095 SetIndex(wxNOT_FOUND
);
1099 if ( cpv
.m_type
< wxPG_COLOUR_WEB_BASE
||
1100 (m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1102 ind
= GetIndexForValue(cpv
.m_type
);
1106 cpv
.m_type
= wxPG_COLOUR_CUSTOM
;
1107 ind
= GetCustomColourIndex();
1117 SetValueToUnspecified();
1118 SetIndex(wxNOT_FOUND
);
1122 ind
= ColToInd(col
);
1124 if ( ind
== wxNOT_FOUND
&&
1125 !(m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1126 ind
= GetCustomColourIndex();
1133 wxColour
wxSystemColourProperty::GetColour( int index
) const
1135 return wxSystemSettings::GetColour( (wxSystemColour
)index
);
1138 wxString
wxSystemColourProperty::ColourToString( const wxColour
& col
, int index
) const
1140 if ( index
== wxNOT_FOUND
)
1141 return wxString::Format(wxT("(%i,%i,%i)"),
1146 return m_choices
.GetLabel(index
);
1149 wxString
wxSystemColourProperty::ValueToString( wxVariant
& value
,
1150 int argFlags
) const
1152 wxColourPropertyValue val
= GetVal(&value
);
1156 if ( argFlags
& wxPG_VALUE_IS_CURRENT
)
1158 // GetIndex() only works reliably if wxPG_VALUE_IS_CURRENT flag is set,
1159 // but we should use it whenever possible.
1162 // If custom colour was selected, use invalid index, so that
1163 // ColourToString() will return properly formatted colour text.
1164 if ( index
== GetCustomColourIndex() &&
1165 !(m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1166 index
= wxNOT_FOUND
;
1170 index
= m_choices
.Index(val
.m_type
);
1173 return ColourToString(val
.m_colour
, index
);
1177 wxSize
wxSystemColourProperty::OnMeasureImage( int ) const
1179 return wxPG_DEFAULT_IMAGE_SIZE
;
1183 int wxSystemColourProperty::GetCustomColourIndex() const
1185 return m_choices
.GetCount() - 1;
1189 bool wxSystemColourProperty::QueryColourFromUser( wxVariant
& variant
) const
1191 wxASSERT( m_value
.GetType() != wxPG_VARIANT_TYPE_STRING
);
1194 wxPropertyGrid
* propgrid
= GetGrid();
1195 wxASSERT( propgrid
);
1197 // Must only occur when user triggers event
1198 if ( !(propgrid
->GetInternalFlags() & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT
) )
1201 wxColourPropertyValue val
= GetVal();
1203 val
.m_type
= wxPG_COLOUR_CUSTOM
;
1206 data
.SetChooseFull(true);
1207 data
.SetColour(val
.m_colour
);
1209 for ( i
= 0; i
< 16; i
++)
1211 wxColour
colour(i
*16, i
*16, i
*16);
1212 data
.SetCustomColour(i
, colour
);
1215 wxColourDialog
dialog(propgrid
, &data
);
1216 if ( dialog
.ShowModal() == wxID_OK
)
1218 wxColourData retData
= dialog
.GetColourData();
1219 val
.m_colour
= retData
.GetColour();
1221 variant
= DoTranslateVal(val
);
1223 SetValueInEvent(variant
);
1232 bool wxSystemColourProperty::IntToValue( wxVariant
& variant
, int number
, int WXUNUSED(argFlags
) ) const
1235 int type
= m_choices
.GetValue(index
);
1237 if ( type
== wxPG_COLOUR_CUSTOM
)
1239 QueryColourFromUser(variant
);
1243 variant
= TranslateVal( type
, GetColour(type
) );
1249 // Need to do some extra event handling.
1250 bool wxSystemColourProperty::OnEvent( wxPropertyGrid
* propgrid
,
1251 wxWindow
* WXUNUSED(primary
),
1254 bool askColour
= false;
1256 if ( propgrid
->IsMainButtonEvent(event
) )
1258 // We need to handle button click in case editor has been
1259 // switched to one that has wxButton as well.
1262 else if ( event
.GetEventType() == wxEVT_COMMAND_COMBOBOX_SELECTED
)
1264 // Must override index detection since at this point GetIndex()
1265 // will return old value.
1266 wxOwnerDrawnComboBox
* cb
=
1267 static_cast<wxOwnerDrawnComboBox
*>(propgrid
->GetEditorControl());
1271 int index
= cb
->GetSelection();
1273 if ( index
== GetCustomColourIndex() &&
1274 !(m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1279 if ( askColour
&& !propgrid
->WasValueChangedInEvent() )
1282 if ( QueryColourFromUser(variant
) )
1288 /*class wxPGColourPropertyRenderer : public wxPGDefaultRenderer
1291 virtual void Render( wxDC& dc, const wxRect& rect,
1292 const wxPropertyGrid* propertyGrid, wxPGProperty* property,
1293 int WXUNUSED(column), int item, int WXUNUSED(flags) ) const
1295 wxASSERT( property->IsKindOf(CLASSINFO(wxSystemColourProperty)) );
1296 wxSystemColourProperty* prop = wxStaticCast(property, wxSystemColourProperty);
1298 dc.SetPen(*wxBLACK_PEN);
1300 ( item < (int)(GetCustomColourIndex) || (prop->HasFlag(wxPG_PROP_HIDE_CUSTOM_COLOUR)))
1304 const wxArrayInt& values = prop->GetValues();
1305 if ( values.GetChildCount() )
1306 colInd = values[item];
1309 dc.SetBrush( wxColour( prop->GetColour( colInd ) ) );
1311 else if ( !prop->IsValueUnspecified() )
1312 dc.SetBrush( prop->GetVal().m_colour );
1314 dc.SetBrush( *wxWHITE );
1316 wxRect imageRect = propertyGrid->GetImageRect(property, item);
1317 wxLogDebug(wxT("%i, %i"),imageRect.x,imageRect.y);
1318 dc.DrawRectangle( rect.x+imageRect.x, rect.y+imageRect.y,
1319 imageRect.width, imageRect.height );
1323 text = property->GetValueAsString();
1325 text = property->GetChoiceString(item);
1326 DrawText( dc, rect, imageRect.width, text );
1331 wxPGColourPropertyRenderer g_wxPGColourPropertyRenderer;
1333 wxPGCellRenderer* wxSystemColourProperty::GetCellRenderer( int column ) const
1336 return &g_wxPGColourPropertyRenderer;
1337 return wxEnumProperty::GetCellRenderer(column);
1340 void wxSystemColourProperty::OnCustomPaint( wxDC
& dc
, const wxRect
& rect
,
1341 wxPGPaintData
& paintdata
)
1345 if ( paintdata
.m_choiceItem
>= 0 &&
1346 paintdata
.m_choiceItem
< (int)m_choices
.GetCount() &&
1347 (paintdata
.m_choiceItem
!= GetCustomColourIndex() ||
1348 m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1350 int colInd
= m_choices
[paintdata
.m_choiceItem
].GetValue();
1351 col
= GetColour( colInd
);
1353 else if ( !IsValueUnspecified() )
1355 col
= GetVal().m_colour
;
1361 dc
.DrawRectangle(rect
);
1366 bool wxSystemColourProperty::StringToValue( wxVariant
& value
, const wxString
& text
, int argFlags
) const
1369 // Accept colour format "[Name] [(R,G,B)]"
1370 // Name takes precedence.
1372 wxString colourName
;
1375 int ppos
= text
.Find(wxT("("));
1377 if ( ppos
== wxNOT_FOUND
)
1383 colourName
= text
.substr(0, ppos
);
1384 colourRGB
= text
.substr(ppos
, text
.length()-ppos
);
1387 // Strip spaces from extremities
1388 colourName
.Trim(true);
1389 colourName
.Trim(false);
1390 colourRGB
.Trim(true);
1392 // Validate colourRGB string - (1,1,1) is shortest allowed
1393 if ( colourRGB
.length() < 7 )
1396 if ( colourRGB
.length() == 0 && m_choices
.GetCount() &&
1397 !(m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) &&
1398 colourName
== m_choices
.GetLabel(GetCustomColourIndex()) )
1400 if ( !(argFlags
& wxPG_EDITABLE_VALUE
))
1402 // This really should not occurr...
1408 QueryColourFromUser(value
);
1412 wxColourPropertyValue val
;
1416 if ( colourName
.length() )
1418 // Try predefined colour first
1419 bool res
= wxEnumProperty::StringToValue(value
, colourName
, argFlags
);
1420 if ( res
&& GetIndex() >= 0 )
1422 val
.m_type
= GetIndex();
1423 if ( val
.m_type
< m_choices
.GetCount() )
1424 val
.m_type
= m_choices
[val
.m_type
].GetValue();
1426 // Get proper colour for type.
1427 val
.m_colour
= GetColour(val
.m_type
);
1432 if ( colourRGB
.length() && !done
)
1434 // Then check custom colour.
1435 val
.m_type
= wxPG_COLOUR_CUSTOM
;
1437 int r
= -1, g
= -1, b
= -1;
1438 wxSscanf(colourRGB
.c_str(),wxT("(%i,%i,%i)"),&r
,&g
,&b
);
1440 if ( r
>= 0 && r
<= 255 &&
1441 g
>= 0 && g
<= 255 &&
1442 b
>= 0 && b
<= 255 )
1444 val
.m_colour
.Set(r
,g
,b
);
1456 value
= DoTranslateVal(val
);
1463 bool wxSystemColourProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
1465 if ( name
== wxPG_COLOUR_ALLOW_CUSTOM
)
1467 int ival
= value
.GetLong();
1469 if ( ival
&& (m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1471 // Show custom choice
1472 m_choices
.Insert(wxT("Custom"), GetCustomColourIndex(), wxPG_COLOUR_CUSTOM
);
1473 m_flags
&= ~(wxPG_PROP_HIDE_CUSTOM_COLOUR
);
1475 else if ( !ival
&& !(m_flags
& wxPG_PROP_HIDE_CUSTOM_COLOUR
) )
1477 // Hide custom choice
1478 m_choices
.RemoveAt(GetCustomColourIndex());
1479 m_flags
|= wxPG_PROP_HIDE_CUSTOM_COLOUR
;
1487 // -----------------------------------------------------------------------
1489 // -----------------------------------------------------------------------
1491 static const wxChar
* gs_cp_es_normcolour_labels
[] = {
1511 (const wxChar
*) NULL
1514 static unsigned long gs_cp_es_normcolour_colours
[] = {
1516 wxPG_COLOUR(128,0,0),
1517 wxPG_COLOUR(0,0,128),
1518 wxPG_COLOUR(128,0,128),
1519 wxPG_COLOUR(0,128,128),
1520 wxPG_COLOUR(128,128,128),
1521 wxPG_COLOUR(0,128,0),
1522 wxPG_COLOUR(128,128,0),
1523 wxPG_COLOUR(166,124,81),
1524 wxPG_COLOUR(0,0,255),
1525 wxPG_COLOUR(255,0,255),
1526 wxPG_COLOUR(255,0,0),
1527 wxPG_COLOUR(247,148,28),
1528 wxPG_COLOUR(192,192,192),
1529 wxPG_COLOUR(0,255,0),
1530 wxPG_COLOUR(0,255,255),
1531 wxPG_COLOUR(255,255,0),
1532 wxPG_COLOUR(255,255,255),
1536 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxColourProperty
, wxSystemColourProperty
,
1537 wxColour
, const wxColour
&, TextCtrlAndButton
)
1539 static wxPGChoices gs_wxColourProperty_choicesCache
;
1541 wxColourProperty::wxColourProperty( const wxString
& label
,
1542 const wxString
& name
,
1543 const wxColour
& value
)
1544 : wxSystemColourProperty(label
, name
, gs_cp_es_normcolour_labels
,
1546 &gs_wxColourProperty_choicesCache
, value
)
1550 m_flags
|= wxPG_PROP_TRANSLATE_CUSTOM
;
1553 wxColourProperty::~wxColourProperty()
1557 void wxColourProperty::Init( wxColour colour
)
1564 int ind
= ColToInd(colour
);
1566 ind
= m_choices
.GetCount() - 1;
1570 wxString
wxColourProperty::ValueToString( wxVariant
& value
,
1571 int argFlags
) const
1573 const wxPGEditor
* editor
= GetEditorClass();
1574 if ( editor
!= wxPGEditor_Choice
&&
1575 editor
!= wxPGEditor_ChoiceAndButton
&&
1576 editor
!= wxPGEditor_ComboBox
)
1577 argFlags
|= wxPG_PROPERTY_SPECIFIC
;
1579 return wxSystemColourProperty::ValueToString(value
, argFlags
);
1582 wxColour
wxColourProperty::GetColour( int index
) const
1584 return gs_cp_es_normcolour_colours
[m_choices
.GetValue(index
)];
1587 wxVariant
wxColourProperty::DoTranslateVal( wxColourPropertyValue
& v
) const
1590 variant
<< v
.m_colour
;
1594 // -----------------------------------------------------------------------
1596 // -----------------------------------------------------------------------
1598 #define wxPG_CURSOR_IMAGE_WIDTH 32
1600 #define NUM_CURSORS 28
1602 //#define wx_cp_es_syscursors_len 28
1603 static const wxChar
* gs_cp_es_syscursors_labels
[NUM_CURSORS
+1] = {
1615 wxT("Middle Button"),
1621 wxT("Question Arrow"),
1622 wxT("Right Button"),
1623 wxT("Sizing NE-SW"),
1625 wxT("Sizing NW-SE"),
1632 (const wxChar
*) NULL
1635 static long gs_cp_es_syscursors_values
[NUM_CURSORS
] = {
1638 wxCURSOR_RIGHT_ARROW
,
1645 wxCURSOR_LEFT_BUTTON
,
1647 wxCURSOR_MIDDLE_BUTTON
,
1649 wxCURSOR_PAINT_BRUSH
,
1651 wxCURSOR_POINT_LEFT
,
1652 wxCURSOR_POINT_RIGHT
,
1653 wxCURSOR_QUESTION_ARROW
,
1654 wxCURSOR_RIGHT_BUTTON
,
1666 IMPLEMENT_DYNAMIC_CLASS(wxCursorProperty
, wxEnumProperty
)
1668 wxCursorProperty::wxCursorProperty( const wxString
& label
, const wxString
& name
,
1670 : wxEnumProperty( label
,
1672 gs_cp_es_syscursors_labels
,
1673 gs_cp_es_syscursors_values
,
1676 m_flags
|= wxPG_PROP_STATIC_CHOICES
; // Cursor selection cannot be changed.
1679 wxCursorProperty::~wxCursorProperty()
1683 wxSize
wxCursorProperty::OnMeasureImage( int item
) const
1685 #if wxPG_CAN_DRAW_CURSOR
1686 if ( item
!= -1 && item
< NUM_CURSORS
)
1687 return wxSize(wxPG_CURSOR_IMAGE_WIDTH
,wxPG_CURSOR_IMAGE_WIDTH
);
1694 #if wxPG_CAN_DRAW_CURSOR
1696 void wxCursorProperty::OnCustomPaint( wxDC
& dc
,
1698 wxPGPaintData
& paintdata
)
1701 dc
.SetBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
) );
1703 if ( paintdata
.m_choiceItem
>= 0 )
1705 dc
.DrawRectangle( rect
);
1707 if ( paintdata
.m_choiceItem
< NUM_CURSORS
)
1709 wxStockCursor cursorIndex
=
1710 (wxStockCursor
) gs_cp_es_syscursors_values
[paintdata
.m_choiceItem
];
1713 if ( cursorIndex
== wxCURSOR_NONE
)
1714 cursorIndex
= wxCURSOR_ARROW
;
1716 wxCursor
cursor( cursorIndex
);
1719 HDC hDc
= (HDC
)((const wxMSWDCImpl
*)dc
.GetImpl())->GetHDC();
1723 (HICON
)cursor
.GetHandle(),
1728 #if !defined(__WXWINCE__)
1729 DI_COMPAT
| DI_DEFAULTSIZE
|
1740 void wxCursorProperty::OnCustomPaint( wxDC
&, const wxRect
&, wxPGPaintData
& ) { }
1741 /*wxPGCellRenderer* wxCursorProperty::GetCellRenderer( int column ) const
1743 return wxEnumProperty::GetCellRenderer(column);
1747 // -----------------------------------------------------------------------
1748 // wxImageFileProperty
1749 // -----------------------------------------------------------------------
1753 const wxString
& wxPGGetDefaultImageWildcard()
1755 // Form the wildcard, if not done yet
1756 if ( !wxPGGlobalVars
->m_pDefaultImageWildcard
.length() )
1761 // TODO: This section may require locking (using global).
1763 wxList
& handlers
= wxImage::GetHandlers();
1765 wxList::iterator node
;
1767 // Let's iterate over the image handler list.
1768 //for ( wxList::Node *node = handlers.GetFirst(); node; node = node->GetNext() )
1769 for ( node
= handlers
.begin(); node
!= handlers
.end(); ++node
)
1771 wxImageHandler
*handler
= (wxImageHandler
*)*node
;
1773 wxString ext_lo
= handler
->GetExtension();
1774 wxString ext_up
= ext_lo
.Upper();
1776 str
.append( ext_up
);
1777 str
.append( wxT(" files (*.") );
1778 str
.append( ext_up
);
1779 str
.append( wxT(")|*.") );
1780 str
.append( ext_lo
);
1781 str
.append( wxT("|") );
1784 str
.append ( wxT("All files (*.*)|*.*") );
1786 wxPGGlobalVars
->m_pDefaultImageWildcard
= str
;
1789 return wxPGGlobalVars
->m_pDefaultImageWildcard
;
1792 IMPLEMENT_DYNAMIC_CLASS(wxImageFileProperty
, wxFileProperty
)
1794 wxImageFileProperty::wxImageFileProperty( const wxString
& label
, const wxString
& name
,
1795 const wxString
& value
)
1796 : wxFileProperty(label
,name
,value
)
1798 SetAttribute( wxPG_FILE_WILDCARD
, wxPGGetDefaultImageWildcard() );
1804 wxImageFileProperty::~wxImageFileProperty()
1812 void wxImageFileProperty::OnSetValue()
1814 wxFileProperty::OnSetValue();
1828 wxFileName filename
= GetFileName();
1830 // Create the image thumbnail
1831 if ( filename
.FileExists() )
1833 m_pImage
= new wxImage( filename
.GetFullPath() );
1837 wxSize
wxImageFileProperty::OnMeasureImage( int ) const
1839 return wxPG_DEFAULT_IMAGE_SIZE
;
1842 void wxImageFileProperty::OnCustomPaint( wxDC
& dc
,
1846 if ( m_pBitmap
|| (m_pImage
&& m_pImage
->Ok() ) )
1848 // Draw the thumbnail
1850 // Create the bitmap here because required size is not known in OnSetValue().
1853 m_pImage
->Rescale( rect
.width
, rect
.height
);
1854 m_pBitmap
= new wxBitmap( *m_pImage
);
1859 dc
.DrawBitmap( *m_pBitmap
, rect
.x
, rect
.y
, false );
1863 // No file - just draw a white box
1864 dc
.SetBrush( *wxWHITE_BRUSH
);
1865 dc
.DrawRectangle ( rect
);
1869 #endif // wxUSE_IMAGE
1871 // -----------------------------------------------------------------------
1872 // wxMultiChoiceProperty
1873 // -----------------------------------------------------------------------
1877 #include "wx/choicdlg.h"
1879 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxMultiChoiceProperty
,wxPGProperty
,
1880 wxArrayInt
,const wxArrayInt
&,TextCtrlAndButton
)
1882 wxMultiChoiceProperty::wxMultiChoiceProperty( const wxString
& label
,
1883 const wxString
& name
,
1884 const wxPGChoices
& choices
,
1885 const wxArrayString
& value
)
1886 : wxPGProperty(label
,name
)
1888 m_choices
.Assign(choices
);
1892 wxMultiChoiceProperty::wxMultiChoiceProperty( const wxString
& label
,
1893 const wxString
& name
,
1894 const wxArrayString
& strings
,
1895 const wxArrayString
& value
)
1896 : wxPGProperty(label
,name
)
1898 m_choices
.Set(strings
);
1902 wxMultiChoiceProperty::wxMultiChoiceProperty( const wxString
& label
,
1903 const wxString
& name
,
1904 const wxArrayString
& value
)
1905 : wxPGProperty(label
,name
)
1907 wxArrayString strings
;
1908 m_choices
.Set(strings
);
1912 wxMultiChoiceProperty::~wxMultiChoiceProperty()
1916 void wxMultiChoiceProperty::OnSetValue()
1918 GenerateValueAsString(m_value
, &m_display
);
1921 wxString
wxMultiChoiceProperty::ValueToString( wxVariant
& value
,
1922 int argFlags
) const
1924 // If possible, use cached string
1925 if ( argFlags
& wxPG_VALUE_IS_CURRENT
)
1929 GenerateValueAsString(value
, &s
);
1933 void wxMultiChoiceProperty::GenerateValueAsString( wxVariant
& value
,
1934 wxString
* target
) const
1936 wxArrayString strings
;
1938 if ( value
.GetType() == wxPG_VARIANT_TYPE_ARRSTRING
)
1939 strings
= value
.GetArrayString();
1941 wxString
& tempStr
= *target
;
1943 unsigned int itemCount
= strings
.size();
1948 tempStr
.append( wxT("\"") );
1950 for ( i
= 0; i
< itemCount
; i
++ )
1952 tempStr
.append( strings
[i
] );
1953 tempStr
.append( wxT("\"") );
1954 if ( i
< (itemCount
-1) )
1955 tempStr
.append ( wxT(" \"") );
1959 wxArrayInt
wxMultiChoiceProperty::GetValueAsIndices() const
1961 wxVariant variant
= GetValue();
1962 const wxArrayInt
& valueArr
= wxArrayIntRefFromVariant(variant
);
1965 // Translate values to string indices.
1966 wxArrayInt selections
;
1968 if ( !m_choices
.IsOk() || !m_choices
.GetCount() || !(&valueArr
) )
1970 for ( i
=0; i
<valueArr
.size(); i
++ )
1975 for ( i
=0; i
<valueArr
.size(); i
++ )
1977 int sIndex
= m_choices
.Index(valueArr
[i
]);
1979 selections
.Add(sIndex
);
1986 bool wxMultiChoiceProperty::OnEvent( wxPropertyGrid
* propgrid
,
1987 wxWindow
* WXUNUSED(primary
),
1990 if ( propgrid
->IsMainButtonEvent(event
) )
1993 wxVariant useValue
= propgrid
->GetUncommittedPropertyValue();
1995 wxArrayString labels
= m_choices
.GetLabels();
1996 unsigned int choiceCount
;
1998 if ( m_choices
.IsOk() )
1999 choiceCount
= m_choices
.GetCount();
2003 // launch editor dialog
2004 wxMultiChoiceDialog
dlg( propgrid
,
2005 _("Make a selection:"),
2008 choiceCount
?&labels
[0]:NULL
,
2009 wxCHOICEDLG_STYLE
);
2011 dlg
.Move( propgrid
->GetGoodEditorDialogPosition(this,dlg
.GetSize()) );
2013 wxArrayString strings
= useValue
.GetArrayString();
2014 wxArrayString extraStrings
;
2016 dlg
.SetSelections(m_choices
.GetIndicesForStrings(strings
, &extraStrings
));
2018 if ( dlg
.ShowModal() == wxID_OK
&& choiceCount
)
2020 int userStringMode
= GetAttributeAsLong(wxT("UserStringMode"), 0);
2022 wxArrayInt arrInt
= dlg
.GetSelections();
2026 // Strings that were not in list of choices
2027 wxArrayString value
;
2029 // Translate string indices to strings
2032 if ( userStringMode
== 1 )
2034 for (n
=0;n
<extraStrings
.size();n
++)
2035 value
.push_back(extraStrings
[n
]);
2039 for ( i
=0; i
<arrInt
.size(); i
++ )
2040 value
.Add(m_choices
.GetLabel(arrInt
.Item(i
)));
2042 if ( userStringMode
== 2 )
2044 for (n
=0;n
<extraStrings
.size();n
++)
2045 value
.push_back(extraStrings
[n
]);
2048 variant
= WXVARIANT(value
);
2050 SetValueInEvent(variant
);
2058 bool wxMultiChoiceProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
2062 int userStringMode
= GetAttributeAsLong(wxT("UserStringMode"), 0);
2064 WX_PG_TOKENIZER2_BEGIN(text
,wxT('"'))
2065 if ( userStringMode
> 0 || (m_choices
.IsOk() && m_choices
.Index( token
) != wxNOT_FOUND
) )
2067 WX_PG_TOKENIZER2_END()
2069 wxVariant
v( WXVARIANT(arr
) );
2075 #endif // wxUSE_CHOICEDLG
2078 // -----------------------------------------------------------------------
2080 // -----------------------------------------------------------------------
2085 #if wxUSE_DATEPICKCTRL
2086 #define dtCtrl DatePickerCtrl
2088 #define dtCtrl TextCtrl
2091 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxDateProperty
,
2098 wxString
wxDateProperty::ms_defaultDateFormat
;
2101 wxDateProperty::wxDateProperty( const wxString
& label
,
2102 const wxString
& name
,
2103 const wxDateTime
& value
)
2104 : wxPGProperty(label
,name
)
2106 //wxPGRegisterDefaultValueType(wxDateTime)
2108 #if wxUSE_DATEPICKCTRL
2109 wxPGRegisterEditorClass(DatePickerCtrl
);
2111 m_dpStyle
= wxDP_DEFAULT
| wxDP_SHOWCENTURY
;
2119 wxDateProperty::~wxDateProperty()
2123 void wxDateProperty::OnSetValue()
2126 // Convert invalid dates to unspecified value
2127 if ( m_value
.GetType() == wxT("datetime") )
2129 if ( !m_value
.GetDateTime().IsValid() )
2134 bool wxDateProperty::StringToValue( wxVariant
& variant
, const wxString
& text
,
2135 int WXUNUSED(argFlags
) ) const
2139 // FIXME: do we really want to return true from here if only part of the
2140 // string was parsed?
2141 const char* c
= dt
.ParseFormat(text
);
2152 wxString
wxDateProperty::ValueToString( wxVariant
& value
,
2153 int argFlags
) const
2155 const wxChar
* format
= (const wxChar
*) NULL
;
2157 wxDateTime dateTime
= value
.GetDateTime();
2159 if ( !dateTime
.IsValid() )
2160 return wxT("Invalid");
2162 if ( !ms_defaultDateFormat
.length() )
2164 #if wxUSE_DATEPICKCTRL
2165 bool showCentury
= m_dpStyle
& wxDP_SHOWCENTURY
? true : false;
2167 bool showCentury
= true;
2169 ms_defaultDateFormat
= DetermineDefaultDateFormat( showCentury
);
2172 if ( m_format
.length() &&
2173 !(argFlags
& wxPG_FULL_VALUE
) )
2174 format
= m_format
.c_str();
2176 // Determine default from locale
2177 // NB: This is really simple stuff, but can't figure anything
2178 // better without proper support in wxLocale
2180 format
= ms_defaultDateFormat
.c_str();
2182 return dateTime
.Format(format
);
2185 wxString
wxDateProperty::DetermineDefaultDateFormat( bool showCentury
)
2187 // This code is basicly copied from datectlg.cpp's SetFormat
2192 dt
.ParseFormat(wxT("2003-10-13"), wxT("%Y-%m-%d"));
2193 wxString
str(dt
.Format(wxT("%x")));
2195 const wxChar
*p
= str
.c_str();
2199 if (n
== dt
.GetDay())
2201 format
.Append(wxT("%d"));
2204 else if (n
== (int)dt
.GetMonth()+1)
2206 format
.Append(wxT("%m"));
2209 else if (n
== dt
.GetYear())
2211 format
.Append(wxT("%Y"));
2214 else if (n
== (dt
.GetYear() % 100))
2217 format
.Append(wxT("%Y"));
2219 format
.Append(wxT("%y"));
2223 format
.Append(*p
++);
2229 bool wxDateProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
2231 if ( name
== wxPG_DATE_FORMAT
)
2233 m_format
= value
.GetString();
2236 else if ( name
== wxPG_DATE_PICKER_STYLE
)
2238 m_dpStyle
= value
.GetLong();
2239 ms_defaultDateFormat
.clear(); // This may need recalculation
2245 #endif // wxUSE_DATETIME
2248 // -----------------------------------------------------------------------
2249 // wxPropertyGridInterface
2250 // -----------------------------------------------------------------------
2252 void wxPropertyGridInterface::InitAllTypeHandlers()
2256 // -----------------------------------------------------------------------
2258 void wxPropertyGridInterface::RegisterAdditionalEditors()
2260 // Register editor classes, if necessary.
2261 if ( wxPGGlobalVars
->m_mapEditorClasses
.empty() )
2262 wxPropertyGrid::RegisterDefaultEditors();
2265 wxPGRegisterEditorClass(SpinCtrl
);
2267 #if wxUSE_DATEPICKCTRL
2268 wxPGRegisterEditorClass(DatePickerCtrl
);
2272 // -----------------------------------------------------------------------
2274 #endif // wxPG_INCLUDE_ADVPROPS
2276 #endif // wxUSE_PROPGRID