Power System Platform  2026w23a-beta
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
TextForm Class Reference

Form to edit the text graphical data. More...

#include <TextForm.h>

Inheritance diagram for TextForm:
Inheritance graph
[legend]
Collaboration diagram for TextForm:
Collaboration graph
[legend]

Public Member Functions

 TextForm (wxWindow *parent, Text *text, std::vector< Element * > elementList, double systemPowerBase=100e6)
 
virtual bool LoadChoices ()
 
virtual void ElementTypeChoice ()
 
virtual void ElementNumberChoice ()
 
virtual void DataTypeChoice ()
 
virtual void UnitChoice ()
 
virtual void Preview ()
 
virtual bool ValidateData ()
 

Protected Member Functions

virtual void OnUnitChoiceSelected (wxCommandEvent &event)
 
virtual void OnCancelButtonClick (wxCommandEvent &event)
 
virtual void OnOKButtonClick (wxCommandEvent &event)
 
virtual void OnElementChoiceSelected (wxCommandEvent &event)
 
virtual void OnFromBusChoiceSelected (wxCommandEvent &event)
 
virtual void OnNameChoiceSelected (wxCommandEvent &event)
 
virtual void OnTextEnter (wxCommandEvent &event)
 
virtual void OnToBusChoiceSelected (wxCommandEvent &event)
 
virtual void OnTypeChoiceSelected (wxCommandEvent &event)
 

Protected Attributes

Text * m_text = nullptr
 
Text * m_textToEdit = nullptr
 
wxWindow * m_parent = nullptr
 
ElectricCalculation m_allElements
 
double m_systemPowerBase
 

Detailed Description

Form to edit the text graphical data.

Author
Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br
Date
05/10/2017

Definition at line 32 of file TextForm.h.

Constructor & Destructor Documentation

◆ TextForm()

TextForm::TextForm ( wxWindow *  parent,
Text *  text,
std::vector< Element * >  elementList,
double  systemPowerBase = 100e6 
)

Definition at line 20 of file TextForm.cpp.

21 : TextFormBase(parent)
22{
23 SetSize(GetBestSize());
24 m_parent = parent;
25 m_textToEdit = text;
26 m_allElements.GetElementsFromList(elementList);
27 m_systemPowerBase = systemPowerBase;
28
29 m_text = new Text();
30 m_text->SetElementTypeText(text->GetElementTypeText());
31 m_text->SetElementNumber(text->GetElementNumber());
32 m_text->SetElement(text->GetElement());
33 m_text->SetDataType(text->GetDataType());
34 m_text->SetDirection(text->GetDirection());
35 m_text->SetUnit(text->GetUnit());
36 m_text->SetDecimalPlaces(text->GetDecimalPlaces());
37
38 if (!LoadChoices()) {
39 m_choiceName->Enable(false);
40 m_choiceTextType->Enable(false);
41 m_choiceTextFromBus->Enable(false);
42 m_choiceTextToBus->Enable(false);
43 m_choiceTextUnit->Enable(false);
44 }
45}
ElectricCalculation::GetElementsFromList
virtual void GetElementsFromList(std::vector< Element * > elementList)
Separate the power elements from a generic list.
Definition ElectricCalculation.cpp:27
Text
Element that shows power element informations in workspace.
Definition Text.h:70

◆ ~TextForm()

TextForm::~TextForm ( )
virtual

Definition at line 47 of file TextForm.cpp.

47{}

Member Function Documentation

◆ DataTypeChoice()

void TextForm::DataTypeChoice ( )
virtual

Definition at line 978 of file TextForm.cpp.

979{
980 m_choiceTextFromBus->Enable(false);
981 m_choiceTextToBus->Enable(false);
982
983 m_choiceTextToBus->Clear();
984 m_choiceTextFromBus->Clear();
985 m_choiceTextUnit->Clear();
986
987 m_choiceTextUnit->Enable();
988
989 wxArrayString arrayString;
990 switch (m_text->GetDataType()) {
991 case DATA_NAME:
992 case DATA_PQ_THD: {
993 m_choiceTextUnit->Enable(false);
994 return;
995 } break;
996 case DATA_VOLTAGE:
997 case DATA_SC_VOLTAGE: {
998 arrayString.Add(_("p.u."));
999 arrayString.Add(_("V"));
1000 arrayString.Add(_("kV"));
1001 } break;
1002 case DATA_ANGLE: {
1003 arrayString.Add(_("Degrees"));
1004 arrayString.Add(_("Radians"));
1005 } break;
1006 case DATA_SC_CURRENT:
1007 case DATA_PF_CURRENT: {
1008 arrayString.Add(_("p.u."));
1009 arrayString.Add(_("A"));
1010 arrayString.Add(_("kA"));
1011 } break;
1012 case DATA_SC_POWER: {
1013 arrayString.Add(_("p.u."));
1014 arrayString.Add(_("VA"));
1015 arrayString.Add(_("kVA"));
1016 arrayString.Add(_("MVA"));
1017 } break;
1018 case DATA_ACTIVE_POWER:
1019 case DATA_PF_ACTIVE:
1020 case DATA_PF_LOSSES: {
1021 arrayString.Add(_("p.u."));
1022 arrayString.Add(_("W"));
1023 arrayString.Add(_("kW"));
1024 arrayString.Add(_("MW"));
1025 m_choiceTextUnit->Enable();
1026 } break;
1027 case DATA_REACTIVE_POWER:
1028 case DATA_PF_REACTIVE: {
1029 arrayString.Add(_("p.u."));
1030 arrayString.Add(_("var"));
1031 arrayString.Add(_("kvar"));
1032 arrayString.Add(_("Mvar"));
1033 } break;
1034 default:
1035 break;
1036 }
1037 m_choiceTextUnit->Append(arrayString);
1038
1039 switch (m_text->GetElementTypeText()) {
1040 case TYPE_LINE: {
1041 if (m_text->GetDataType() != DATA_PF_LOSSES) {
1042 //auto it = m_allElements.GetLineList().begin();
1043 //std::advance(it, m_text->GetElementNumber());
1044 Line* line = m_allElements.GetLineList()[m_text->GetElementNumber()];
1045 //Line* line = *it;
1046
1047 Bus* bus1 = static_cast<Bus*>(line->GetParentList()[0]);
1048 Bus* bus2 = static_cast<Bus*>(line->GetParentList()[1]);
1049 wxString bus1Name = bus1->GetElectricalData().name;
1050 wxString bus2Name = bus2->GetElectricalData().name;
1051
1052 m_choiceTextFromBus->Append(bus1Name);
1053 m_choiceTextFromBus->Append(bus2Name);
1054 m_choiceTextToBus->Append(bus2Name);
1055 m_choiceTextToBus->Append(bus1Name);
1056 m_choiceTextFromBus->SetSelection(0);
1057 m_choiceTextToBus->SetSelection(0);
1058
1059 m_choiceTextFromBus->Enable();
1060 m_choiceTextToBus->Enable();
1061 }
1062 } break;
1063 case TYPE_TRANSFORMER: {
1064 if (m_text->GetDataType() != DATA_PF_LOSSES) {
1065 //auto it = m_allElements.GetTransformerList().begin();
1066 //std::advance(it, m_text->GetElementNumber());
1067 Transformer* transformer = m_allElements.GetTransformerList()[m_text->GetElementNumber()];
1068
1069 Bus* bus1 = static_cast<Bus*>(transformer->GetParentList()[0]);
1070 Bus* bus2 = static_cast<Bus*>(transformer->GetParentList()[1]);
1071 wxString bus1Name = bus1->GetElectricalData().name;
1072 wxString bus2Name = bus2->GetElectricalData().name;
1073
1074 m_choiceTextFromBus->Append(bus1Name);
1075 m_choiceTextFromBus->Append(bus2Name);
1076 m_choiceTextToBus->Append(bus2Name);
1077 m_choiceTextToBus->Append(bus1Name);
1078 m_choiceTextFromBus->SetSelection(0);
1079 m_choiceTextToBus->SetSelection(0);
1080
1081 m_choiceTextFromBus->Enable();
1082 m_choiceTextToBus->Enable();
1083 }
1084 } break;
1085 default:
1086 break;
1087 }
1088}
Bus
Node for power elements. All others power elements are connected through this.
Definition Bus.h:86
ElectricCalculation::GetTransformerList
const std::vector< Transformer * > GetTransformerList() const
Get the transformers of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:338
ElectricCalculation::GetLineList
const std::vector< Line * > GetLineList() const
Get the lines of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:318
Element::GetParentList
virtual std::vector< Element * > GetParentList() const
Get the parent list.
Definition Element.h:562
Line
Power line element.
Definition Line.h:64
Transformer
Two-winding transformer power element.
Definition Transformer.h:84

◆ ElementNumberChoice()

void TextForm::ElementNumberChoice ( )
virtual

Definition at line 874 of file TextForm.cpp.

875{
876 m_choiceTextFromBus->Enable(false);
877 m_choiceTextToBus->Enable(false);
878 m_choiceTextUnit->Enable(false);
879 m_choiceTextFromBus->Clear();
880 m_choiceTextToBus->Clear();
881 m_choiceTextUnit->Clear();
882
883 int index = m_choiceName->GetSelection();
884 m_text->SetElementNumber(index);
885
886 m_choiceTextType->Clear();
887 wxArrayString arrayString;
888 switch (m_text->GetElementTypeText()) {
889 case TYPE_BUS: {
890 Bus* bus = m_allElements.GetBusList()[index];
891 m_text->SetElement(bus);
892
893 arrayString.Add(_("Name"));
894 arrayString.Add(_("Voltage"));
895 arrayString.Add(_("Angle"));
896 arrayString.Add(_("Fault current"));
897 arrayString.Add(_("Fault voltage"));
898 arrayString.Add(_("Short-circuit power"));
899 arrayString.Add(_("Voltage THD"));
900 } break;
901 case TYPE_SYNC_GENERATOR: {
902 SyncGenerator* syncGenerator = m_allElements.GetSyncGeneratorList()[index];
903 m_text->SetElement(syncGenerator);
904
905 arrayString.Add(_("Name"));
906 arrayString.Add(_("Active power"));
907 arrayString.Add(_("Reactive power"));
908 arrayString.Add(_("Fault current"));
909 } break;
910 case TYPE_LINE: {
911 Line* line = m_allElements.GetLineList()[index];
912 m_text->SetElement(line);
913
914 arrayString.Add(_("Name"));
915 arrayString.Add(_("Active power flow"));
916 arrayString.Add(_("Reactive power flow"));
917 arrayString.Add(_("Losses"));
918 arrayString.Add(_("Current"));
919 arrayString.Add(_("Fault current"));
920 } break;
921 case TYPE_TRANSFORMER: {
922 Transformer* transformer = m_allElements.GetTransformerList()[index];
923 m_text->SetElement(transformer);
924
925 arrayString.Add(_("Name"));
926 arrayString.Add(_("Active power flow"));
927 arrayString.Add(_("Reactive power flow"));
928 arrayString.Add(_("Losses"));
929 arrayString.Add(_("Current"));
930 arrayString.Add(_("Fault current"));
931 } break;
932 case TYPE_LOAD: {
933 Load* load = m_allElements.GetLoadList()[index];
934 m_text->SetElement(load);
935
936 arrayString.Add(_("Name"));
937 arrayString.Add(_("Active power"));
938 arrayString.Add(_("Reactive power"));
939 } break;
940 case TYPE_CAPACITOR: {
941 Capacitor* capacitor = m_allElements.GetCapacitorList()[index];
942 m_text->SetElement(capacitor);
943
944 arrayString.Add(_("Name"));
945 arrayString.Add(_("Reactive power"));
946 } break;
947 case TYPE_INDUCTOR: {
948 Inductor* inductor = m_allElements.GetInductorList()[index];
949 m_text->SetElement(inductor);
950
951 arrayString.Add(_("Name"));
952 arrayString.Add(_("Reactive power"));
953 } break;
954 case TYPE_SYNC_MOTOR: {
955 SyncMotor* syncMotor = m_allElements.GetSyncMotorList()[index];
956 m_text->SetElement(syncMotor);
957
958 arrayString.Add(_("Name"));
959 arrayString.Add(_("Active power"));
960 arrayString.Add(_("Reactive power"));
961 } break;
962 case TYPE_IND_MOTOR: {
963 IndMotor* indMotor = m_allElements.GetIndMotorList()[index];
964 m_text->SetElement(indMotor);
965
966 arrayString.Add(_("Name"));
967 arrayString.Add(_("Active power"));
968 arrayString.Add(_("Reactive power"));
969 } break;
970
971 default:
972 break;
973 }
974 m_choiceTextType->Append(arrayString);
975 m_choiceTextType->Enable();
976}
Capacitor
Shunt capactior power element.
Definition Capacitor.h:39
ElectricCalculation::GetIndMotorList
const std::vector< IndMotor * > GetIndMotorList() const
Get the induction motors of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:308
ElectricCalculation::GetLoadList
const std::vector< Load * > GetLoadList() const
Get the loads of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:323
ElectricCalculation::GetSyncMotorList
const std::vector< SyncMotor * > GetSyncMotorList() const
Get the synchronous motors of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:333
ElectricCalculation::GetSyncGeneratorList
const std::vector< SyncGenerator * > GetSyncGeneratorList() const
Get the synchronous generators of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:328
ElectricCalculation::GetCapacitorList
const std::vector< Capacitor * > GetCapacitorList() const
Get the capacitors of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:303
ElectricCalculation::GetInductorList
const std::vector< Inductor * > GetInductorList() const
Get the inductors of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:313
ElectricCalculation::GetBusList
const std::vector< Bus * > GetBusList() const
Get the buses of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:298
IndMotor
Induction motor power element.
Definition IndMotor.h:119
Inductor
Inductor shunt power element.
Definition Inductor.h:39
Load
Loas shunt power element.
Definition Load.h:74
SyncGenerator
Synchronous generator power element.
Definition SyncGenerator.h:146
SyncMotor
Synchronous motor (synchronous compensator) power element.
Definition SyncMotor.h:135

◆ ElementTypeChoice()

void TextForm::ElementTypeChoice ( )
virtual

Definition at line 798 of file TextForm.cpp.

799{
800 m_choiceTextType->Enable(false);
801 m_choiceTextFromBus->Enable(false);
802 m_choiceTextToBus->Enable(false);
803 m_choiceTextUnit->Enable(false);
804 m_choiceTextType->Clear();
805 m_choiceTextFromBus->Clear();
806 m_choiceTextToBus->Clear();
807 m_choiceTextUnit->Clear();
808
809 m_choiceName->Clear();
810 wxArrayString arrayString;
811 switch (m_text->GetElementTypeText()) {
812 case TYPE_BUS: {
813 for (int i = 0; i < (int)m_allElements.GetBusList().size(); i++) {
814 Bus* bus = m_allElements.GetBusList()[i];
815 arrayString.Add(bus->GetElectricalData().name);
816 }
817 } break;
818 case TYPE_SYNC_GENERATOR: {
819 for (int i = 0; i < (int)m_allElements.GetSyncGeneratorList().size(); i++) {
820 SyncGenerator* syncGenerator = m_allElements.GetSyncGeneratorList()[i];
821 arrayString.Add(syncGenerator->GetElectricalData().name);
822 }
823 } break;
824 case TYPE_LINE: {
825 for (int i = 0; i < (int)m_allElements.GetLineList().size(); i++) {
826 Line* line = m_allElements.GetLineList()[i];
827 arrayString.Add(line->GetElectricalData().name);
828 }
829 } break;
830 case TYPE_TRANSFORMER: {
831 for (int i = 0; i < (int)m_allElements.GetTransformerList().size(); i++) {
832 Transformer* transformer = m_allElements.GetTransformerList()[i];
833 arrayString.Add(transformer->GetElectricalData().name);
834 }
835 } break;
836 case TYPE_LOAD: {
837 for (int i = 0; i < (int)m_allElements.GetLoadList().size(); i++) {
838 Load* load = m_allElements.GetLoadList()[i];
839 arrayString.Add(load->GetElectricalData().name);
840 }
841 } break;
842 case TYPE_CAPACITOR: {
843 for (int i = 0; i < (int)m_allElements.GetCapacitorList().size(); i++) {
844 Capacitor* capacitor = m_allElements.GetCapacitorList()[i];
845 arrayString.Add(capacitor->GetElectricalData().name);
846 }
847 } break;
848 case TYPE_INDUCTOR: {
849 for (int i = 0; i < (int)m_allElements.GetInductorList().size(); i++) {
850 Inductor* inductor = m_allElements.GetInductorList()[i];
851 arrayString.Add(inductor->GetElectricalData().name);
852 }
853 } break;
854 case TYPE_SYNC_MOTOR: {
855 for (int i = 0; i < (int)m_allElements.GetSyncMotorList().size(); i++) {
856 SyncMotor* syncMotor = m_allElements.GetSyncMotorList()[i];
857 arrayString.Add(syncMotor->GetElectricalData().name);
858 }
859 } break;
860 case TYPE_IND_MOTOR: {
861 for (int i = 0; i < (int)m_allElements.GetIndMotorList().size(); i++) {
862 IndMotor* indMotor = m_allElements.GetIndMotorList()[i];
863 arrayString.Add(indMotor->GetElectricalData().name);
864 }
865 } break;
866
867 default:
868 break;
869 }
870 m_choiceName->Append(arrayString);
871 m_choiceName->Enable();
872}

◆ LoadChoices()

bool TextForm::LoadChoices ( )
virtual

Definition at line 212 of file TextForm.cpp.

213{
214 if (m_text->GetElementTypeText() == TYPE_NONE) return false;
215
216 // Fill the element possible choices.
217 ElementTypeChoice();
218 m_choiceName->SetSelection(m_text->GetElementNumber());
219 ElementNumberChoice();
220 DataTypeChoice();
221
222 // Select the saved choices.
223 switch (m_text->GetElementTypeText()) {
224 case TYPE_BUS: {
225 m_choiceElement->SetSelection(0);
226 switch (m_text->GetDataType()) {
227 case DATA_NAME: {
228 m_choiceTextType->SetSelection(0);
229 } break;
230 case DATA_VOLTAGE: {
231 m_choiceTextType->SetSelection(1);
232 switch (m_text->GetUnit()) {
233 case ElectricalUnit::UNIT_PU: {
234 m_choiceTextUnit->SetSelection(0);
235 } break;
236 case ElectricalUnit::UNIT_V: {
237 m_choiceTextUnit->SetSelection(1);
238 } break;
239 case ElectricalUnit::UNIT_kV: {
240 m_choiceTextUnit->SetSelection(2);
241 } break;
242 default:
243 break;
244 }
245
246 } break;
247 case DATA_ANGLE: {
248 m_choiceTextType->SetSelection(2);
249 switch (m_text->GetUnit()) {
250 case ElectricalUnit::UNIT_DEGREE: {
251 m_choiceTextUnit->SetSelection(0);
252 } break;
253 case ElectricalUnit::UNIT_RADIAN: {
254 m_choiceTextUnit->SetSelection(1);
255 } break;
256 default:
257 break;
258 }
259 } break;
260 case DATA_SC_CURRENT: {
261 m_choiceTextType->SetSelection(3);
262 switch (m_text->GetUnit()) {
263 case ElectricalUnit::UNIT_PU: {
264 m_choiceTextUnit->SetSelection(0);
265 } break;
266 case ElectricalUnit::UNIT_A: {
267 m_choiceTextUnit->SetSelection(1);
268 } break;
269 case ElectricalUnit::UNIT_kA: {
270 m_choiceTextUnit->SetSelection(2);
271 } break;
272 default:
273 break;
274 }
275 } break;
276 case DATA_SC_VOLTAGE: {
277 m_choiceTextType->SetSelection(4);
278 switch (m_text->GetUnit()) {
279 case ElectricalUnit::UNIT_PU: {
280 m_choiceTextUnit->SetSelection(0);
281 } break;
282 case ElectricalUnit::UNIT_V: {
283 m_choiceTextUnit->SetSelection(1);
284 } break;
285 case ElectricalUnit::UNIT_kV: {
286 m_choiceTextUnit->SetSelection(2);
287 } break;
288 default:
289 break;
290 }
291 } break;
292 case DATA_SC_POWER: {
293 m_choiceTextType->SetSelection(5);
294 switch (m_text->GetUnit()) {
295 case ElectricalUnit::UNIT_PU: {
296 m_choiceTextUnit->SetSelection(0);
297 } break;
298 case ElectricalUnit::UNIT_VA: {
299 m_choiceTextUnit->SetSelection(1);
300 } break;
301 case ElectricalUnit::UNIT_kVA: {
302 m_choiceTextUnit->SetSelection(2);
303 } break;
304 case ElectricalUnit::UNIT_MVA: {
305 m_choiceTextUnit->SetSelection(3);
306 } break;
307 default:
308 break;
309 }
310 } break;
311 case DATA_PQ_THD: {
312 m_choiceTextType->SetSelection(6);
313 } break;
314 default:
315 break;
316 }
317 } break;
318 case TYPE_SYNC_GENERATOR: {
319 m_choiceElement->SetSelection(1);
320 switch (m_text->GetDataType()) {
321 case DATA_NAME: {
322 m_choiceTextType->SetSelection(0);
323 } break;
324 case DATA_ACTIVE_POWER: {
325 m_choiceTextType->SetSelection(1);
326 switch (m_text->GetUnit()) {
327 case ElectricalUnit::UNIT_PU: {
328 m_choiceTextUnit->SetSelection(0);
329 } break;
330 case ElectricalUnit::UNIT_W: {
331 m_choiceTextUnit->SetSelection(1);
332 } break;
333 case ElectricalUnit::UNIT_kW: {
334 m_choiceTextUnit->SetSelection(2);
335 } break;
336 case ElectricalUnit::UNIT_MW: {
337 m_choiceTextUnit->SetSelection(3);
338 } break;
339 default:
340 break;
341 }
342 } break;
343 case DATA_REACTIVE_POWER: {
344 m_choiceTextType->SetSelection(2);
345 switch (m_text->GetUnit()) {
346 case ElectricalUnit::UNIT_PU: {
347 m_choiceTextUnit->SetSelection(0);
348 } break;
349 case ElectricalUnit::UNIT_var: {
350 m_choiceTextUnit->SetSelection(1);
351 } break;
352 case ElectricalUnit::UNIT_kvar: {
353 m_choiceTextUnit->SetSelection(2);
354 } break;
355 case ElectricalUnit::UNIT_Mvar: {
356 m_choiceTextUnit->SetSelection(3);
357 } break;
358 default:
359 break;
360 }
361 } break;
362 case DATA_SC_CURRENT: {
363 m_choiceTextType->SetSelection(3);
364 switch (m_text->GetUnit()) {
365 case ElectricalUnit::UNIT_PU: {
366 m_choiceTextUnit->SetSelection(0);
367 } break;
368 case ElectricalUnit::UNIT_A: {
369 m_choiceTextUnit->SetSelection(1);
370 } break;
371 case ElectricalUnit::UNIT_kA: {
372 m_choiceTextUnit->SetSelection(2);
373 } break;
374 default:
375 break;
376 }
377 } break;
378 default:
379 break;
380 }
381 } break;
382 case TYPE_LINE: {
383 m_choiceElement->SetSelection(2);
384 switch (m_text->GetDataType()) {
385 case DATA_NAME: {
386 m_choiceTextType->SetSelection(0);
387 } break;
388 case DATA_PF_ACTIVE: {
389 m_choiceTextType->SetSelection(1);
390 switch (m_text->GetUnit()) {
391 case ElectricalUnit::UNIT_PU: {
392 m_choiceTextUnit->SetSelection(0);
393 } break;
394 case ElectricalUnit::UNIT_W: {
395 m_choiceTextUnit->SetSelection(1);
396 } break;
397 case ElectricalUnit::UNIT_kW: {
398 m_choiceTextUnit->SetSelection(2);
399 } break;
400 case ElectricalUnit::UNIT_MW: {
401 m_choiceTextUnit->SetSelection(3);
402 } break;
403 default:
404 break;
405 }
406 } break;
407 case DATA_PF_REACTIVE: {
408 m_choiceTextType->SetSelection(2);
409 switch (m_text->GetUnit()) {
410 case ElectricalUnit::UNIT_PU: {
411 m_choiceTextUnit->SetSelection(0);
412 } break;
413 case ElectricalUnit::UNIT_var: {
414 m_choiceTextUnit->SetSelection(1);
415 } break;
416 case ElectricalUnit::UNIT_kvar: {
417 m_choiceTextUnit->SetSelection(2);
418 } break;
419 case ElectricalUnit::UNIT_Mvar: {
420 m_choiceTextUnit->SetSelection(3);
421 } break;
422 default:
423 break;
424 }
425 } break;
426 case DATA_PF_LOSSES: {
427 m_choiceTextType->SetSelection(3);
428 switch (m_text->GetUnit()) {
429 case ElectricalUnit::UNIT_PU: {
430 m_choiceTextUnit->SetSelection(0);
431 } break;
432 case ElectricalUnit::UNIT_W: {
433 m_choiceTextUnit->SetSelection(1);
434 } break;
435 case ElectricalUnit::UNIT_kW: {
436 m_choiceTextUnit->SetSelection(2);
437 } break;
438 case ElectricalUnit::UNIT_MW: {
439 m_choiceTextUnit->SetSelection(3);
440 } break;
441 default:
442 break;
443 }
444 } break;
445 case DATA_PF_CURRENT: {
446 m_choiceTextType->SetSelection(4);
447 switch (m_text->GetUnit()) {
448 case ElectricalUnit::UNIT_PU: {
449 m_choiceTextUnit->SetSelection(0);
450 } break;
451 case ElectricalUnit::UNIT_A: {
452 m_choiceTextUnit->SetSelection(1);
453 } break;
454 case ElectricalUnit::UNIT_kA: {
455 m_choiceTextUnit->SetSelection(2);
456 } break;
457 default:
458 break;
459 }
460 } break;
461 case DATA_SC_CURRENT: {
462 m_choiceTextType->SetSelection(5);
463 switch (m_text->GetUnit()) {
464 case ElectricalUnit::UNIT_PU: {
465 m_choiceTextUnit->SetSelection(0);
466 } break;
467 case ElectricalUnit::UNIT_A: {
468 m_choiceTextUnit->SetSelection(1);
469 } break;
470 case ElectricalUnit::UNIT_kA: {
471 m_choiceTextUnit->SetSelection(2);
472 } break;
473 case ElectricalUnit::UNIT_MW: {
474 m_choiceTextUnit->SetSelection(3);
475 } break;
476 default:
477 break;
478 }
479 } break;
480 default:
481 break;
482 }
483 } break;
484 case TYPE_TRANSFORMER: {
485 m_choiceElement->SetSelection(3);
486 switch (m_text->GetDataType()) {
487 case DATA_NAME: {
488 m_choiceTextType->SetSelection(0);
489 } break;
490 case DATA_PF_ACTIVE: {
491 m_choiceTextType->SetSelection(1);
492 switch (m_text->GetUnit()) {
493 case ElectricalUnit::UNIT_PU: {
494 m_choiceTextUnit->SetSelection(0);
495 } break;
496 case ElectricalUnit::UNIT_W: {
497 m_choiceTextUnit->SetSelection(1);
498 } break;
499 case ElectricalUnit::UNIT_kW: {
500 m_choiceTextUnit->SetSelection(2);
501 } break;
502 case ElectricalUnit::UNIT_MW: {
503 m_choiceTextUnit->SetSelection(3);
504 } break;
505 default:
506 break;
507 }
508 } break;
509 case DATA_PF_REACTIVE: {
510 m_choiceTextType->SetSelection(2);
511 switch (m_text->GetUnit()) {
512 case ElectricalUnit::UNIT_PU: {
513 m_choiceTextUnit->SetSelection(0);
514 } break;
515 case ElectricalUnit::UNIT_var: {
516 m_choiceTextUnit->SetSelection(1);
517 } break;
518 case ElectricalUnit::UNIT_kvar: {
519 m_choiceTextUnit->SetSelection(2);
520 } break;
521 case ElectricalUnit::UNIT_Mvar: {
522 m_choiceTextUnit->SetSelection(3);
523 } break;
524 default:
525 break;
526 }
527 } break;
528 case DATA_PF_LOSSES: {
529 m_choiceTextType->SetSelection(3);
530 switch (m_text->GetUnit()) {
531 case ElectricalUnit::UNIT_PU: {
532 m_choiceTextUnit->SetSelection(0);
533 } break;
534 case ElectricalUnit::UNIT_W: {
535 m_choiceTextUnit->SetSelection(1);
536 } break;
537 case ElectricalUnit::UNIT_kW: {
538 m_choiceTextUnit->SetSelection(2);
539 } break;
540 case ElectricalUnit::UNIT_MW: {
541 m_choiceTextUnit->SetSelection(3);
542 } break;
543 default:
544 break;
545 }
546 } break;
547 case DATA_PF_CURRENT: {
548 m_choiceTextType->SetSelection(4);
549 switch (m_text->GetUnit()) {
550 case ElectricalUnit::UNIT_PU: {
551 m_choiceTextUnit->SetSelection(0);
552 } break;
553 case ElectricalUnit::UNIT_A: {
554 m_choiceTextUnit->SetSelection(1);
555 } break;
556 case ElectricalUnit::UNIT_kA: {
557 m_choiceTextUnit->SetSelection(2);
558 } break;
559 default:
560 break;
561 }
562 } break;
563 case DATA_SC_CURRENT: {
564 m_choiceTextType->SetSelection(5);
565 switch (m_text->GetUnit()) {
566 case ElectricalUnit::UNIT_PU: {
567 m_choiceTextUnit->SetSelection(0);
568 } break;
569 case ElectricalUnit::UNIT_A: {
570 m_choiceTextUnit->SetSelection(1);
571 } break;
572 case ElectricalUnit::UNIT_kA: {
573 m_choiceTextUnit->SetSelection(2);
574 } break;
575 default:
576 break;
577 }
578 } break;
579 default:
580 break;
581 }
582 } break;
583 case TYPE_LOAD: {
584 m_choiceElement->SetSelection(4);
585 switch (m_text->GetDataType()) {
586 case DATA_NAME: {
587 m_choiceTextType->SetSelection(0);
588 } break;
589 case DATA_ACTIVE_POWER: {
590 m_choiceTextType->SetSelection(1);
591 switch (m_text->GetUnit()) {
592 case ElectricalUnit::UNIT_PU: {
593 m_choiceTextUnit->SetSelection(0);
594 } break;
595 case ElectricalUnit::UNIT_W: {
596 m_choiceTextUnit->SetSelection(1);
597 } break;
598 case ElectricalUnit::UNIT_kW: {
599 m_choiceTextUnit->SetSelection(2);
600 } break;
601 case ElectricalUnit::UNIT_MW: {
602 m_choiceTextUnit->SetSelection(3);
603 } break;
604 default:
605 break;
606 }
607 } break;
608 case DATA_REACTIVE_POWER: {
609 m_choiceTextType->SetSelection(2);
610 switch (m_text->GetUnit()) {
611 case ElectricalUnit::UNIT_PU: {
612 m_choiceTextUnit->SetSelection(0);
613 } break;
614 case ElectricalUnit::UNIT_var: {
615 m_choiceTextUnit->SetSelection(1);
616 } break;
617 case ElectricalUnit::UNIT_kvar: {
618 m_choiceTextUnit->SetSelection(2);
619 } break;
620 case ElectricalUnit::UNIT_Mvar: {
621 m_choiceTextUnit->SetSelection(3);
622 } break;
623 default:
624 break;
625 }
626 } break;
627 default:
628 break;
629 }
630 } break;
631 case TYPE_CAPACITOR: {
632 m_choiceElement->SetSelection(5);
633 switch (m_text->GetDataType()) {
634 case DATA_NAME: {
635 m_choiceTextType->SetSelection(0);
636 } break;
637 case DATA_REACTIVE_POWER: {
638 m_choiceTextType->SetSelection(1);
639 switch (m_text->GetUnit()) {
640 case ElectricalUnit::UNIT_PU: {
641 m_choiceTextUnit->SetSelection(0);
642 } break;
643 case ElectricalUnit::UNIT_var: {
644 m_choiceTextUnit->SetSelection(1);
645 } break;
646 case ElectricalUnit::UNIT_kvar: {
647 m_choiceTextUnit->SetSelection(2);
648 } break;
649 case ElectricalUnit::UNIT_Mvar: {
650 m_choiceTextUnit->SetSelection(3);
651 } break;
652 default:
653 break;
654 }
655 } break;
656 default:
657 break;
658 }
659 } break;
660 case TYPE_INDUCTOR: {
661 m_choiceElement->SetSelection(6);
662 switch (m_text->GetDataType()) {
663 case DATA_NAME: {
664 m_choiceTextType->SetSelection(0);
665 } break;
666 case DATA_REACTIVE_POWER: {
667 m_choiceTextType->SetSelection(1);
668 switch (m_text->GetUnit()) {
669 case ElectricalUnit::UNIT_PU: {
670 m_choiceTextUnit->SetSelection(0);
671 } break;
672 case ElectricalUnit::UNIT_var: {
673 m_choiceTextUnit->SetSelection(1);
674 } break;
675 case ElectricalUnit::UNIT_kvar: {
676 m_choiceTextUnit->SetSelection(2);
677 } break;
678 case ElectricalUnit::UNIT_Mvar: {
679 m_choiceTextUnit->SetSelection(3);
680 } break;
681 default:
682 break;
683 }
684 } break;
685 default:
686 break;
687 }
688 } break;
689 case TYPE_SYNC_MOTOR: {
690 m_choiceElement->SetSelection(7);
691 switch (m_text->GetDataType()) {
692 case DATA_NAME: {
693 m_choiceTextType->SetSelection(0);
694 } break;
695 case DATA_ACTIVE_POWER: {
696 m_choiceTextType->SetSelection(1);
697 switch (m_text->GetUnit()) {
698 case ElectricalUnit::UNIT_PU: {
699 m_choiceTextUnit->SetSelection(0);
700 } break;
701 case ElectricalUnit::UNIT_W: {
702 m_choiceTextUnit->SetSelection(1);
703 } break;
704 case ElectricalUnit::UNIT_kW: {
705 m_choiceTextUnit->SetSelection(2);
706 } break;
707 case ElectricalUnit::UNIT_MW: {
708 m_choiceTextUnit->SetSelection(3);
709 } break;
710 default:
711 break;
712 }
713 } break;
714 case DATA_REACTIVE_POWER: {
715 m_choiceTextType->SetSelection(2);
716 switch (m_text->GetUnit()) {
717 case ElectricalUnit::UNIT_PU: {
718 m_choiceTextUnit->SetSelection(0);
719 } break;
720 case ElectricalUnit::UNIT_var: {
721 m_choiceTextUnit->SetSelection(1);
722 } break;
723 case ElectricalUnit::UNIT_kvar: {
724 m_choiceTextUnit->SetSelection(2);
725 } break;
726 case ElectricalUnit::UNIT_Mvar: {
727 m_choiceTextUnit->SetSelection(3);
728 } break;
729 default:
730 break;
731 }
732 } break;
733 default:
734 break;
735 }
736 } break;
737 case TYPE_IND_MOTOR: {
738 m_choiceElement->SetSelection(8);
739 switch (m_text->GetDataType()) {
740 case DATA_NAME: {
741 m_choiceTextType->SetSelection(0);
742 } break;
743 case DATA_ACTIVE_POWER: {
744 m_choiceTextType->SetSelection(1);
745 switch (m_text->GetUnit()) {
746 case ElectricalUnit::UNIT_PU: {
747 m_choiceTextUnit->SetSelection(0);
748 } break;
749 case ElectricalUnit::UNIT_W: {
750 m_choiceTextUnit->SetSelection(1);
751 } break;
752 case ElectricalUnit::UNIT_kW: {
753 m_choiceTextUnit->SetSelection(2);
754 } break;
755 case ElectricalUnit::UNIT_MW: {
756 m_choiceTextUnit->SetSelection(3);
757 } break;
758 default:
759 break;
760 }
761 } break;
762 case DATA_REACTIVE_POWER: {
763 m_choiceTextType->SetSelection(2);
764 switch (m_text->GetUnit()) {
765 case ElectricalUnit::UNIT_PU: {
766 m_choiceTextUnit->SetSelection(0);
767 } break;
768 case ElectricalUnit::UNIT_var: {
769 m_choiceTextUnit->SetSelection(1);
770 } break;
771 case ElectricalUnit::UNIT_kvar: {
772 m_choiceTextUnit->SetSelection(2);
773 } break;
774 case ElectricalUnit::UNIT_Mvar: {
775 m_choiceTextUnit->SetSelection(3);
776 } break;
777 default:
778 break;
779 }
780 } break;
781 default:
782 break;
783 }
784 } break;
785 default:
786 break;
787 }
788
789 if (m_choiceTextFromBus->IsEnabled()) m_choiceTextFromBus->SetSelection(m_text->GetDirection());
790 if (m_choiceTextToBus->IsEnabled()) m_choiceTextToBus->SetSelection(m_text->GetDirection());
791
792 m_textCtrlDecimal->SetValue(wxString::Format("%d", m_text->GetDecimalPlaces()));
793 Preview();
794
795 return true;
796}

◆ OnCancelButtonClick()

virtual void TextForm::OnCancelButtonClick ( wxCommandEvent &  event)
inlineprotectedvirtual

Definition at line 50 of file TextForm.h.

50{ EndModal(wxID_CANCEL); }

◆ OnElementChoiceSelected()

void TextForm::OnElementChoiceSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 48 of file TextForm.cpp.

49{
50 switch (m_choiceElement->GetSelection()) {
51 case 0: {
52 m_text->SetElementTypeText(TYPE_BUS);
53 } break;
54 case 1: {
55 m_text->SetElementTypeText(TYPE_SYNC_GENERATOR);
56 } break;
57 case 2: {
58 m_text->SetElementTypeText(TYPE_LINE);
59 } break;
60 case 3: {
61 m_text->SetElementTypeText(TYPE_TRANSFORMER);
62 } break;
63 case 4: {
64 m_text->SetElementTypeText(TYPE_LOAD);
65 } break;
66 case 5: {
67 m_text->SetElementTypeText(TYPE_CAPACITOR);
68 } break;
69 case 6: {
70 m_text->SetElementTypeText(TYPE_INDUCTOR);
71 } break;
72 case 7: {
73 m_text->SetElementTypeText(TYPE_SYNC_MOTOR);
74 } break;
75 case 8: {
76 m_text->SetElementTypeText(TYPE_IND_MOTOR);
77 } break;
78
79 default:
80 break;
81 }
82
83 ElementTypeChoice();
84}

◆ OnFromBusChoiceSelected()

void TextForm::OnFromBusChoiceSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 86 of file TextForm.cpp.

87{
88 m_text->SetDirection(m_choiceTextFromBus->GetSelection());
89 m_choiceTextToBus->SetSelection(m_choiceTextFromBus->GetSelection());
90}

◆ OnNameChoiceSelected()

void TextForm::OnNameChoiceSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 92 of file TextForm.cpp.

93{
94 m_text->SetElementNumber(m_choiceName->GetSelection());
95 ElementNumberChoice();
96}

◆ OnOKButtonClick()

void TextForm::OnOKButtonClick ( wxCommandEvent &  event)
protectedvirtual

Definition at line 1245 of file TextForm.cpp.

1246{
1247 if (ValidateData()) {
1248 EndModal(wxID_OK);
1249 }
1250 else {
1251 wxString errorMsg = _("There are blank fields.");
1252 wxMessageDialog msgDialog(this, errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
1253 msgDialog.ShowModal();
1254 }
1255}

◆ OnTextEnter()

void TextForm::OnTextEnter ( wxCommandEvent &  event)
protectedvirtual

Definition at line 98 of file TextForm.cpp.

98{ Preview(); }

◆ OnToBusChoiceSelected()

void TextForm::OnToBusChoiceSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 99 of file TextForm.cpp.

100{
101 m_text->SetDirection(m_choiceTextToBus->GetSelection());
102 m_choiceTextFromBus->SetSelection(m_choiceTextToBus->GetSelection());
103}

◆ OnTypeChoiceSelected()

void TextForm::OnTypeChoiceSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 111 of file TextForm.cpp.

112{
113 switch (m_text->GetElementTypeText()) {
114 case TYPE_BUS: {
115 switch (m_choiceTextType->GetSelection()) {
116 case 0: {
117 m_text->SetDataType(DATA_NAME);
118 } break;
119 case 1: {
120 m_text->SetDataType(DATA_VOLTAGE);
121 } break;
122 case 2: {
123 m_text->SetDataType(DATA_ANGLE);
124 } break;
125 case 3: {
126 m_text->SetDataType(DATA_SC_CURRENT);
127 } break;
128 case 4: {
129 m_text->SetDataType(DATA_SC_VOLTAGE);
130 } break;
131 case 5: {
132 m_text->SetDataType(DATA_SC_POWER);
133 } break;
134 case 6: {
135 m_text->SetDataType(DATA_PQ_THD);
136 } break;
137 }
138 } break;
139 case TYPE_SYNC_GENERATOR: {
140 switch (m_choiceTextType->GetSelection()) {
141 case 0: {
142 m_text->SetDataType(DATA_NAME);
143 } break;
144 case 1: {
145 m_text->SetDataType(DATA_ACTIVE_POWER);
146 } break;
147 case 2: {
148 m_text->SetDataType(DATA_REACTIVE_POWER);
149 } break;
150 case 3: {
151 m_text->SetDataType(DATA_SC_CURRENT);
152 } break;
153 }
154 } break;
155 case TYPE_LINE:
156 case TYPE_TRANSFORMER: {
157 switch (m_choiceTextType->GetSelection()) {
158 case 0: {
159 m_text->SetDataType(DATA_NAME);
160 } break;
161 case 1: {
162 m_text->SetDataType(DATA_PF_ACTIVE);
163 } break;
164 case 2: {
165 m_text->SetDataType(DATA_PF_REACTIVE);
166 } break;
167 case 3: {
168 m_text->SetDataType(DATA_PF_LOSSES);
169 } break;
170 case 4: {
171 m_text->SetDataType(DATA_PF_CURRENT);
172 } break;
173 case 5: {
174 m_text->SetDataType(DATA_SC_CURRENT);
175 } break;
176 }
177 } break;
178 case TYPE_LOAD:
179 case TYPE_SYNC_MOTOR:
180 case TYPE_IND_MOTOR: {
181 switch (m_choiceTextType->GetSelection()) {
182 case 0: {
183 m_text->SetDataType(DATA_NAME);
184 } break;
185 case 1: {
186 m_text->SetDataType(DATA_ACTIVE_POWER);
187 } break;
188 case 2: {
189 m_text->SetDataType(DATA_REACTIVE_POWER);
190 } break;
191 }
192 } break;
193 case TYPE_CAPACITOR:
194 case TYPE_INDUCTOR: {
195 switch (m_choiceTextType->GetSelection()) {
196 case 0: {
197 m_text->SetDataType(DATA_NAME);
198 } break;
199 case 1: {
200 m_text->SetDataType(DATA_REACTIVE_POWER);
201 } break;
202 }
203 } break;
204 default:
205 break;
206 }
207 DataTypeChoice();
208
209 if (m_text->GetDataType() == DATA_NAME || m_text->GetDataType() == DATA_PQ_THD) Preview();
210}

◆ OnUnitChoiceSelected()

void TextForm::OnUnitChoiceSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 105 of file TextForm.cpp.

106{
107 UnitChoice();
108 Preview();
109}

◆ Preview()

void TextForm::Preview ( )
virtual

Definition at line 1203 of file TextForm.cpp.

1204{
1205 double decimalPlaces = m_text->GetDecimalPlaces();
1206 if (m_textCtrlDecimal->GetValue().ToDouble(&decimalPlaces)) m_text->SetDecimalPlaces(decimalPlaces);
1207
1208 m_text->UpdateText(m_systemPowerBase);
1209
1210 m_textCtrlPreview->SetValue(m_text->GetText());
1211}

◆ UnitChoice()

void TextForm::UnitChoice ( )
virtual

Definition at line 1090 of file TextForm.cpp.

1091{
1092 switch (m_text->GetDataType()) {
1093 case DATA_NAME: {
1094 m_choiceTextUnit->Enable(false);
1095 return;
1096 } break;
1097 case DATA_VOLTAGE:
1098 case DATA_SC_VOLTAGE: {
1099 switch (m_choiceTextUnit->GetSelection()) {
1100 case 0: {
1101 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1102 } break;
1103 case 1: {
1104 m_text->SetUnit(ElectricalUnit::UNIT_V);
1105 } break;
1106 case 2: {
1107 m_text->SetUnit(ElectricalUnit::UNIT_kV);
1108 } break;
1109 default:
1110 break;
1111 }
1112 } break;
1113 case DATA_ANGLE: {
1114 switch (m_choiceTextUnit->GetSelection()) {
1115 case 0: {
1116 m_text->SetUnit(ElectricalUnit::UNIT_DEGREE);
1117 } break;
1118 case 1: {
1119 m_text->SetUnit(ElectricalUnit::UNIT_RADIAN);
1120 } break;
1121 default:
1122 break;
1123 }
1124 } break;
1125 case DATA_SC_CURRENT:
1126 case DATA_PF_CURRENT: {
1127 switch (m_choiceTextUnit->GetSelection()) {
1128 case 0: {
1129 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1130 } break;
1131 case 1: {
1132 m_text->SetUnit(ElectricalUnit::UNIT_A);
1133 } break;
1134 case 2: {
1135 m_text->SetUnit(ElectricalUnit::UNIT_kA);
1136 } break;
1137 default:
1138 break;
1139 }
1140 } break;
1141 case DATA_SC_POWER: {
1142 switch (m_choiceTextUnit->GetSelection()) {
1143 case 0: {
1144 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1145 } break;
1146 case 1: {
1147 m_text->SetUnit(ElectricalUnit::UNIT_VA);
1148 } break;
1149 case 2: {
1150 m_text->SetUnit(ElectricalUnit::UNIT_kVA);
1151 } break;
1152 case 3: {
1153 m_text->SetUnit(ElectricalUnit::UNIT_MVA);
1154 } break;
1155 default:
1156 break;
1157 }
1158 } break;
1159 case DATA_ACTIVE_POWER:
1160 case DATA_PF_ACTIVE:
1161 case DATA_PF_LOSSES: {
1162 switch (m_choiceTextUnit->GetSelection()) {
1163 case 0: {
1164 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1165 } break;
1166 case 1: {
1167 m_text->SetUnit(ElectricalUnit::UNIT_W);
1168 } break;
1169 case 2: {
1170 m_text->SetUnit(ElectricalUnit::UNIT_kW);
1171 } break;
1172 case 3: {
1173 m_text->SetUnit(ElectricalUnit::UNIT_MW);
1174 } break;
1175 default:
1176 break;
1177 }
1178 } break;
1179 case DATA_REACTIVE_POWER:
1180 case DATA_PF_REACTIVE: {
1181 switch (m_choiceTextUnit->GetSelection()) {
1182 case 0: {
1183 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1184 } break;
1185 case 1: {
1186 m_text->SetUnit(ElectricalUnit::UNIT_var);
1187 } break;
1188 case 2: {
1189 m_text->SetUnit(ElectricalUnit::UNIT_kvar);
1190 } break;
1191 case 3: {
1192 m_text->SetUnit(ElectricalUnit::UNIT_Mvar);
1193 } break;
1194 default:
1195 break;
1196 }
1197 } break;
1198 default:
1199 break;
1200 }
1201}

◆ ValidateData()

bool TextForm::ValidateData ( )
virtual

Definition at line 1213 of file TextForm.cpp.

1214{
1215 if (m_choiceElement->GetSelection() == -1) return false;
1216 if (m_choiceName->GetSelection() == -1) return false;
1217 if (m_choiceTextType->GetSelection() == -1) return false;
1218 if (m_text->GetDataType() != DATA_NAME && m_text->GetDataType() != DATA_PQ_THD &&
1219 m_choiceTextUnit->GetSelection() == -1)
1220 return false;
1221 if (m_text->GetElementTypeText() == TYPE_LINE || m_text->GetElementTypeText() == TYPE_TRANSFORMER) {
1222 if (m_text->GetDataType() != DATA_PF_LOSSES && m_text->GetDataType() != DATA_NAME) {
1223 if (m_choiceTextFromBus->GetSelection() == -1) return false;
1224 if (m_choiceTextToBus->GetSelection() == -1) return false;
1225 }
1226 }
1227
1228 if (m_choiceTextFromBus->IsEnabled() && m_choiceTextToBus->IsEnabled())
1229 m_text->SetDirection(m_choiceTextFromBus->GetSelection());
1230 double decimalPlaces = m_text->GetDecimalPlaces();
1231 if (m_textCtrlDecimal->GetValue().ToDouble(&decimalPlaces)) m_text->SetDecimalPlaces(decimalPlaces);
1232
1233 m_textToEdit->SetElementTypeText(m_text->GetElementTypeText());
1234 m_textToEdit->SetElementNumber(m_text->GetElementNumber());
1235 m_textToEdit->SetElement(m_text->GetElement());
1236 m_textToEdit->SetDataType(m_text->GetDataType());
1237 m_textToEdit->SetDirection(m_text->GetDirection());
1238 m_textToEdit->SetUnit(m_text->GetUnit());
1239 m_textToEdit->SetDecimalPlaces(decimalPlaces);
1240 m_textToEdit->UpdateText(m_systemPowerBase);
1241
1242 return true;
1243}

Member Data Documentation

◆ m_allElements

ElectricCalculation TextForm::m_allElements
protected

Definition at line 62 of file TextForm.h.

◆ m_parent

wxWindow* TextForm::m_parent = nullptr
protected

Definition at line 61 of file TextForm.h.

◆ m_systemPowerBase

double TextForm::m_systemPowerBase
protected

Definition at line 63 of file TextForm.h.

◆ m_text

Text* TextForm::m_text = nullptr
protected

Definition at line 59 of file TextForm.h.

◆ m_textToEdit

Text* TextForm::m_textToEdit = nullptr
protected

Definition at line 60 of file TextForm.h.

The documentation for this class was generated from the following files: