Power System Platform  2026w34a-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)
 
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 
)

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:71

◆ ~TextForm()

TextForm::~TextForm ( )
virtual

Definition at line 47 of file TextForm.cpp.

47{}

Member Function Documentation

◆ DataTypeChoice()

void TextForm::DataTypeChoice ( )
virtual

Definition at line 997 of file TextForm.cpp.

998{
999 m_choiceTextFromBus->Enable(false);
1000 m_choiceTextToBus->Enable(false);
1001
1002 m_choiceTextToBus->Clear();
1003 m_choiceTextFromBus->Clear();
1004 m_choiceTextUnit->Clear();
1005
1006 m_choiceTextUnit->Enable();
1007
1008 wxArrayString arrayString;
1009 switch (m_text->GetDataType()) {
1010 case DATA_NAME:
1011 case DATA_PQ_THD: {
1012 m_choiceTextUnit->Enable(false);
1013 return;
1014 } break;
1015 case DATA_VOLTAGE:
1016 case DATA_SC_VOLTAGE: {
1017 arrayString.Add(_("p.u."));
1018 arrayString.Add(_("V"));
1019 arrayString.Add(_("kV"));
1020 } break;
1021 case DATA_ANGLE: {
1022 arrayString.Add(_("Degrees"));
1023 arrayString.Add(_("Radians"));
1024 } break;
1025 case DATA_SC_CURRENT:
1026 case DATA_PF_CURRENT: {
1027 arrayString.Add(_("p.u."));
1028 arrayString.Add(_("A"));
1029 arrayString.Add(_("kA"));
1030 } break;
1031 case DATA_SC_POWER: {
1032 arrayString.Add(_("p.u."));
1033 arrayString.Add(_("VA"));
1034 arrayString.Add(_("kVA"));
1035 arrayString.Add(_("MVA"));
1036 } break;
1037 case DATA_ACTIVE_POWER:
1038 case DATA_PF_ACTIVE:
1039 case DATA_PF_LOSSES: {
1040 arrayString.Add(_("p.u."));
1041 arrayString.Add(_("W"));
1042 arrayString.Add(_("kW"));
1043 arrayString.Add(_("MW"));
1044 m_choiceTextUnit->Enable();
1045 } break;
1046 case DATA_REACTIVE_POWER:
1047 case DATA_PF_REACTIVE: {
1048 arrayString.Add(_("p.u."));
1049 arrayString.Add(_("var"));
1050 arrayString.Add(_("kvar"));
1051 arrayString.Add(_("Mvar"));
1052 } break;
1053 case DATA_TRANSFORMER_TAP: {
1054 arrayString.Add(_("p.u."));
1055 arrayString.Add(_("None"));
1056 } break;
1057 default:
1058 break;
1059 }
1060 m_choiceTextUnit->Append(arrayString);
1061
1062 if (m_text->GetDataType() == DATA_TRANSFORMER_TAP) {
1063 m_choiceTextUnit->SetSelection(m_text->GetUnit() == ElectricalUnit::UNIT_NONE ? 1 : 0);
1064 }
1065
1066 switch (m_text->GetElementTypeText()) {
1067 case TYPE_LINE: {
1068 if (m_text->GetDataType() != DATA_PF_LOSSES) {
1069 //auto it = m_allElements.GetLineList().begin();
1070 //std::advance(it, m_text->GetElementNumber());
1071 Line* line = m_allElements.GetLineList()[m_text->GetElementNumber()];
1072 //Line* line = *it;
1073
1074 Bus* bus1 = static_cast<Bus*>(line->GetParentList()[0]);
1075 Bus* bus2 = static_cast<Bus*>(line->GetParentList()[1]);
1076 wxString bus1Name = bus1->GetElectricalData().name;
1077 wxString bus2Name = bus2->GetElectricalData().name;
1078
1079 m_choiceTextFromBus->Append(bus1Name);
1080 m_choiceTextFromBus->Append(bus2Name);
1081 m_choiceTextToBus->Append(bus2Name);
1082 m_choiceTextToBus->Append(bus1Name);
1083 m_choiceTextFromBus->SetSelection(0);
1084 m_choiceTextToBus->SetSelection(0);
1085
1086 m_choiceTextFromBus->Enable();
1087 m_choiceTextToBus->Enable();
1088 }
1089 } break;
1090 case TYPE_TRANSFORMER: {
1091 if (m_text->GetDataType() != DATA_PF_LOSSES && m_text->GetDataType() != DATA_TRANSFORMER_TAP) {
1092 //auto it = m_allElements.GetTransformerList().begin();
1093 //std::advance(it, m_text->GetElementNumber());
1094 Transformer* transformer = m_allElements.GetTransformerList()[m_text->GetElementNumber()];
1095
1096 Bus* bus1 = static_cast<Bus*>(transformer->GetParentList()[0]);
1097 Bus* bus2 = static_cast<Bus*>(transformer->GetParentList()[1]);
1098 wxString bus1Name = bus1->GetElectricalData().name;
1099 wxString bus2Name = bus2->GetElectricalData().name;
1100
1101 m_choiceTextFromBus->Append(bus1Name);
1102 m_choiceTextFromBus->Append(bus2Name);
1103 m_choiceTextToBus->Append(bus2Name);
1104 m_choiceTextToBus->Append(bus1Name);
1105 m_choiceTextFromBus->SetSelection(0);
1106 m_choiceTextToBus->SetSelection(0);
1107
1108 m_choiceTextFromBus->Enable();
1109 m_choiceTextToBus->Enable();
1110 }
1111 } break;
1112 default:
1113 break;
1114 }
1115}
Bus
Node for power elements. All others power elements are connected through this.
Definition Bus.h:87
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:567
Line
Power line element.
Definition Line.h:64
Transformer
Two-winding transformer power element with OLTC support.
Definition Transformer.h:96

◆ ElementNumberChoice()

void TextForm::ElementNumberChoice ( )
virtual

Definition at line 892 of file TextForm.cpp.

893{
894 m_choiceTextFromBus->Enable(false);
895 m_choiceTextToBus->Enable(false);
896 m_choiceTextUnit->Enable(false);
897 m_choiceTextFromBus->Clear();
898 m_choiceTextToBus->Clear();
899 m_choiceTextUnit->Clear();
900
901 int index = m_choiceName->GetSelection();
902 m_text->SetElementNumber(index);
903
904 m_choiceTextType->Clear();
905 wxArrayString arrayString;
906 switch (m_text->GetElementTypeText()) {
907 case TYPE_BUS: {
908 Bus* bus = m_allElements.GetBusList()[index];
909 m_text->SetElement(bus);
910
911 arrayString.Add(_("Name"));
912 arrayString.Add(_("Voltage"));
913 arrayString.Add(_("Angle"));
914 arrayString.Add(_("Fault current"));
915 arrayString.Add(_("Fault voltage"));
916 arrayString.Add(_("Short-circuit power"));
917 arrayString.Add(_("Voltage THD"));
918 } break;
919 case TYPE_SYNC_GENERATOR: {
920 SyncGenerator* syncGenerator = m_allElements.GetSyncGeneratorList()[index];
921 m_text->SetElement(syncGenerator);
922
923 arrayString.Add(_("Name"));
924 arrayString.Add(_("Active power"));
925 arrayString.Add(_("Reactive power"));
926 arrayString.Add(_("Fault current"));
927 } break;
928 case TYPE_LINE: {
929 Line* line = m_allElements.GetLineList()[index];
930 m_text->SetElement(line);
931
932 arrayString.Add(_("Name"));
933 arrayString.Add(_("Active power flow"));
934 arrayString.Add(_("Reactive power flow"));
935 arrayString.Add(_("Losses"));
936 arrayString.Add(_("Current"));
937 arrayString.Add(_("Fault current"));
938 } break;
939 case TYPE_TRANSFORMER: {
940 Transformer* transformer = m_allElements.GetTransformerList()[index];
941 m_text->SetElement(transformer);
942
943 arrayString.Add(_("Name"));
944 arrayString.Add(_("Active power flow"));
945 arrayString.Add(_("Reactive power flow"));
946 arrayString.Add(_("Losses"));
947 arrayString.Add(_("Current"));
948 arrayString.Add(_("Fault current"));
949 arrayString.Add(_("Tap"));
950 } break;
951 case TYPE_LOAD: {
952 Load* load = m_allElements.GetLoadList()[index];
953 m_text->SetElement(load);
954
955 arrayString.Add(_("Name"));
956 arrayString.Add(_("Active power"));
957 arrayString.Add(_("Reactive power"));
958 } break;
959 case TYPE_CAPACITOR: {
960 Capacitor* capacitor = m_allElements.GetCapacitorList()[index];
961 m_text->SetElement(capacitor);
962
963 arrayString.Add(_("Name"));
964 arrayString.Add(_("Reactive power"));
965 } break;
966 case TYPE_INDUCTOR: {
967 Inductor* inductor = m_allElements.GetInductorList()[index];
968 m_text->SetElement(inductor);
969
970 arrayString.Add(_("Name"));
971 arrayString.Add(_("Reactive power"));
972 } break;
973 case TYPE_SYNC_MOTOR: {
974 SyncMotor* syncMotor = m_allElements.GetSyncMotorList()[index];
975 m_text->SetElement(syncMotor);
976
977 arrayString.Add(_("Name"));
978 arrayString.Add(_("Active power"));
979 arrayString.Add(_("Reactive power"));
980 } break;
981 case TYPE_IND_MOTOR: {
982 IndMotor* indMotor = m_allElements.GetIndMotorList()[index];
983 m_text->SetElement(indMotor);
984
985 arrayString.Add(_("Name"));
986 arrayString.Add(_("Active power"));
987 arrayString.Add(_("Reactive power"));
988 } break;
989
990 default:
991 break;
992 }
993 m_choiceTextType->Append(arrayString);
994 m_choiceTextType->Enable();
995}
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 816 of file TextForm.cpp.

