KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pg_properties.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KICAD, a free EDA CAD application.
3 *
4 * Copyright (C) 2020-2023 CERN
5 * Copyright The KiCad Developers, see AUTHORS.TXT for contributors.
6 * @author Maciej Suminski <[email protected]>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 3
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <wx/dc.h>
23#include <wx/propgrid/propgrid.h>
24
25#include <macros.h>
26#include <validators.h>
27#include <eda_draw_frame.h>
28#include <eda_units.h>
35#include <properties/property.h>
36#include <string_utils.h>
38
39
40class wxAnyToSTD_OPTIONAL_INT_VARIANTRegistrationImpl : public wxAnyToVariantRegistration
41{
42public:
44 : wxAnyToVariantRegistration( factory )
45 {
46 }
47
48public:
49 static bool IsSameClass(const wxAnyValueType* otherType)
50 {
51 return AreSameClasses( *s_instance.get(), *otherType );
52 }
53
54 static wxAnyValueType* GetInstance()
55 {
56 return s_instance.get();
57 }
58
59 virtual wxAnyValueType* GetAssociatedType() override
60 {
62 }
63private:
64 static bool AreSameClasses(const wxAnyValueType& a, const wxAnyValueType& b)
65 {
66 return wxTypeId(a) == wxTypeId(b);
67 }
68
69 static wxAnyValueTypeScopedPtr s_instance;
70};
71
72
74 new wxAnyValueTypeImpl<std::optional<int>>() );
75
76
78 s_wxAnyToSTD_OPTIONAL_INT_VARIANTRegistration(
80
81
82class wxAnyToSTD_OPTIONAL_DOUBLE_VARIANTRegistrationImpl : public wxAnyToVariantRegistration
83{
84public:
86 : wxAnyToVariantRegistration( factory )
87 {
88 }
89
90public:
91 static bool IsSameClass(const wxAnyValueType* otherType)
92 {
93 return AreSameClasses( *s_instance.get(), *otherType );
94 }
95
96 static wxAnyValueType* GetInstance()
97 {
98 return s_instance.get();
99 }
100
101 virtual wxAnyValueType* GetAssociatedType() override
102 {
104 }
105private:
106 static bool AreSameClasses(const wxAnyValueType& a, const wxAnyValueType& b)
107 {
108 return wxTypeId(a) == wxTypeId(b);
109 }
110
111 static wxAnyValueTypeScopedPtr s_instance;
112};
113
114
116 new wxAnyValueTypeImpl<std::optional<double>>() );
117
118
120 s_wxAnyToSTD_OPTIONAL_DOUBLE_VARIANTRegistration(
122
123
124class wxAnyToEDA_ANGLE_VARIANTRegistrationImpl : public wxAnyToVariantRegistration
125{
126public:
127 wxAnyToEDA_ANGLE_VARIANTRegistrationImpl( wxVariantDataFactory factory )
128 : wxAnyToVariantRegistration( factory )
129 {
130 }
131
132public:
133 static bool IsSameClass(const wxAnyValueType* otherType)
134 {
135 return AreSameClasses( *s_instance.get(), *otherType );
136 }
137
138 static wxAnyValueType* GetInstance()
139 {
140 return s_instance.get();
141 }
142
143 virtual wxAnyValueType* GetAssociatedType() override
144 {
146 }
147private:
148 static bool AreSameClasses(const wxAnyValueType& a, const wxAnyValueType& b)
149 {
150 return wxTypeId(a) == wxTypeId(b);
151 }
152
153 static wxAnyValueTypeScopedPtr s_instance;
154};
155
156
157wxAnyValueTypeScopedPtr
158 wxAnyToEDA_ANGLE_VARIANTRegistrationImpl::s_instance( new wxAnyValueTypeImpl<EDA_ANGLE>() );
159
160
162 s_wxAnyToEDA_ANGLE_VARIANTRegistration( &EDA_ANGLE_VARIANT_DATA::VariantDataFactory );
163
164
165class wxAnyToCOLOR4D_VARIANTRegistrationImpl : public wxAnyToVariantRegistration
166{
167public:
168 wxAnyToCOLOR4D_VARIANTRegistrationImpl( wxVariantDataFactory factory )
169 : wxAnyToVariantRegistration( factory )
170 {
171 }
172
173public:
174 static bool IsSameClass(const wxAnyValueType* otherType)
175 {
176 return AreSameClasses( *s_instance.get(), *otherType );
177 }
178
179 static wxAnyValueType* GetInstance()
180 {
181 return s_instance.get();
182 }
183
184 virtual wxAnyValueType* GetAssociatedType() override
185 {
187 }
188private:
189 static bool AreSameClasses(const wxAnyValueType& a, const wxAnyValueType& b)
190 {
191 return wxTypeId(a) == wxTypeId(b);
192 }
193
194 static wxAnyValueTypeScopedPtr s_instance;
195};
196
197
199 new wxAnyValueTypeImpl<KIGFX::COLOR4D>() );
200
201
203 s_wxAnyToCOLOR4D_VARIANTRegistration( &COLOR4D_VARIANT_DATA::VariantDataFactory );
204
205
206wxPGProperty* PGPropertyFactory( const PROPERTY_BASE* aProperty, EDA_DRAW_FRAME* aFrame )
207{
208 wxPGProperty* ret = nullptr;
209 PROPERTY_DISPLAY display = aProperty->Display();
210
211 switch( display )
212 {
214 ret = new PGPROPERTY_TIME( aFrame );
215 ret->SetEditor( PG_UNIT_EDITOR::BuildEditorName( aFrame ) );
216 break;
217
219 ret = new PGPROPERTY_SIZE( aFrame );
220 ret->SetEditor( PG_UNIT_EDITOR::BuildEditorName( aFrame ) );
221 break;
222
224 ret = new PGPROPERTY_AREA( aFrame );
225 ret->SetEditor( PG_UNIT_EDITOR::BuildEditorName( aFrame ) );
226 break;
227
229 ret = new PGPROPERTY_COORD( aFrame, aProperty->CoordType() );
230 ret->SetEditor( PG_UNIT_EDITOR::BuildEditorName( aFrame ) );
231 break;
232
235 {
237
238 if( display == PROPERTY_DISPLAY::PT_DECIDEGREE )
239 prop->SetScale( 10.0 );
240
241 ret = prop;
242 ret->SetEditor( PG_UNIT_EDITOR::BuildEditorName( aFrame ) );
243 break;
244 }
245
247 ret = new PGPROPERTY_RATIO();
248 break;
249
251 ret = new PGPROPERTY_NET( aProperty->Choices() );
252 break;
253
254 default:
255 wxFAIL;
257 /* fall through */
259 {
260 // Create a corresponding wxPGProperty
261 size_t typeId = aProperty->TypeHash();
262
263 // Enum property
264 if( aProperty->HasChoices() )
265 {
266 // I do not know why enum property takes a non-const reference to wxPGChoices..
267 ret = new wxEnumProperty( wxPG_LABEL, wxPG_LABEL,
268 const_cast<wxPGChoices&>( aProperty->Choices() ) );
269 }
270 else if( typeId == TYPE_HASH( int ) || typeId == TYPE_HASH( long ) )
271 {
272 ret = new wxIntProperty();
273 }
274 else if( typeId == TYPE_HASH( unsigned int ) || typeId == TYPE_HASH( unsigned long ) )
275 {
276 ret = new wxUIntProperty();
277 }
278 else if( typeId == TYPE_HASH( float ) || typeId == TYPE_HASH( double ) )
279 {
280 ret = new wxFloatProperty();
281 }
282 else if( typeId == TYPE_HASH( bool ) )
283 {
284 ret = new PGPROPERTY_BOOL();
285 }
286 else if( typeId == TYPE_HASH( wxString ) )
287 {
288 ret = new PGPROPERTY_STRING();
289 }
290 else if( typeId == TYPE_HASH( COLOR4D ) )
291 {
292 ret = new PGPROPERTY_COLOR4D();
293 }
294 else
295 {
296 wxFAIL_MSG( wxString::Format( wxS( "Property %s not supported by PGPropertyFactory" ),
297 aProperty->Name() ) );
298 ret = new wxPropertyCategory();
299 ret->Enable( false );
300 }
301
302 break;
303 }
304 }
305
306 if( ret )
307 {
308 ret->SetLabel( wxGetTranslation( aProperty->Name() ) );
309 ret->SetName( aProperty->Name() );
310 ret->SetHelpString( wxGetTranslation( aProperty->Name() ) );
311 ret->SetClientData( const_cast<PROPERTY_BASE*>( aProperty ) );
312 }
313
314 return ret;
315}
316
317
320 m_parentFrame( aParentFrame ),
321 m_coordType( aCoordType )
322{
323}
324
325
329
330
331#if wxCHECK_VERSION( 3, 3, 0 )
332bool PGPROPERTY_DISTANCE::StringToDistance( wxVariant& aVariant, const wxString& aText,
333 wxPGPropValFormatFlags aFlags ) const
334#else
335bool PGPROPERTY_DISTANCE::StringToDistance( wxVariant& aVariant, const wxString& aText,
336 int aFlags ) const
337#endif
338{
339 // TODO(JE): Are there actual use cases for this?
340 wxCHECK_MSG( false, false, wxS( "PGPROPERTY_DISTANCE::StringToDistance should not be used." ) );
341}
342
343
344#if wxCHECK_VERSION( 3, 3, 0 )
345wxString PGPROPERTY_DISTANCE::DistanceToString( wxVariant& aVariant,
346 wxPGPropValFormatFlags aFlags ) const
347#else
348wxString PGPROPERTY_DISTANCE::DistanceToString( wxVariant& aVariant, int aFlags ) const
349#endif
350{
351 long distanceIU;
352
353 if( aVariant.GetType() == wxT( "std::optional<int>" ) )
354 {
355 auto* variantData = static_cast<STD_OPTIONAL_INT_VARIANT_DATA*>( aVariant.GetData() );
356
357 if( !variantData->Value().has_value() )
358 return wxEmptyString;
359
360 distanceIU = variantData->Value().value();
361 }
362 else if( aVariant.GetType() == wxPG_VARIANT_TYPE_LONG )
363 {
364 distanceIU = aVariant.GetLong();
365 }
366 else
367 {
368 wxFAIL_MSG( wxT( "Expected int (or std::optional<int>) value type" ) );
369 return wxEmptyString;
370 }
371
372 ORIGIN_TRANSFORMS& transforms = m_parentFrame->GetOriginTransforms();
373
374 distanceIU = transforms.ToDisplay( static_cast<long long int>( distanceIU ), m_coordType );
375
376 return m_parentFrame->StringFromValue( distanceIU, true, EDA_DATA_TYPE::DISTANCE );
377}
378
379
381 wxIntProperty( wxPG_LABEL, wxPG_LABEL, 0 ),
382 m_parentFrame( aParentFrame )
383{
384}
385
386
387#if wxCHECK_VERSION( 3, 3, 0 )
388bool PGPROPERTY_AREA::StringToValue( wxVariant& aVariant, const wxString& aText,
389 wxPGPropValFormatFlags aArgFlags ) const
390#else
391bool PGPROPERTY_AREA::StringToValue( wxVariant& aVariant, const wxString& aText,
392 int aArgFlags ) const
393#endif
394{
395 // TODO(JE): Are there actual use cases for this?
396 wxCHECK_MSG( false, false, wxS( "PGPROPERTY_AREA::StringToValue should not be used." ) );
397}
398
399
400#if wxCHECK_VERSION( 3, 3, 0 )
401wxString PGPROPERTY_AREA::ValueToString( wxVariant& aVariant,
402 wxPGPropValFormatFlags aArgFlags ) const
403#else
404wxString PGPROPERTY_AREA::ValueToString( wxVariant& aVariant, int aArgFlags ) const
405#endif
406{
407 wxCHECK( aVariant.GetType() == wxPG_VARIANT_TYPE_LONGLONG, wxEmptyString );
408
409 wxLongLongNative areaIU = aVariant.GetLongLong();
410
411 return m_parentFrame->StringFromValue( areaIU.ToDouble(), true, EDA_DATA_TYPE::AREA );
412}
413
414
416{
417 return nullptr;
418}
419
420
422 wxUIntProperty( wxPG_LABEL, wxPG_LABEL, 0 ),
423 PGPROPERTY_DISTANCE( aParentFrame, ORIGIN_TRANSFORMS::NOT_A_COORD )
424{
425}
426
427
428bool PGPROPERTY_SIZE::ValidateValue( wxVariant& aValue, wxPGValidationInfo& aValidationInfo ) const
429{
430 if( aValue.GetType() == wxT( "std::optional<int>" ) )
431 {
432 auto* data = static_cast<STD_OPTIONAL_INT_VARIANT_DATA*>( aValue.GetData() );
433
434 if( !data->Value().has_value() )
435 return wxEmptyString;
436
437 wxVariant value( data->Value().value() );
438 return wxUIntProperty::ValidateValue( value, aValidationInfo );
439 }
440
441 return wxUIntProperty::ValidateValue( aValue, aValidationInfo );
442}
443
444
446{
447 return nullptr;
448}
449
450
453 wxIntProperty( wxPG_LABEL, wxPG_LABEL, 0 ),
454 PGPROPERTY_DISTANCE( aParentFrame, aCoordType )
455{
456}
457
458
460{
461 return nullptr;
462}
463
464
466 wxFloatProperty( wxPG_LABEL, wxPG_LABEL, 0 )
467{
468 SetEditor( PG_RATIO_EDITOR::EDITOR_NAME );
469}
470
471
472const wxPGEditor* PGPROPERTY_RATIO::DoGetEditorClass() const
473{
474 wxCHECK_MSG( m_customEditor, wxPGEditor_TextCtrl,
475 wxT( "Make sure to RegisterEditorClass() for PGPROPERTY_RATIO!" ) );
476 return m_customEditor;
477}
478
479
480#if wxCHECK_VERSION( 3, 3, 0 )
481bool PGPROPERTY_RATIO::StringToValue( wxVariant& aVariant, const wxString& aText,
482 wxPGPropValFormatFlags aArgFlags ) const
483#else
484bool PGPROPERTY_RATIO::StringToValue( wxVariant& aVariant, const wxString& aText,
485 int aArgFlags ) const
486#endif
487{
488 // TODO(JE): Are there actual use cases for this?
489 wxCHECK_MSG( false, false, wxS( "PGPROPERTY_RATIO::StringToValue should not be used." ) );
490}
491
492
493#if wxCHECK_VERSION( 3, 3, 0 )
494wxString PGPROPERTY_RATIO::ValueToString( wxVariant& aVariant,
495 wxPGPropValFormatFlags aArgFlags ) const
496#else
497wxString PGPROPERTY_RATIO::ValueToString( wxVariant& aVariant, int aArgFlags ) const
498#endif
499{
500 double value;
501
502 if( aVariant.GetType() == wxT( "std::optional<double>" ) )
503 {
504 auto* variantData = static_cast<STD_OPTIONAL_DOUBLE_VARIANT_DATA*>( aVariant.GetData() );
505
506 if( !variantData->Value().has_value() )
507 return wxEmptyString;
508
509 value = variantData->Value().value();
510 }
511 else if( aVariant.GetType() == wxPG_VARIANT_TYPE_DOUBLE )
512 {
513 value = aVariant.GetDouble();
514 }
515 else
516 {
517 wxFAIL_MSG( wxT( "Expected double (or std::optional<double>) value type" ) );
518 return wxEmptyString;
519 }
520
521 return wxString::Format( wxS( "%g" ), value );
522}
523
524
525bool PGPROPERTY_RATIO::ValidateValue( wxVariant& aValue, wxPGValidationInfo& aValidationInfo ) const
526{
527 if( aValue.GetType() == wxT( "std::optional<double>" ) )
528 {
529 auto* data = static_cast<STD_OPTIONAL_DOUBLE_VARIANT_DATA*>( aValue.GetData() );
530
531 if( !data->Value().has_value() )
532 return wxEmptyString;
533
534 wxVariant value( data->Value().value() );
535 return wxFloatProperty::ValidateValue( value, aValidationInfo );
536 }
537
538 return wxFloatProperty::ValidateValue( aValue, aValidationInfo );
539}
540
541
543{
544 return nullptr;
545}
546
547
548#if wxCHECK_VERSION( 3, 3, 0 )
549bool PGPROPERTY_ANGLE::StringToValue( wxVariant& aVariant, const wxString& aText,
550 wxPGPropValFormatFlags aArgFlags ) const
551#else
552bool PGPROPERTY_ANGLE::StringToValue( wxVariant& aVariant, const wxString& aText,
553 int aArgFlags ) const
554#endif
555{
556 double value = 0.0;
557
558 if( !aText.ToDouble( &value ) )
559 {
560 aVariant.MakeNull();
561 return true;
562 }
563
564 value *= m_scale;
565
566 if( aVariant.IsNull() || aVariant.GetDouble() != value )
567 {
568 aVariant = value;
569 return true;
570 }
571
572 return false;
573}
574
575
576#if wxCHECK_VERSION( 3, 3, 0 )
577wxString PGPROPERTY_ANGLE::ValueToString( wxVariant& aVariant,
578 wxPGPropValFormatFlags aArgFlags ) const
579#else
580wxString PGPROPERTY_ANGLE::ValueToString( wxVariant& aVariant, int aArgFlags ) const
581#endif
582{
583 if( aVariant.GetType() == wxT( "std::optional<double>" ) )
584 {
585 auto* variantData = static_cast<STD_OPTIONAL_DOUBLE_VARIANT_DATA*>( aVariant.GetData() );
586
587 if( variantData->Value().has_value() )
588 return wxString::Format( wxS( "%g\u00B0" ), variantData->Value().value() / m_scale );
589 else
590 return wxEmptyString;
591 }
592 else if( aVariant.GetType() == wxPG_VARIANT_TYPE_DOUBLE )
593 {
594 return wxString::Format( wxS( "%g\u00B0" ), aVariant.GetDouble() / m_scale );
595 }
596 else if( aVariant.GetType() == wxS( "EDA_ANGLE" ) )
597 {
598 wxString ret;
599 static_cast<EDA_ANGLE_VARIANT_DATA*>( aVariant.GetData() )->Write( ret );
600 return ret;
601 }
602 else
603 {
604 wxCHECK_MSG( false, wxEmptyString, wxS( "Unexpected variant type in PGPROPERTY_ANGLE" ) );
605 }
606}
607
608
610{
611 return nullptr;
612}
613
614
616{
617 wxSize size( 16, -1 );
618
619 if( wxPropertyGrid* pg = GetGrid() )
620 size = pg->FromDIP( size );
621
622 return size;
623}
624
625
626void PGPROPERTY_COLORENUM::OnCustomPaint( wxDC& aDC, const wxRect& aRect,
627 wxPGPaintData& aPaintData )
628{
629 int index = aPaintData.m_choiceItem;
630
631 if( index < 0 )
632 index = GetIndex();
633
634 // GetIndex can return -1 when the control hasn't been set up yet
635 if( index < 0 || index >= static_cast<int>( GetChoices().GetCount() ) )
636 return;
637
638 wxColour color = GetColor( GetChoices().GetValue( index ) );
639
640 if( color == wxNullColour )
641 return;
642
643 aDC.SetPen( *wxTRANSPARENT_PEN );
644 aDC.SetBrush( wxBrush( color ) );
645 aDC.DrawRectangle( aRect );
646
647 aPaintData.m_drawnWidth = aRect.width;
648}
649
650
651#if wxCHECK_VERSION( 3, 3, 0 )
652wxString PGPROPERTY_STRING::ValueToString( wxVariant& aValue,
653 wxPGPropValFormatFlags aFlags ) const
654#else
655wxString PGPROPERTY_STRING::ValueToString( wxVariant& aValue, int aFlags ) const
656#endif
657{
658 if( aValue.GetType() != wxPG_VARIANT_TYPE_STRING )
659 return wxEmptyString;
660
661 return UnescapeString( aValue.GetString() );
662}
663
664
665#if wxCHECK_VERSION( 3, 3, 0 )
666bool PGPROPERTY_STRING::StringToValue( wxVariant& aVariant, const wxString& aString,
667 wxPGPropValFormatFlags aArgFlags ) const
668#else
669bool PGPROPERTY_STRING::StringToValue( wxVariant& aVariant, const wxString& aString,
670 int aFlags ) const
671#endif
672{
673 aVariant = EscapeString( aString, CTX_QUOTED_STR );
674 return true;
675}
676
677
678PGPROPERTY_BOOL::PGPROPERTY_BOOL( const wxString& aLabel, const wxString& aName, bool aValue ) :
679 wxBoolProperty( aLabel, aName, aValue )
680{
682}
683
684
685const wxPGEditor* PGPROPERTY_BOOL::DoGetEditorClass() const
686{
687 wxCHECK_MSG( m_customEditor, wxPGEditor_CheckBox,
688 wxT( "Make sure to RegisterEditorClass() for PGPROPERTY_BOOL!" ) );
689 return m_customEditor;
690}
691
692
693PGPROPERTY_COLOR4D::PGPROPERTY_COLOR4D( const wxString& aLabel, const wxString& aName,
694 COLOR4D aValue, COLOR4D aBackgroundColor ) :
695 wxStringProperty( aLabel, aName, aValue.ToCSSString() ),
696 m_backgroundColor( aBackgroundColor )
697{
698 SetEditor( PG_COLOR_EDITOR::EDITOR_NAME );
699#if wxCHECK_VERSION( 3, 3, 1 )
700 SetFlag( wxPGFlags::NoEditor );
701#elif wxCHECK_VERSION( 3, 3, 0 )
702 SetFlag( wxPGPropertyFlags::NoEditor );
703#else
704 SetFlag( wxPG_PROP_NOEDITOR );
705#endif
706}
707
708
709#if wxCHECK_VERSION( 3, 3, 0 )
710bool PGPROPERTY_COLOR4D::StringToValue( wxVariant& aVariant, const wxString& aString,
711 wxPGPropValFormatFlags aArgFlags ) const
712#else
713bool PGPROPERTY_COLOR4D::StringToValue( wxVariant& aVariant, const wxString& aString,
714 int aFlags ) const
715#endif
716{
717 aVariant.SetData( new COLOR4D_VARIANT_DATA( aString ) );
718 return true;
719}
720
721
722#if wxCHECK_VERSION( 3, 3, 0 )
723wxString PGPROPERTY_COLOR4D::ValueToString( wxVariant& aValue,
724 wxPGPropValFormatFlags aFlags ) const
725#else
726wxString PGPROPERTY_COLOR4D::ValueToString( wxVariant& aValue, int aFlags ) const
727#endif
728{
729 wxString ret;
730
731 if( aValue.IsType( wxS( "COLOR4D" ) ) )
732 static_cast<COLOR4D_VARIANT_DATA*>( aValue.GetData() )->Write( ret );
733 else
734 return wxStringProperty::ValueToString( aValue, aFlags );
735
736 return ret;
737}
738
739
741 wxIntProperty( wxPG_LABEL, wxPG_LABEL, 0 ),
742 m_parentFrame( aParentFrame )
743{
744}
745
746
747#if wxCHECK_VERSION( 3, 3, 0 )
748bool PGPROPERTY_TIME::StringToValue( wxVariant& aVariant, const wxString& aText,
749 wxPGPropValFormatFlags aArgFlags ) const
750#else
751bool PGPROPERTY_TIME::StringToValue( wxVariant& aVariant, const wxString& aText,
752 int aArgFlags ) const
753#endif
754{
755 wxCHECK_MSG( false, false, wxS( "PGPROPERTY_RATIO::StringToValue should not be used." ) );
756}
757
758
759#if wxCHECK_VERSION( 3, 3, 0 )
760wxString PGPROPERTY_TIME::ValueToString( wxVariant& aVariant,
761 wxPGPropValFormatFlags aArgFlags ) const
762#else
763wxString PGPROPERTY_TIME::ValueToString( wxVariant& aVariant, int aArgFlags ) const
764#endif
765{
766 int value;
767
768 if( aVariant.GetType() == wxT( "std::optional<int>" ) )
769 {
770 auto* variantData = static_cast<STD_OPTIONAL_INT_VARIANT_DATA*>( aVariant.GetData() );
771
772 if( !variantData->Value().has_value() )
773 return wxEmptyString;
774
775 value = variantData->Value().value();
776 }
777 else if( aVariant.GetType() == wxPG_VARIANT_TYPE_LONG )
778 {
779 value = static_cast<int>( aVariant.GetInteger() );
780 }
781 else
782 {
783 wxFAIL_MSG( wxT( "Expected int (or std::optional<int>) value type" ) );
784 return wxEmptyString;
785 }
786
787 return m_parentFrame->StringFromValue( value, true, EDA_DATA_TYPE::TIME );
788}
789
790
791bool PGPROPERTY_TIME::ValidateValue( wxVariant& aValue, wxPGValidationInfo& aValidationInfo ) const
792{
793 return true;
794}
795
796
798{
799 return nullptr;
800}
801
802
803PGPROPERTY_NET::PGPROPERTY_NET( const wxPGChoices& aChoices ) :
804 wxEnumProperty( wxPG_LABEL, wxPG_LABEL, const_cast<wxPGChoices&>( aChoices ) )
805{
806 SetEditor( wxS( "PG_NET_SELECTOR_EDITOR" ) );
807}
808
809
810const wxPGEditor* PGPROPERTY_NET::DoGetEditorClass() const
811{
812 wxCHECK_MSG( m_customEditor, wxPGEditor_Choice,
813 wxT( "Make sure to RegisterEditorClass() for PGPROPERTY_NET!" ) );
814
815 return m_customEditor;
816}
int color
bool Write(wxString &aString) const override
static wxVariantData * VariantDataFactory(const wxAny &aAny)
static wxVariantData * VariantDataFactory(const wxAny &aAny)
bool Write(wxString &aString) const override
The base class for create windows for drawing purpose.
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:104
A class to perform either relative or absolute display origin transforms for a single axis of a point...
virtual int ToDisplay(int aValue, COORD_TYPES_T aCoordType) const
COORD_TYPES_T
The supported Display Origin Transform types.
A wxEnumProperty that displays a color next to the enum value.
void SetScale(double aScale)
wxString ValueToString(wxVariant &aVariant, int aArgFlags=0) const override
double m_scale
< Scale factor to convert between raw and displayed value
wxValidator * DoGetValidator() const override
Do not perform PG validation; the UX is not what we want.
bool StringToValue(wxVariant &aVariant, const wxString &aText, int aArgFlags=0) const override
PGPROPERTY_AREA(EDA_DRAW_FRAME *aParentFrame)
wxString ValueToString(wxVariant &aVariant, int aArgFlags=0) const override
wxValidator * DoGetValidator() const override
bool StringToValue(wxVariant &aVariant, const wxString &aText, int aArgFlags=0) const override
EDA_DRAW_FRAME * m_parentFrame
const wxPGEditor * DoGetEditorClass() const override
PGPROPERTY_BOOL(const wxString &aLabel=wxPG_LABEL, const wxString &aName=wxPG_LABEL, bool aValue=false)
KIGFX::COLOR4D m_backgroundColor
Used for rendering colors with opacity.
bool StringToValue(wxVariant &aVariant, const wxString &aText, int aFlags=0) const override
wxString ValueToString(wxVariant &aValue, int aFlags=0) const override
PGPROPERTY_COLOR4D(const wxString &aLabel=wxPG_LABEL, const wxString &aName=wxPG_LABEL, KIGFX::COLOR4D aValue=KIGFX::COLOR4D::UNSPECIFIED, KIGFX::COLOR4D aBackground=KIGFX::COLOR4D::UNSPECIFIED)
wxColour GetColor(int aValue)
wxSize OnMeasureImage(int aItem=-1) const override
void OnCustomPaint(wxDC &aDC, const wxRect &aRect, wxPGPaintData &aPaintData) override
Customized wxPGProperty class to handle angles.
PGPROPERTY_COORD(EDA_DRAW_FRAME *aParentFrame, ORIGIN_TRANSFORMS::COORD_TYPES_T aCoordType)
wxValidator * DoGetValidator() const override
EDA_DRAW_FRAME * m_parentFrame
wxString DistanceToString(wxVariant &aVariant, int aArgFlags=0) const
bool StringToDistance(wxVariant &aVariant, const wxString &aText, int aArgFlags=0) const
virtual ~PGPROPERTY_DISTANCE()=0
ORIGIN_TRANSFORMS::COORD_TYPES_T m_coordType
PGPROPERTY_DISTANCE(EDA_DRAW_FRAME *aParentFrame, ORIGIN_TRANSFORMS::COORD_TYPES_T aCoordType)
PGPROPERTY_NET(const wxPGChoices &aChoices=wxPGChoices())
const wxPGEditor * DoGetEditorClass() const override
wxValidator * DoGetValidator() const override
bool ValidateValue(wxVariant &aValue, wxPGValidationInfo &aValidationInfo) const override
bool StringToValue(wxVariant &aVariant, const wxString &aText, int aArgFlags=0) const override
wxString ValueToString(wxVariant &aVariant, int aArgFlags=0) const override
const wxPGEditor * DoGetEditorClass() const override
wxValidator * DoGetValidator() const override
bool ValidateValue(wxVariant &aValue, wxPGValidationInfo &aValidationInfo) const override
PGPROPERTY_SIZE(EDA_DRAW_FRAME *aParentFrame)
wxString ValueToString(wxVariant &aValue, int aFlags=0) const override
bool StringToValue(wxVariant &aVariant, const wxString &aString, int aFlags=0) const override
bool StringToValue(wxVariant &aVariant, const wxString &aText, int aArgFlags=0) const override
wxString ValueToString(wxVariant &aVariant, int aArgFlags=0) const override
EDA_DRAW_FRAME * m_parentFrame
PGPROPERTY_TIME(EDA_DRAW_FRAME *aParentFrame)
wxValidator * DoGetValidator() const override
bool ValidateValue(wxVariant &aValue, wxPGValidationInfo &aValidationInfo) const override
static const wxString EDITOR_NAME
Definition pg_editors.h:75
static const wxString EDITOR_NAME
Definition pg_editors.h:91
static const wxString EDITOR_NAME
Definition pg_editors.h:117
static wxString BuildEditorName(EDA_DRAW_FRAME *aFrame)
virtual size_t TypeHash() const =0
Return type-id of the property type.
PROPERTY_DISPLAY Display() const
Definition property.h:305
ORIGIN_TRANSFORMS::COORD_TYPES_T CoordType() const
Definition property.h:308
virtual bool HasChoices() const
Return true if this PROPERTY has a limited set of possible values.
Definition property.h:243
const wxString & Name() const
Definition property.h:219
virtual const wxPGChoices & Choices() const
Return a limited set of possible values (e.g.
Definition property.h:225
std::optional< double > Value() const
static wxVariantData * VariantDataFactory(const wxAny &aAny)
std::optional< int > Value() const
static wxVariantData * VariantDataFactory(const wxAny &aAny)
wxAnyToCOLOR4D_VARIANTRegistrationImpl(wxVariantDataFactory factory)
static wxAnyValueType * GetInstance()
static bool AreSameClasses(const wxAnyValueType &a, const wxAnyValueType &b)
static bool IsSameClass(const wxAnyValueType *otherType)
virtual wxAnyValueType * GetAssociatedType() override
static wxAnyValueTypeScopedPtr s_instance
static wxAnyValueTypeScopedPtr s_instance
static bool IsSameClass(const wxAnyValueType *otherType)
virtual wxAnyValueType * GetAssociatedType() override
wxAnyToEDA_ANGLE_VARIANTRegistrationImpl(wxVariantDataFactory factory)
static bool AreSameClasses(const wxAnyValueType &a, const wxAnyValueType &b)
static bool IsSameClass(const wxAnyValueType *otherType)
wxAnyToSTD_OPTIONAL_DOUBLE_VARIANTRegistrationImpl(wxVariantDataFactory factory)
virtual wxAnyValueType * GetAssociatedType() override
static bool AreSameClasses(const wxAnyValueType &a, const wxAnyValueType &b)
static bool AreSameClasses(const wxAnyValueType &a, const wxAnyValueType &b)
virtual wxAnyValueType * GetAssociatedType() override
static bool IsSameClass(const wxAnyValueType *otherType)
wxAnyToSTD_OPTIONAL_INT_VARIANTRegistrationImpl(wxVariantDataFactory factory)
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition macros.h:83
wxPGProperty * PGPropertyFactory(const PROPERTY_BASE *aProperty, EDA_DRAW_FRAME *aFrame)
Customized abstract wxPGProperty class to handle coordinate/size units.
#define TYPE_HASH(x)
Definition property.h:73
PROPERTY_DISPLAY
Common property types.
Definition property.h:60
@ PT_DEGREE
Angle expressed in degrees.
Definition property.h:65
@ PT_COORD
Coordinate expressed in distance units (mm/inch)
Definition property.h:64
@ PT_RATIO
Definition property.h:67
@ PT_DECIDEGREE
Angle expressed in decidegrees.
Definition property.h:66
@ PT_AREA
Area expressed in distance units-squared (mm/inch)
Definition property.h:63
@ PT_DEFAULT
Default property for a given type.
Definition property.h:61
@ PT_SIZE
Size expressed in distance units (mm/inch)
Definition property.h:62
@ PT_NET
Net selection property.
Definition property.h:69
@ PT_TIME
Time expressed in ps.
Definition property.h:68
wxString UnescapeString(const wxString &aSource)
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
@ CTX_QUOTED_STR
Custom text control validator definitions.