817{
818 m_choiceTextType->Enable(false);
819 m_choiceTextFromBus->Enable(false);
820 m_choiceTextToBus->Enable(false);
821 m_choiceTextUnit->Enable(false);
822 m_choiceTextType->Clear();
823 m_choiceTextFromBus->Clear();
824 m_choiceTextToBus->Clear();
825 m_choiceTextUnit->Clear();
826
827 m_choiceName->Clear();
828 wxArrayString arrayString;
829 switch (m_text->GetElementTypeText()) {
830 case TYPE_BUS: {
831 for (int i = 0; i < (int)m_allElements.GetBusList().size(); i++) {
832 Bus* bus = m_allElements.GetBusList()[i];
833 arrayString.Add(bus->GetElectricalData().name);
834 }
835 } break;
836 case TYPE_SYNC_GENERATOR: {
837 for (int i = 0; i < (int)m_allElements.GetSyncGeneratorList().size(); i++) {
838 SyncGenerator* syncGenerator = m_allElements.GetSyncGeneratorList()[i];
839 arrayString.Add(syncGenerator->GetElectricalData().name);
840 }
841 } break;
842 case TYPE_LINE: {
843 for (int i = 0; i < (int)m_allElements.GetLineList().size(); i++) {
844 Line* line = m_allElements.GetLineList()[i];
845 arrayString.Add(line->GetElectricalData().name);
846 }
847 } break;
848 case TYPE_TRANSFORMER: {
849 for (int i = 0; i < (int)m_allElements.GetTransformerList().size(); i++) {
850 Transformer* transformer = m_allElements.GetTransformerList()[i];
851 arrayString.Add(transformer->GetElectricalData().name);
852 }
853 } break;
854 case TYPE_LOAD: {
855 for (int i = 0; i < (int)m_allElements.GetLoadList().size(); i++) {
856 Load* load = m_allElements.GetLoadList()[i];
857 arrayString.Add(load->GetElectricalData().name);
858 }
859 } break;
860 case TYPE_CAPACITOR: {
861 for (int i = 0; i < (int)m_allElements.GetCapacitorList().size(); i++) {
862 Capacitor* capacitor = m_allElements.GetCapacitorList()[i];
863 arrayString.Add(capacitor->GetElectricalData().name);
864 }
865 } break;
866 case TYPE_INDUCTOR: {
867 for (int i = 0; i < (int)m_allElements.GetInductorList().size(); i++) {
868 Inductor* inductor = m_allElements.GetInductorList()[i];
869 arrayString.Add(inductor->GetElectricalData().name);
870 }
871 } break;
872 case TYPE_SYNC_MOTOR: {
873 for (int i = 0; i < (int)m_allElements.GetSyncMotorList().size(); i++) {
874 SyncMotor* syncMotor = m_allElements.GetSyncMotorList()[i];
875 arrayString.Add(syncMotor->GetElectricalData().name);
876 }
877 } break;
878 case TYPE_IND_MOTOR: {
879 for (int i = 0; i < (int)m_allElements.GetIndMotorList().size(); i++) {
880 IndMotor* indMotor = m_allElements.GetIndMotorList()[i];
881 arrayString.Add(indMotor->GetElectricalData().name);
882 }
883 } break;
884
885 default:
886 break;
887 }
888 m_choiceName->Append(arrayString);
889 m_choiceName->Enable();
890}

◆ LoadChoices()

bool TextForm::LoadChoices ( )
virtual

Definition at line 216 of file TextForm.cpp.

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

◆ 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 1284 of file TextForm.cpp.

1285{
1286 if (ValidateData()) {
1287 EndModal(wxID_OK);
1288 }
1289 else {
1290 wxString errorMsg = _("There are blank fields.");
1291 wxMessageDialog msgDialog(this, errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
1292 msgDialog.ShowModal();
1293 }
1294}

◆ 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 case 6: {
177 m_text->SetDataType(DATA_TRANSFORMER_TAP);
178 m_text->SetUnit(ElectricalUnit::UNIT_PU);
179 } break;
180 }
181 } break;
182 case TYPE_LOAD:
183 case TYPE_SYNC_MOTOR:
184 case TYPE_IND_MOTOR: {
185 switch (m_choiceTextType->GetSelection()) {
186 case 0: {
187 m_text->SetDataType(DATA_NAME);
188 } break;
189 case 1: {
190 m_text->SetDataType(DATA_ACTIVE_POWER);
191 } break;
192 case 2: {
193 m_text->SetDataType(DATA_REACTIVE_POWER);
194 } break;
195 }
196 } break;
197 case TYPE_CAPACITOR:
198 case TYPE_INDUCTOR: {
199 switch (m_choiceTextType->GetSelection()) {
200 case 0: {
201 m_text->SetDataType(DATA_NAME);
202 } break;
203 case 1: {
204 m_text->SetDataType(DATA_REACTIVE_POWER);
205 } break;
206 }
207 } break;
208 default:
209 break;
210 }
211 DataTypeChoice();
212
213 if (m_text->GetDataType() == DATA_NAME || m_text->GetDataType() == DATA_PQ_THD || m_text->GetDataType() == DATA_TRANSFORMER_TAP) Preview();
214}

◆ 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 1242 of file TextForm.cpp.

1243{
1244 double decimalPlaces = m_text->GetDecimalPlaces();
1245 if (m_textCtrlDecimal->GetValue().ToDouble(&decimalPlaces)) m_text->SetDecimalPlaces(decimalPlaces);
1246
1247 m_text->UpdateText(m_systemPowerBase);
1248
1249 m_textCtrlPreview->SetValue(m_text->GetText());
1250}

◆ UnitChoice()

void TextForm::UnitChoice ( )
virtual

Definition at line 1117 of file TextForm.cpp.

1118{
1119 switch (m_text->GetDataType()) {
1120 case DATA_NAME: {
1121 m_choiceTextUnit->Enable(false);
1122 return;
1123 } break;
1124 case DATA_VOLTAGE:
1125 case DATA_SC_VOLTAGE: {
1126 switch (m_choiceTextUnit->GetSelection()) {
1127 case 0: {
1128 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1129 } break;
1130 case 1: {
1131 m_text->SetUnit(ElectricalUnit::UNIT_V);
1132 } break;
1133 case 2: {
1134 m_text->SetUnit(ElectricalUnit::UNIT_kV);
1135 } break;
1136 default:
1137 break;
1138 }
1139 } break;
1140 case DATA_ANGLE: {
1141 switch (m_choiceTextUnit->GetSelection()) {
1142 case 0: {
1143 m_text->SetUnit(ElectricalUnit::UNIT_DEGREE);
1144 } break;
1145 case 1: {
1146 m_text->SetUnit(ElectricalUnit::UNIT_RADIAN);
1147 } break;
1148 default:
1149 break;
1150 }
1151 } break;
1152 case DATA_SC_CURRENT:
1153 case DATA_PF_CURRENT: {
1154 switch (m_choiceTextUnit->GetSelection()) {
1155 case 0: {
1156 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1157 } break;
1158 case 1: {
1159 m_text->SetUnit(ElectricalUnit::UNIT_A);
1160 } break;
1161 case 2: {
1162 m_text->SetUnit(ElectricalUnit::UNIT_kA);
1163 } break;
1164 default:
1165 break;
1166 }
1167 } break;
1168 case DATA_SC_POWER: {
1169 switch (m_choiceTextUnit->GetSelection()) {
1170 case 0: {
1171 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1172 } break;
1173 case 1: {
1174 m_text->SetUnit(ElectricalUnit::UNIT_VA);
1175 } break;
1176 case 2: {
1177 m_text->SetUnit(ElectricalUnit::UNIT_kVA);
1178 } break;
1179 case 3: {
1180 m_text->SetUnit(ElectricalUnit::UNIT_MVA);
1181 } break;
1182 default:
1183 break;
1184 }
1185 } break;
1186 case DATA_ACTIVE_POWER:
1187 case DATA_PF_ACTIVE:
1188 case DATA_PF_LOSSES: {
1189 switch (m_choiceTextUnit->GetSelection()) {
1190 case 0: {
1191 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1192 } break;
1193 case 1: {
1194 m_text->SetUnit(ElectricalUnit::UNIT_W);
1195 } break;
1196 case 2: {
1197 m_text->SetUnit(ElectricalUnit::UNIT_kW);
1198 } break;
1199 case 3: {
1200 m_text->SetUnit(ElectricalUnit::UNIT_MW);
1201 } break;
1202 default:
1203 break;
1204 }
1205 } break;
1206 case DATA_REACTIVE_POWER:
1207 case DATA_PF_REACTIVE: {
1208 switch (m_choiceTextUnit->GetSelection()) {
1209 case 0: {
1210 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1211 } break;
1212 case 1: {
1213 m_text->SetUnit(ElectricalUnit::UNIT_var);
1214 } break;
1215 case 2: {
1216 m_text->SetUnit(ElectricalUnit::UNIT_kvar);
1217 } break;
1218 case 3: {
1219 m_text->SetUnit(ElectricalUnit::UNIT_Mvar);
1220 } break;
1221 default:
1222 break;
1223 }
1224 } break;
1225 case DATA_TRANSFORMER_TAP: {
1226 switch (m_choiceTextUnit->GetSelection()) {
1227 case 0: {
1228 m_text->SetUnit(ElectricalUnit::UNIT_PU);
1229 } break;
1230 case 1: {
1231 m_text->SetUnit(ElectricalUnit::UNIT_NONE);
1232 } break;
1233 default:
1234 break;
1235 }
1236 } break;
1237 default:
1238 break;
1239 }
1240}

◆ ValidateData()

bool TextForm::ValidateData ( )
virtual

Definition at line 1252 of file TextForm.cpp.

1253{
1254 if (m_choiceElement->GetSelection() == -1) return false;
1255 if (m_choiceName->GetSelection() == -1) return false;
1256 if (m_choiceTextType->GetSelection() == -1) return false;
1257 if (m_text->GetDataType() != DATA_NAME && m_text->GetDataType() != DATA_PQ_THD &&
1258 m_choiceTextUnit->GetSelection() == -1)
1259 return false;
1260 if (m_text->GetElementTypeText() == TYPE_LINE || m_text->GetElementTypeText() == TYPE_TRANSFORMER) {
1261 if (m_text->GetDataType() != DATA_PF_LOSSES && m_text->GetDataType() != DATA_NAME && m_text->GetDataType() != DATA_TRANSFORMER_TAP) {
1262 if (m_choiceTextFromBus->GetSelection() == -1) return false;
1263 if (m_choiceTextToBus->GetSelection() == -1) return false;
1264 }
1265 }
1266
1267 if (m_choiceTextFromBus->IsEnabled() && m_choiceTextToBus->IsEnabled())
1268 m_text->SetDirection(m_choiceTextFromBus->GetSelection());
1269 double decimalPlaces = m_text->GetDecimalPlaces();
1270 if (m_textCtrlDecimal->GetValue().ToDouble(&decimalPlaces)) m_text->SetDecimalPlaces(decimalPlaces);
1271
1272 m_textToEdit->SetElementTypeText(m_text->GetElementTypeText());
1273 m_textToEdit->SetElementNumber(m_text->GetElementNumber());
1274 m_textToEdit->SetElement(m_text->GetElement());
1275 m_textToEdit->SetDataType(m_text->GetDataType());
1276 m_textToEdit->SetDirection(m_text->GetDirection());
1277 m_textToEdit->SetUnit(m_text->GetUnit());
1278 m_textToEdit->SetDecimalPlaces(decimalPlaces);
1279 m_textToEdit->UpdateText(m_systemPowerBase);
1280
1281 return true;
1282}

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: