File: WORKFLOW\TSteering.cpp
1 //#############################################################################
2 // TSteering
3 //#############################################################################
4
5 #include "internls\evrythng.h" // GermanVersion
6 #include "winresrc\rc_def.h" // Ressourcen-IDs
7 //#pragma hdrstop
8
9 //#include "datavisa\datavisa.h"
10 #include "motrstrg\motrstrg.h"
11 //#include "difrkmty\difrkmty.h"
12
13 #include "workflow\workflow.h"
14 #include "workflow\m_steerg.h"
15
16 //#include "workflow\TCmd.h"
17 //#include "workflow\TChooseAxisCmd.h"
18
19 // Modul-Instance
20 TSteering Steering; //Datum: 28.07.2002 = TSteering()
21
22
23 //#############################################################################
24 // globale Methode aus L_LAYER.CPP
25 //#############################################################################
26
27 // Prototypen
28 ExScanType ParsingXScanType ( LPSTR xst )
29 {
30 if ( !strcmp( xst, "Standard" ) )
31 return stStandardScan;
32 if ( !strcmp( xst, "Omega2Theta" ) )
33 return stOmega2ThetaScan;
34 if ( !strcmp( xst, "Continuous" ) )
35 return stContinuousScan;
36 if ( !strcmp( xst, "PsdEnergyScan" ) )
37 return stPsdEnergyScan;
38 if ( !strcmp( xst, "PsdPositionScan" ) )
39 return stPsdPositionScan;
40 if ( !strcmp( xst, "Omega2ThetaList" ) )
41 return stOmega2ThetaScanList;
42 if ( !strcmp( xst, "ScanList" ) )
43 return stScanList;
44 return stUnknown;
45 };
46
47 //*****************************************************************************
48 // KONSTRUKTOR-DESTRUKTOR
49 //*****************************************************************************
50
51
52 TSteering::TSteering ( void )
53 {
54 // Fuer Liste der aufrufenden Macros
55 TheMacro= 0;
56 TheCmd= 0;
57 nCmdIdx= -1;
58 nMacroNumber= 0;
59 bSendReport= FALSE;
60 hReportList= NULL;
61 fNoiseLevel= 300;
62 bSteeringActive= FALSE;
63 //! neu Kullmann+Reinecker
64 bReset= FALSE;
65 bInterrupted= FALSE;
66 dPeakPoint= 0;
67 dStartPoint= 0;
68 for (int i= 0; i < nMaxArg; i++)
69 dCalcArg[i]= 0;
70 fHWB= 0;
71 dCalcResult= 0;
72 dGoalDistance= 0;
73 fIncomingIntensity= 0;
74 fPeakIntensity= 0;
75 fGoalIntensity= 0;
76 nEvent= 0; //Timer ist inaktiv
77 hHostWindow= 0;
78 Monitor= 0;
79 //Datum: 28.07.2002 bTimerActive = FALSE;
80 };
81
82 // Testgruppe 21.10.2002
83 TSteering::~TSteering( void )
84 {
85 Reset();
86 _FREEOBJ(TheCmd);
87 _FREEOBJ(TheMacro);
88 }
89
90 //*****************************************************************************
91 // Makros aus Dateien laden
92 //*****************************************************************************
93
94 //##laedt Standardmakros ("STANDARD.MAK")
95 BOOL TSteering::Initialize ( const HWND hwnd, const int mid, TDetector *sensor )
96 {
97 Visualising( FALSE, FALSE );
98 StartUp(hwnd, mid, sensor);
99 // ! neu Kullmann+Reinecker: LoadMacro ermittelt jetzt selbststaendig den vollständigen Path
100 if ( !LoadMacro("InquireHwb", "standard.mak") )
101 return FALSE;
102 if ( !LoadMacro("SearchReflection", "standard.mak") )
103 return FALSE;
104 if ( !LoadMacro("SetupTopography", "standard.mak") )
105 return FALSE;
106 if ( !LoadMacro("Test", "standard.mak") )
107 return FALSE;
108 if ( !LoadMacro("AzimutalJustify", "standard.mak") )
109 return FALSE;
110 return TRUE;
111 };
112 //-----------------------------------------------------------------------------
113
114 // lädt Makros aus "SCAN.MAK"
115 BOOL TSteering::LoadMacroByUser ( void )
116 {
117 // ! neu Kullmann+Reinecker: LoadMacro ermittelt jetzt selbststaendig den Path
118 if ( !LoadMacro( "ScanJob", "scan.mak" ) )
119 return FALSE;
120 if ( !LoadMacro( "AreaScanJob", "scan.mak" ) )
121 return FALSE;
122 return TRUE;
123 };
124
125 //*****************************************************************************
126 // Kommando-/ Makroverarbeitung vorbereiten
127 //*****************************************************************************
128
129 //##Setzt das Bezugsfenster, aktiviert Motorachse mid, setzt Zaehler auf
130 //##sensid
131 BOOL TSteering::StartUp ( const HWND hwnd, const int mid, TDetector *sensor )
132 {
133 hControlWnd= hwnd;
134 mlSetAxis(mid);
135 Detector= sensor;
136 return TRUE;
137 };
138 //-----------------------------------------------------------------------------
139
140 //## setzt einige Werte, die sich auf spaeter Reportausgaben beziehen
141 void TSteering::Visualising ( BOOL a, BOOL f )
142 {
143 bSendReport= a;
144
145 //##die naechsten vier Variablen werden hier zwar mit Werten belegt, aber
146 //##im weiteren Programmverlauf nicht verwendet
147 //Datum: 28.07.2002 b_id_Angle = b;
148 //Datum: 28.07.2002 b_id_PeakIntensity = c;
149 //Datum: 28.07.2002 b_id_Intensity = d;
150 //Datum: 28.07.2002 b_id_HalfWidth = e;
151 //##b_id_Report wird nur fuer nachfolgende Zuweisung von hReportList
152 //##verwendet
153 //Datum: 28.07.2002 b_id_Report = f;
154 hReportList= (f) ? GetDlgItem(hControlWnd, id_Report) : NULL;
155 };
156
157 //*****************************************************************************
158 // Kommando-/ Makroverarbeitung starten
159 //*****************************************************************************
160
161 BOOL TSteering::StartMacroExecution ( TMacroTag *Macro, HWND host )
162 {
163 // Function tested; Last changes 950814
164 if ( !Macro )
165 return FALSE; //! Absturzursache beseitigt
166
167 if ( !Macro->bIsReady && !bInterrupted )
168 {
169 MessageBox(GetFocus(), "Das laufende Macro erst unterbrechen !", "Meldung", MBINFO);
170 return FALSE;
171 }
172
173 Detector->MeasureStop();
174 Detector->SetControlWnd(hControlWnd);
175 hHostWindow= host;
176 TheMacro= Macro;
177 if ( (TheMacro) && (TheMacro->Id == InquireHwb) )
178 fHWB= 0; // !neu Kullmann+Reinecker, Halbwertsbreite in diesem Makro NOCH nicht berechnet
179 nCmdIdx= 0;
180 TheCmdList= Macro->CmdList;
181 StartCmdExecution(TheCmdList[nCmdIdx]);
182 return TRUE;
183 };
184 //-----------------------------------------------------------------------------
185
186 //##setzt die uebergebenen Parameter in die Kommandostruktur ein und
187 //##ruft TSteering::StartCmdExecution mit dieser Kommandostruktur auf
188 int TSteering::StartCmdExecution ( ECmdId cmdid, int p1, int p2, LPSTR p3, HWND host )
189 {
190 TCmdTag ct;
191
192 hHostWindow= host;
193 ct.Id= cmdid;
194 ct.P1= (ECmdParam)p1;
195 ct.P2= (ECmdParam)p2;
196 strcpy(ct.P3, p3);
197 return StartCmdExecution(ct);
198 }
199
200 //*****************************************************************************
201 // Kommando-/ Makroverarbeitung pausieren/ fortsetzen, stoppen
202 //*****************************************************************************
203
204 // Makroverarbeitung abbrechen, kann nicht mehr fortgesetzt werden
205 BOOL TSteering::Reset ( BOOL aDoNotify )
206 {
207 if (Detector)
208 Detector->MeasureStop(); //! neu Kullmann+Reinecker: Absturzursache beseitigt
209 StopTimer();
210 if ( hHostWindow && aDoNotify )
211 SendMessage(hHostWindow, WM_COMMAND, cm_SteeringReset, 0l);
212 _FREEOBJ(TheCmd);
213 TheMacro= 0; // delete von TheMacro führt zur Schutzverletzung
214 nCmdIdx= -1;
215 bSteeringActive= FALSE;
216 bInterrupted= FALSE;
217 bReset= TRUE;
218 return TRUE;
219 };
220 //-----------------------------------------------------------------------------
221
222 BOOL TSteering::ToggleInterrupt ( void )
223 {
224 static int nOldMotor; //! FIX Fehler 79
225 // Function tested; Last changes 950814
226 if (bInterrupted)
227 { // restart the action
228 //! FIX Fehler 72 Diff/Refl
229 if ( TheCmd ) TheCmd->bRestart= TRUE;
230 bInterrupted= FALSE;
231 Detector->MeasureStop();
232 Detector->SetControlWnd( hControlWnd );
233 // Meßeinstellungen erneut laden
234 Detector->SetExposureSettings( exposure );
235 //! FIX Fehler 72 Diff/Refl
236 if ( TheCmd ) switch (TheCmd->GetId())
237 {
238 case Scan:
239 case AreaScan:
240 mlSetAxis(nMotor= nOldMotor); //! FIX Fehler 79
241 DetectorRequest();
242 break;
243
244 default:
245 Detector->MeasureStart();
246 };
247 bSteeringActive= TRUE;
248
249 // interrupt the action
250 }
251 else
252 { // bInterrupted==FALSE
253 nOldMotor= mlGetAxis(); //! FIX Fehler 79
254 Detector->MeasureStop();
255 StopTimer();
256 Detector->SetControlWnd(NULL);
257 bSteeringActive= FALSE;
258 exposure= Detector->GetExposureSettings();
259 Detector->PopSettings();
260 Detector->MeasureStart();
261 bInterrupted= TRUE;
262 }
263 bReset= FALSE;
264 return bInterrupted;
265 };
266
267 //*****************************************************************************
268 // Schnittstelle zu anderen Subsystemen
269 //*****************************************************************************
270
271 //##fragt den aktuellen Intensitaetswert ab; je nach Kommandozustand
272 //##unterschiedliche Akionen
273 BOOL TSteering::DetectorRequest ( void )
274 {
275 // Function tested; Last changes 950814
276 //##aktuellen Intensitaetswert abfragen
277 Detector->GetIntegral(fIncomingIntensity);
278 if (fIntensityNorm != 0.0)
279 fIncomingIntensity /= fIntensityNorm;
280
281 //##naechsten Schritt des aktuellen Kommandos auswaehlen
282 switch (TheCmd->DoAction())
283 {
284 case CMeasure:
285 //if (bSendReport) SetStatus("Measure");
286 Detector->MeasureStart();
287 if ( Steering.Monitor )
288 Steering.Monitor->MeasureStart();
289 break;
290
291 case CRecall:
292 // if (bSendReport) SetStatus("Recall");
293 StartTimer();
294 break;
295
296 case CReady:
297 ReadyReaction();
298 break;
299 }
300 return TRUE;
301 };
302 //-----------------------------------------------------------------------------
303
304 void TSteering::WakeUp ( void )
305 {
306 // Function tested; Last changes 950814
307 if ( TheCmd->IsReady() )
308 {
309 ReadyReaction();
310 return;
311 }
312 switch ( TheCmd->WakeUp() )
313 {
314 case CMeasure:
315 if (TheCmd->GetShowData(MessageBuffer))
316 SendReport();
317 // if ( bSendReport ) SetStatus("Measure");
318 Detector->MeasureStart();
319 if ( Steering.Monitor )
320 Steering.Monitor->MeasureStart();
321 break;
322
323 case CRecall:
324 //if ( bSendReport ) SetStatus("Recall");
325 StartTimer();
326 break;
327
328 case CReady:
329 ReadyReaction();
330 break;
331 }
332 return;
333 };
334
335 //*****************************************************************************
336 // Makroliste bearbeiten: Makros auslesen, löschen und Makroanzahl ermitteln
337 //*****************************************************************************
338
339 TMacroTag *TSteering::GetMacroById ( EMacroId MacId )
340 {
341 // Function tested; Last changes 950811
342 for (int idx= 0; idx < nMacroNumber; idx++)
343 if ( MacId == aMacroList[idx].Id )
344 {
345 if ( aMacroList[idx].bIsReady )
346 return &aMacroList[idx];
347 else
348 return NULL;
349 }
350 return NULL;
351 };
352 //-----------------------------------------------------------------------------
353
354 TMacroTag *TSteering::GetMacroByNumber ( int num )
355 {
356 // Function tested; Last changes 950813
357 if (num < 0)
358 return NULL;
359 if (num >= nMacroNumber)
360 return NULL; //Datum: 28.07.2002 neu Kullmann+Reinecker
361 if ( !aMacroList[num].bIsReady )
362 return NULL;
363 return &aMacroList[num];
364 }
365 //-----------------------------------------------------------------------------
366
367 TMacroTag *TSteering::GetMacroByName ( LPSTR name )
368 {
369 // Function tested; Last changes 950811
370 for (int idx= 0; idx < nMacroNumber; idx++)
371 if ( !strcmp(name, aMacroList[idx].Name) )
372 {
373 if ( aMacroList[idx].bIsReady )
374 return &aMacroList[idx];
375 else
376 return NULL;
377 }
378 return NULL;
379 };
380 //-----------------------------------------------------------------------------
381
382 BOOL TSteering::DeleteMacro ( TMacroTag *macro )
383 {
384 if ( !macro )
385 return FALSE;
386
387 //24.07.2002
388 // ! Kullmann+Reinecker: (idx<nMacroNumber) sonst lesen wir über das Listenende hinweg, wenn das Makro nicht vorhanden ist
389 int idx= 0;
390 while ( (idx < nMacroNumber) && (strcmp(aMacroList[idx].Name, macro->Name)) )
391 idx++;
392 if ( idx >= nMacroNumber )
393 return FALSE; // das gesuchte Makro ist nicht vorhanden
394
395 // zu gesuchtes Makro löschen
396 _FREEOBJ(aMacroList[idx].CmdList);
397
398 // Rest jeweils um eine Position nach vorn kopierem
399 idx++;
400 while (idx < nMacroNumber)
401 {
402 aMacroList[idx - 1]= aMacroList[idx];
403 idx++;
404 }
405
406 // Anzahl der Makros runterzählen und Speicher freigeben
407 nMacroNumber--;
408 memset(&(aMacroList[nMacroNumber]), 0, sizeof(TMacroTag));
409 return TRUE;
410 };
411 //-----------------------------------------------------------------------------
412
413 int TSteering::GetMacroCount ( void )
414 {
415 return nMacroNumber;
416 }
417
418 //*****************************************************************************
419 // POLLING zum Fortschritt der Makroverarbeitung ( ! neu Kullmann+Reinecker )
420 //*****************************************************************************
421
422 BOOL TSteering::IsActive ( void )
423 {
424 return bSteeringActive;
425 };
426 //------------------------------------------------------------------------------
427
428 BOOL TSteering::IsReset ( void )
429 {
430 return bReset;
431 }
432 //------------------------------------------------------------------------------
433
434 BOOL TSteering::GetProgress ( int &aCmdIdx, LPSTR aProgress, int &aCmdCount )
435 {
436 aCmdIdx= 0;
437 aProgress[0]= 0;
438 aCmdCount= 0;
439 if ( !IsActive() )
440 return FALSE; // derzeit wird nichts verarbeitet, d.h. Verarbeitung bereits beendet ODER es wurde noch kein Kommando verarbeitet
441
442 aCmdIdx= nCmdIdx;
443 if ( !TheMacro )
444 aCmdCount= 1; //Einzelkommandoverarbeitung
445 else
446 aCmdCount= TheMacro->Length; //Makroverarbeitung
447 if ( !TheCmd )
448 return TRUE; // Statusinformationen sind nicht verfügbar
449
450 TheCmd->GetShowData( aProgress ); //Statusinformationen ermitteln
451 if ( strlen(aProgress) == 0 )
452 {
453 TheCmd->GetName( aProgress );
454 if ( strlen(aProgress) > 0 )
455 {
456 char *buf= new char [ strlen(aProgress) + 1 ];
457 strcpy( buf, aProgress );
458 #ifdef GermanVersion
459
460 sprintf( aProgress, "\"%s\"-Kommando...", buf );
464 #endif
465
466 _FREELIST(buf);
467 }
468 }
469 return TRUE;
470 }
471
472 //*****************************************************************************
473 // Accessor-/ Mutator-Methoden (einiges neu oder vormals als inline deklariert)
474 //*****************************************************************************
475
476 BOOL TSteering::IsPositionValid ( void )
477 {
478 if ( TheCmd )
479 return TheCmd->IsPositionValid();
480 else
481 return FALSE;
482 };
483 //-----------------------------------------------------------------------------
484
485 double TSteering::GetDistance ( void )
486 {
487 return mGetValue(Distance);
488 };
489 //-----------------------------------------------------------------------------
490
491 double TSteering::GetStartPoint ( void )
492 {
493 return dStartPoint;
494 };
495 //-----------------------------------------------------------------------------
496 void TSteering::SetStartPoint ( double aValue)
497 {
498 dStartPoint= aValue;
499 };
500 //-----------------------------------------------------------------------------
501
502 float TSteering::GetIntensity ( void )
503 {
504 return fIncomingIntensity;
505 };
506 //-----------------------------------------------------------------------------
507
508 float TSteering::GetSigma ( void )
509 {
510 return Detector->GetSigma();
511 };
512 //-----------------------------------------------------------------------------
513
514 float TSteering::GetNoiseLevel ( void )
515 {
516 return fNoiseLevel;
517 };
518 //-----------------------------------------------------------------------------
519
520 void TSteering::SetNoiseLevel ( float nl )
521 {
522 fNoiseLevel= nl;
523 };
524 //-----------------------------------------------------------------------------
525
526 float TSteering::GetNorm ( void )
527 {
528 return fIntensityNorm;
529 };
530 //-----------------------------------------------------------------------------
531
532 void TSteering::SetNorm ( float norm )
533 {
534 fIntensityNorm= norm;
535 };
536 //-----------------------------------------------------------------------------
537
538 BOOL TSteering::IsResponding ( void )
539 {
540 return bSendReport;
541 };
542 //-----------------------------------------------------------------------------
543
544 void TSteering::SetResponse ( BOOL sr )
545 {
546 bSendReport= sr;
547 }
548 //------------------------------------------------------------------------------
549
550 double TSteering::GetHwb ( void )
551 {
552 return fHWB;
553 }
554 //------------------------------------------------------------------------------
555
556 void TSteering::SetHwb ( double aHwb )
557 {
558 fHWB= aHwb;
559 }
560
561 //*****************************************************************************
562 // PRIVATE METHODS
563 //*****************************************************************************
564
565 BOOL TSteering::LoadMacro (LPSTR makname, LPSTR fn )
566 {
567 TTxtRead file( GetMacroFile(fn) ); // ! neu Kullmann+Reinecker
568 char *line;
569 while ( (line= file.NextLine()) != 0 )
570 { // suche den Anfang des nächsten Makros
571 if ( !strstr(line, "[Common]") )
572 continue; // bis zum nächsten "Common", überlesen wir alle Zeilen
573
574 //*** [Common]
575 while ( (line= file.NextLine()) != 0 )
576 { // "[Common] über- und Makro einlesen
577 if ( (strlen(line) == 0) || (line[0] == '#') )
578 continue; // Leer- und Kommentarzeilen überlesen
579
580 char *token= strtok( line, " =\r\n\t" );
581 //*** Name=<Makroname>
582 if ( !strcmp(token, "Name") )
583 {
584 token= strtok(NULL, " =\r\n\t");
585 if ( strcmp(makname, token) )
586 break; // es ist nicht das gesuchte Makro, also zurück zu "bis das nächste Makro beginnt, überlesen wir alle Zeilen"
587
588 ParsingMacroId(aMacroList[nMacroNumber], token);
589 strcpy(aMacroList[nMacroNumber].FileName, fn);
590 continue;
591 }
592 //*** Length=<Anzahl der Kommandos>
593 if ( !strcmp(token, "Length") )
594 {
595 token= strtok(NULL, " =\r\n\t");
596 aMacroList[nMacroNumber].Length= atoi(token);
597 continue;
598 }
599 //*** [Commands]
600 if ( !strcmp(token, "[Commands]") )
601 { //in den nächsten Zeilen folgen bis zu <Anzahl der Kommandos> Kommandos
602 aMacroList[nMacroNumber].CmdList= new TCmdTag[aMacroList[nMacroNumber].Length];
603 int cnt= 0;
604 while ( (line= file.NextLine()) != 0 )
605 { // [Commandos] über- und Kommandos (samt -parametern) lesen
606 if ( (strlen(line) == 0) || (line[0] == '#') )
607 continue; // Leer- und Kommentarzeilen überlesen
608
609 if ( (strstr(line, "[End]")) || (cnt > aMacroList[nMacroNumber].Length) )
610 break; // Ende der Kommandoliste ODER Maximalanzahl erreicht: Rest ignorieren
611
612 // das nächste Makro beginnt, ohne das dieses Makro beendet wird (d.h. [End]): Fehlerstabilisierung
613 if ( strstr(line, "[Common]") )
614 {
615 MessageBox( GetFocus(), "Kommandoliste unvollstaendig!", makname, MBSTOP );
616 return FALSE;
617 }
618 // Kommandoparameter
619 LPSTR cmd= strtok(line, " \r\n\t");
620 LPSTR p1= strtok(NULL, " \r\n\t");
621 LPSTR p2= strtok(NULL, " \r\n\t");
622 LPSTR p3= strtok(NULL, "\r\n\t");
623 if ( ParsingCmd(aMacroList[nMacroNumber].CmdList[cnt], cmd, p1, p2, p3) )
624 cnt++; // FALSE: dieses Kommando mit dem nächsten Kommando (ggf. Stop) überschrieben
625 if (cnt == aMacroList[nMacroNumber].Length)
626 break; // maximale Kommandoanzahl erreicht: nicht weiterlesen
627 } // Kommandos (samt -parametern) einlesen
628
629 // wenn kein fehlerfreies Kommando gefunden wurde
630 if ( cnt == 0 )
631 {
632 MessageBox( GetFocus(), "Makro ohne Kommandos!", makname, MBSTOP );
633 return FALSE;
634 }
635 aMacroList[nMacroNumber].Length= cnt; //so viele fehlerfreie Kommandos haben wirklich gelesem
636 aMacroList[nMacroNumber].CmdList[cnt - 1].Id= Stop; // das letzte Kommando muss "Stop" sein: Ist dies nicht der Fall wird das letzte Kommando überschrieben
637 aMacroList[nMacroNumber].bIsReady= TRUE;
638 nMacroNumber++;
639
640 // durchsuche die Liste ob das Makro schon existiert; ist der der Fall wird das alte gelöscht
641 int idx= nMacroNumber - 1;
642 while ( idx > 0 )
643 {
644 idx--; // wir überspringen das soebene eingelesene (letzte) Makro, sonst ist die Dopplung vorprogrammiert
645 if ( !strcmp(aMacroList[nMacroNumber - 1].Name, aMacroList[idx].Name) )
646 { // das soeben gelesene Makro existsiert schon: wir löschen das alte Makro
647 DeleteMacro( &aMacroList[idx] ); // ! neu Kullmann+Reiecker: wir verwenden lieber DeleteMacro()
648 return TRUE; // das gesuchte Makro wurde erfolgreich einlesen; Dopplung zuvor entfernt
649 }
650 }
651 return TRUE; // das gesuchte Makro wurde erfolgreich einlesen
652 } // if "[Commands]"
653 } // while "Makro einlesen"
654 } // while "suche den Anfang des nächsten Makros"
655
656 // Makrodatei oder gesuchtes Makro nicht vorhanden
657 if ( !file.Exists() )
658 MessageBox( GetFocus(), "Makrodatei fehlt!", fn, MBSTOP ); //! Makrodatei ist nicht in dem Verzeichnis aus dem die EXE gestartet wurde
659 else
660 MessageBox( GetFocus(), "Makro fehlt!", makname, MBSTOP );
661 return FALSE;
662 };
663 //-----------------------------------------------------------------------------
664
665 //##ein Kommando ausfuehren: legt Objekt an, das diesem Kommando entspricht
666 int TSteering::StartCmdExecution ( TCmdTag Cmd )
667 {
668 // Function tested; Last changes 950814
669 //##das evtl. gerade ausgefuehrte Kommando stoppen, Werte auf Initial-
670 //##zustand zuruecksetzen, neues aktives Kommando erzeugen
671 _FREEOBJ(TheCmd);
672 Detector->MeasureStop();
673 Detector->SetControlWnd(hControlWnd);
674 fIntensityNorm= 0.0;
675 //Datum: 28.07.2002 nFailureId = 0;
676 bInterrupted= FALSE;
677 bReset= FALSE;
678 //##dem Kommando entsprechendes Objekt anlegen
679 switch (Cmd.Id)
680 {
681 case GotoPeak:
682 TheCmd= (TGotoPeakCmd*)new TGotoPeakCmd(Cmd);
683 break;
684
685 case GotoIntensity:
686 TheCmd= (TGotoIntensityCmd*)new TGotoIntensityCmd(Cmd);
687 break;
688
689 case ChooseAxis:
690 TheCmd= (TChooseAxisCmd*)new TChooseAxisCmd(Cmd);
691 break;
692
693 case ChooseDetector:
694 TheCmd= (TChooseDetectorCmd*)new TChooseDetectorCmd(Cmd);
695 break;
696
697 case SetupScan:
698 TheCmd= (TSetupScanCmd*)new TSetupScanCmd(Cmd);
699 break;
700
701 case SetWidth:
702 TheCmd= (TSetWidthCmd*)new TSetWidthCmd(Cmd);
703 break;
704
705 case Scan:
706 TheCmd= (TScanCmd*)new TScanCmd(Cmd);
707 break;
708
709 case ControlFlank: //## Nachregeln der Topographie
710 TheCmd= (TControlFlankCmd*)new TControlFlankCmd(Cmd);
711 break;
712
713 case ShowValue:
714 TheCmd= (TShowValueCmd*)new TShowValueCmd(Cmd);
715 break;
716
717 case SetFileName:
718 TheCmd= (TSetFileNameCmd*)new TSetFileNameCmd(Cmd);
719 break;
720
721 case SaveData:
722 TheCmd= (TSaveDataCmd*)new TSaveDataCmd(Cmd);
723 break;
724
725 case Calculate:
726 TheCmd= (TCalculateCmd*)new TCalculateCmd(Cmd);
727 break;
728
729 case LoadPoint:
730 TheCmd= (TLoadPointCmd*)new TLoadPointCmd(Cmd);
731 break;
732
733 case MoveToPoint:
734 TheCmd= (TMoveToPointCmd*)new TMoveToPointCmd(Cmd);
735 break;
736
737 case AreaScan:
738 TheCmd= (TAreaScanCmd*)new TAreaScanCmd(Cmd);
739 break;
740
741 default:
742 return FALSE;
743 }
744
745 if ( !TheCmd->nFailureId )
746 { // das gestartete Kommando hat einen Fehlercode zurückgegeben
747 bSteeringActive= TRUE;
748 StartTimer();
749 return TRUE;
750 }
751 return FALSE;
752 };
753 //-----------------------------------------------------------------------------
754
755 BOOL TSteering::ReadyReaction ( void )
756 {
757 // Function tested; Last changes 950814
758 if (TheCmd->GetShowData(MessageBuffer))
759 SendReport();
760 if (TheMacro)
761 ExecuteNextCmd();
762 else
763 NotifyCmdReady();
764 return TRUE;
765 };
766 //-----------------------------------------------------------------------------
767
768 BOOL TSteering::ExecuteNextCmd ( void )
769 {
770 if ( TheCmd->nFailureId )
771 {
772 MessageBox(GetFocus(), "Makroausführung ist fehlgeschlagen !", "Steuerung", MBSTOP);
773 _FREEOBJ(TheCmd);
774 return FALSE;
775 }
776 _FREEOBJ(TheCmd);
777 // Function tested; Last changes 950814
778 if ( TheCmdList[nCmdIdx].Id == Inquire )
779 nCmdIdx += (bInquireResult) ? 2 : 1;
780 else
781 nCmdIdx++;
782 switch (TheCmdList[nCmdIdx].Id)
783 {
784 case Stop:
785 // Kontrolle an Steuerfenster übergeben
786 NotifyMacroReady();
787 return FALSE;
788
789 case GotoLine:
790 nCmdIdx= TheCmdList[nCmdIdx].P1;
791 if ( (TheCmdList[nCmdIdx].Id == Stop) || (nCmdIdx > TheMacro->Length - 1) )
792 {
793 NotifyMacroReady();
794 return FALSE;
795 }
796 return TRUE;
797
798 default:
799 StartCmdExecution(TheCmdList[nCmdIdx]);
800 return TRUE;
801 }
802 };
803 //-----------------------------------------------------------------------------
804
805 void TSteering::NotifyCmdReady ( void )
806 {
807 // Laeuft ein Macro, dann naechsten Befehl laden
808 bSteeringActive= FALSE;
809 Detector->MeasureStop();
810 Detector->SetControlWnd(NULL);
811 Detector->PopSettings();
812 Detector->MeasureStart();
813 if ( hHostWindow )
814 PostMessage(hHostWindow, WM_COMMAND, cm_SteeringReady, 0l);
815 hHostWindow= 0;
816 };
817 //-----------------------------------------------------------------------------
818
819 void TSteering::NotifyMacroReady ( void )
820 {
821 bSteeringActive= FALSE;
822 Detector->MeasureStop();
823 Detector->SetControlWnd(NULL);
824 Detector->PopSettings();
825 Detector->MeasureStart();
826 if ( hHostWindow )
827 PostMessage(hHostWindow, WM_COMMAND, cm_SteeringReady, 0l);
828 hHostWindow= 0;
829 TheMacro= NULL; // ! neu Kullmann+Reinecker: Bei der nächsten Kommandoverarbeitung wissen wir, ob es ein Makro ( !TheMacro ) verarbeitet wird ODER nur ein Einzelkommendo ( SONST ).
830 };
831 //-----------------------------------------------------------------------------
832
833 // Callback Timer starten
834
835 BOOL TSteering::StartTimer ( void )
836 {
837 if ( Steering.nEvent != 0 )
838 return FALSE; // bereits aktiv
839
840 //Datum: 28.07.2002 if (restart) nAskIdx--;
841 //Datum: 28.07.2002 else nAskIdx= nMaxAskNumber;
842 Steering.nEvent= timeSetEvent( nAskTicks, 3, (LPTIMECALLBACK) & TSteering::RecallSteering, 0, TIME_ONESHOT );
843 return ( Steering.nEvent != 0 );
844 };
845 //-----------------------------------------------------------------------------
846
847 //##falls Timer Callback aktiv, diesen stoppen
848 void TSteering::StopTimer ( void )
849 {
850 // Function tested; Last changes 960322
851 if ( Steering.nEvent == 0 )
852 return; //bereits gestoppt
853
854 timeKillEvent( Steering.nEvent );
855 Steering.nEvent= 0;
856 return;
857 };
858 //-----------------------------------------------------------------------------
859
860 void CALLBACK TSteering::RecallSteering ( UINT, UINT, DWORD, DWORD, DWORD )
861 {
862 // Function tested; Last changes 950814
863 //Datum: 28.07.2002 Steering.bTimerActive= FALSE;
864 Steering.nEvent= 0;
865 PostMessage( GetFrameHandle(), GetWakeUpMsg(), 0, 0l);
866 // Steering.WakeUp();
867 };
868
869 //-----------------------------------------------------------------------------
870
871 void TSteering::SendReport ( void )
872 {
873 if ( !bSendReport )
874 return;
875 if ( !strlen(MessageBuffer) )
876 return;
877 if ( hReportList )
878 ListBox_AddString( hReportList, MessageBuffer );
879 else
880 SetInfo( MessageBuffer );
881 };
882
883 //-----------------------------------------------------------------------------
884 BOOL TSteering::ParsingMacroId (TMacroTag& macro, LPSTR name )
885 {
886 // Makro: SEARCHREFLECTION
887 if ( !strcmp(name, "SearchReflection") )
888 {
889 macro.Id= SearchReflection;
890 strcpy(macro.Name, name);
891
892 // Makro: INQUIREHWB
893 }
894 else if ( !strcmp(name, "InquireHwb") )
895 {
896 macro.Id= InquireHwb;
897 strcpy(macro.Name, name);
898
899 //Datum: 28.07.2002
900 /*// Makro: BATCHMACRO
901 } else if ( !strcmp(name,"BatchMacro") ) {
902 macro.Id= BatchMacro;
903 strcpy(macro.Name, name);*/
904
905 // Makro: SCANJOB
906 }
907 else if ( !strcmp(name, "ScanJob") )
908 {
909 macro.Id= ScanJob;
910 strcpy(macro.Name, name);
911
912 // Makro: AREASSCANJOB
913 }
914 else if ( !strcmp(name, "AreaScanJob") )
915 {
916 macro.Id= AreaScanJob;
917 strcpy(macro.Name, name);
918
919 //Datum: 28.07.2002
920 /*// Makro: MIDDLEOFVALLEY
921 } else if ( !strcmp(name,"MiddleOfValley") ) {
922 macro.Id= MiddleOfValley;
923 strcpy(macro.Name, name);*/
924
925 // Makro:AZIMUTALJUSTIFY
926 }
927 else if ( !strcmp(name, "AzimutalJustify") )
928 {
929 macro.Id= AzimutalJustify;
930 strcpy(macro.Name, name);
931
932 // Makro: SETUPTOPOGRAPHY
933 }
934 else if ( !strcmp(name, "SetupTopography") )
935 {
936 macro.Id= SetupTopography;
937 strcpy(macro.Name, name);
938
939 // Makro: TEST
940 }
941 else if ( !strcmp(name, "Test") )
942 {
943 macro.Id= Test;
944 strcpy(macro.Name, name);
945
946 // UNBEKANNTES MAKRO
947 }
948 else
949 {
950 macro.Id= (EMacroId)nMacroNumber;
951 sprintf(macro.Name, "Macro%d", nMacroNumber);
952 SetInfo("No Match for this Macro-Name.");
953 return FALSE;
954 }
955
956 // ParsingMacroId darf nur für noch nicht vorhandene Makros benutzt werden, sonst wird eine Fehlermeldung ausgegeben
957 for (int idx= 0;idx < nMacroNumber; idx++)
958 if (macro.Id == aMacroList[idx].Id)
959 {
960 SetInfo("Macro is already loaded.");
961 return FALSE;
962 }
963 return TRUE;
964 };
965 //-----------------------------------------------------------------------------
966
967 BOOL TSteering::ParsingCmd ( TCmdTag& cmd, LPSTR pcmd, LPSTR p1, LPSTR p2, LPSTR p3 )
968 {
969 int nFailure= 0; //bislang kein Fehler
970 char buf[MaxString];
971
972 if ( !strcmp(pcmd, "GotoPeak") )// Kommando: GOTOPEAK
973 {
974 cmd.Id= GotoPeak;
975 cmd.P1= ParsingCmdParam(p1);
976 }
977 else if ( !strcmp(pcmd, "SaveData") )// Kommando: SAVEDATA
978 {
979 cmd.Id= SaveData;
980 cmd.P1= ParsingCmdParam(p1);
981 switch (cmd.P1)
982 {
983 case 0:
984 nFailure= 5;
985 break;
986
987 case ForScan:
988 case ForAreaScan:
989 break;
990
991 default:
992 nFailure= 2;
993 }
994 }
995 else if ( !strcmp(pcmd, "SetFileName") )// Kommando: SETFILENAME
996 {
997 cmd.Id= SetFileName;
998 cmd.P1= ParsingCmdParam(p1);
999 switch (cmd.P1)
1000 {
1001 case 0:
1002 nFailure= 5;
1003 break;
1004
1005 case ForScan:
1006 case ForAreaScan:
1007 strcpy(cmd.P3, strtok(p2, " "));
1008 break;
1009
1010 default:
1011 nFailure= 2;
1012 }
1013
1014 //Datum: 28.07.2002
1015 /*} else if ( !strcmp(pcmd,"SetupAreaScan") ) {// Kommando: SETUPAREASCAN
1016 cmd.Id= SetupAreaScan;
1017 cmd.P1= (ECmdParam)ParsingXScanType(p1);
1018 switch (cmd.P1) {
1019 case 0:
1020 nFailure= 5;
1021 break;
1022
1023 case StandardScan:
1024 case Omega2ThetaScan:
1025 sprintf(cmd.P3,"%s ",p2);
1026 strcat(cmd.P3,p3);
1027 break;
1028
1029 default:
1030 nFailure= 2;
1031 }*/
1032 }
1033 else if ( !strcmp(pcmd, "SetupScan") )// Kommando: SETUPSCAN
1034 {
1035 cmd.Id= SetupScan;
1036 cmd.P1= (ECmdParam)ParsingXScanType(p1);
1037 switch (cmd.P1)
1038 {
1039 case stUnknown:
1040 nFailure= 5;
1041 break;
1042
1043 case stStandardScan:
1044 case stOmega2ThetaScan:
1045 if ( !p2 && !p3 )
1046 {
1047 nFailure= 5;
1048 break;
1049 }
1050 sprintf(cmd.P3, "%s ", p2);
1051 strcat(cmd.P3, p3);
1052 break;
1053
1054 default:
1055 nFailure= 2;
1056 }
1057 }
1058 else if ( !strcmp(pcmd, "Scan") ) // Kommando: SCAN
1059 {
1060 cmd.Id= Scan;
1061 cmd.P1= ParsingCmdParam(p1);
1062 switch (cmd.P1)
1063 {
1064 case 0:
1065 nFailure= 5;
1066 break;
1067
1068 case ForScan:
1069 case ForAreaScan:
1070 cmd.P2= (ECmdParam)ParsingXScanType(p2);
1071 switch (cmd.P2)
1072 {
1073 case stUnknown:
1074 nFailure= 5;
1075 break;
1076
1077 case stOmega2ThetaScan:
1078 case stStandardScan:
1079 break;
1080
1081 default:
1082 nFailure= 2;
1083 }
1084 break;
1085
1086 default:
1087 nFailure= 2;
1088 }
1089 }
1090 else if ( !strcmp(pcmd, "AreaScan") ) // Kommando: AREASCAN
1091 {
1092 cmd.Id= AreaScan;
1093 cmd.P1= ParsingCmdParam(p1);
1094 switch (cmd.P1)
1095 {
1096 case 0:
1097 nFailure= 5;
1098 break;
1099
1100 case ForAreaScan:
1101 cmd.P2= (ECmdParam)ParsingXScanType(p2);
1102 switch (cmd.P2)
1103 {
1104 case stUnknown:
1105 nFailure= 5;
1106 break;
1107
1108 case stOmega2ThetaScan:
1109 case stStandardScan:
1110 break;
1111
1112 default:
1113 nFailure= 2;
1114 }
1115 break;
1116
1117 default:
1118 nFailure= 2;
1119 }
1120 }
1121 else if ( !strcmp(pcmd, "ShowValue") ) // Kommando: SHOWVALUE
1122 {
1123 cmd.Id= ShowValue;
1124 cmd.P1= ParsingCmdParam(p1);
1125 switch (cmd.P1)
1126 {
1127 case 0:
1128 nFailure= 5;
1129 break;
1130
1131 case Reflection:
1132 case Hwb:
1133 break;
1134
1135 default:
1136 nFailure= 2;
1137 }
1138 }
1139 else if ( !strcmp(pcmd, "LoadPoint") ) // Kommando: LOADPOINT
1140 {
1141 cmd.Id= LoadPoint;
1142 cmd.P1= ParsingCmdParam(p1);
1143 switch (cmd.P1)
1144 {
1145 case 0:
1146 nFailure= 5;
1147 break;
1148
1149 case Argument:
1150 cmd.P2= (ECmdParam)atoi(p2);
1151 if ( (cmd.P2 > nMaxArg) || (cmd.P2 < 0) )
1152 nFailure= 3;
1153 break;
1154
1155 case Start:
1156 case Peak:
1157 break;
1158
1159 default:
1160 nFailure= 2;
1161 }
1162 }
1163 else if ( !strcmp(pcmd, "SetWidth") ) // Kommando: SETWIDTH
1164 {
1165 cmd.Id= SetWidth;
1166 if ( atof(p1) != 0.0 )
1167 strcpy(cmd.P3, p1);
1168 else
1169 nFailure= 2;
1170 }
1171 else if ( !strcmp(pcmd, "MoveToPoint") ) // Kommando: MOVETOPOINT
1172 {
1173 cmd.Id= MoveToPoint;
1174 cmd.P1= ParsingCmdParam(p1);
1175 switch (cmd.P1)
1176 {
1177 case Start:
1178 case Peak:
1179 case Result:
1180 case LastGoal:
1181 break;
1182
1183 case Relative:
1184 if (atof(p2) == 0.0)
1185 nFailure= 5;
1186 else
1187 strcpy(cmd.P3, p2);
1188 break;
1189
1190 case 0:
1191 if (atof(p1) == 0.0)
1192 nFailure= 5;
1193 else
1194 strcpy(cmd.P3, p1);
1195 break;
1196
1197 default:
1198 nFailure= 2;
1199 }
1200 }
1201 else if ( !strcmp(pcmd, "Calculate") ) // Kommando: CALCULATE
1202 {
1203 cmd.Id= Calculate;
1204 cmd.P1= ParsingCmdParam(p1);
1205 switch (cmd.P1)
1206 {
1207 case Middle:
1208 case Hwb:
1209 case Difference:
1210 case Opposite:
1211 break;
1212
1213 default:
1214 nFailure= 2;
1215 }
1216 }
1217 else if ( !strcmp(pcmd, "Stop") ) // Kommando: STOP
1218 {
1219 cmd.Id= Stop;
1220 }
1221 else if ( !strcmp(pcmd, "GotoLine") ) // Kommando: GOTOLINE
1222 {
1223 cmd.Id= GotoLine;
1224 cmd.P1= (ECmdParam)atoi(p1);
1225 if ((cmd.P1 <= 0) || (cmd.P1 > aMacroList[nMacroNumber].Length))
1226 nFailure= 2;
1227 }
1228 else if ( !strcmp(pcmd, "GotoIntensity") ) // Kommando: GOTOINTENSITY
1229 {
1230 cmd.Id= GotoIntensity;
1231 cmd.P1= ParsingCmdParam(p1);
1232 switch (cmd.P1)
1233 {
1234 case SmallSide:
1235 case LargeSide:
1236 if ( atof(p2) != 0.0 )
1237 {
1238 strcpy(cmd.P3, p2);
1239 break;
1240 }
1241 cmd.P2= ParsingCmdParam(p2);
1242 switch (cmd.P2)
1243 {
1244 case Interpolation:
1245 case BackMove:
1246 if (atof(p3) == 0.0 )
1247 {
1248 nFailure= 5;
1249 break;
1250 }
1251 else
1252 strcpy(cmd.P3, strtok(p3, " "));
1253 break;
1254
1255 case 0:
1256 nFailure= 2;
1257 break;
1258
1259 default:
1260 nFailure= 4;
1261 } // switch cmd.P2
1262 break;
1263
1264 case 0:
1265 nFailure= 2;
1266 break;
1267
1268 default:
1269 nFailure= 5;
1270 }
1271 }
1272 else if ( !strcmp(pcmd, "ControlFlank") ) // Kommando: CONTROLFLANK
1273 {
1274 cmd.Id= ControlFlank;
1275 }
1276 else if ( !strcmp(pcmd, "ChooseAxis") ) // Kommando: CHOOSEAXIS
1277 {
1278 cmd.Id= ChooseAxis;
1279 cmd.P1= (ECmdParam)mlParsingAxis(p1);
1280 if (!cmd.P1)
1281 nFailure= 2;
1282 }
1283 else if ( (!strcmp(pcmd, "ChooseDetector")) || (!strcmp(pcmd, "ChooseDevice")) ) // Kommando: CHOOSEDETECTOR
1284 {
1285 cmd.Id= ChooseDetector;
1286 cmd.P1= (ECmdParam)TDetectorManager::DetectorManager().GetIdByDescription(p1);
1287 if (cmd.P1 != -1)
1288 {
1289 if (p2)
1290 {
1291 sprintf(cmd.P3, "%s ", p2);
1292 if (p3)
1293 strcat(cmd.P3, p3);
1294 }
1295 }
1296 else
1297 nFailure= 2;
1298 }
1299 else // UNBEKANNTES KOMMANDO
1300 {
1301 cmd.Id= Stop;
1302 nFailure= 1;
1303 }
1304
1305 if ( nFailure != 0 )
1306 { //Fehler-Id in Klartext umsetzen und Meldungsfenster ausgeben
1307 switch (nFailure)
1308 {
1309 case 1:
1310 sprintf(buf, "Makrobefehl >%s< wird nicht unterstützt !", pcmd);
1311 break;
1312
1313 case 2:
1314 sprintf(buf, "Paramter %s für >%s< wird nicht unterstützt !", p1, pcmd);
1315 break;
1316
1317 case 3:
1318 sprintf(buf, "Paramter %s für >%s< wird nicht unterstützt !", p2, pcmd);
1319 break;
1320
1321 case 4:
1322 sprintf(buf, "Paramter %s für >%s< wird nicht unterstützt !", p3, pcmd);
1323 break;
1324
1325 case 5:
1326 sprintf(buf, "Paramter für >%s< sind unvollständig !", pcmd);
1327 break;
1328 }
1329 MessageBox(GetFocus(), buf, "Macro einlesen", MBINFO);
1330 return FALSE;
1331 }
1332 else
1333 return TRUE; //keine Probleme :-)
1334 };
1335 //-----------------------------------------------------------------------------
1336
1337 ECmdParam TSteering::ParsingCmdParam ( LPSTR param )
1338 {
1339 if ( param == NULL )
1340 return (ECmdParam)0;
1341
1342 if ( !strcmp(param, "AbsorberUsed") )
1343 return AbsorberUsed;
1344 if ( !strcmp(param, "AreaScanResult") )
1345 return AreaScanResult;
1346 if ( !strcmp(param, "Argument") )
1347 return Argument;
1348 if ( !strcmp(param, "Array") )
1349 return Array;
1350 if ( !strcmp(param, "BackMove") )
1351 return BackMove;
1352 if ( !strcmp(param, "DecreaseWidth") )
1353 return DecreaseWidth;
1354 if ( !strcmp(param, "DynamicWidth") )
1355 return DynamicWidth;
1356 if ( !strcmp(param, "Difference") )
1357 return Difference;
1358 if ( !strcmp(param, "Equidistant") )
1359 return Equidistant;
1360
1361 if ( !strcmp(param, "ForAreaScan") )
1362 return ForAreaScan;
1363 if ( !strcmp(param, "ForScan") )
1364 return ForScan;
1365 if ( !strcmp(param, "Hwb") )
1366 return Hwb;
1367 if ( !strcmp(param, "IncreasePeak") )
1368 return IncreasePeak;
1369 if ( !strcmp(param, "Interpolation") )
1370 return Interpolation;
1371 if ( !strcmp(param, "LargeSide") )
1372 return LargeSide;
1373 if ( !strcmp(param, "LastGoal") )
1374 return LastGoal;
1375 if ( !strcmp(param, "List") )
1376 return List;
1377 if ( !strcmp(param, "Max") )
1378 return Max;
1379 if ( !strcmp(param, "MaximizeCollimator") )
1380 return MaximizeCollimator;
1381 if ( !strcmp(param, "MaximizeGradient") )
1382 return MaximizeGradient;
1383 if ( !strcmp(param, "MaximizeTilt") )
1384 return MaximizeTilt;
1385 if ( !strcmp(param, "Middle") )
1386 return Middle;
1387 if ( !strcmp(param, "Min") )
1388 return Min;
1389
1390 if ( !strcmp(param, "Opposite") )
1391 return Opposite;
1392 if ( !strcmp(param, "Peak") )
1393 return Peak;
1394 if ( !strcmp(param, "Reflection") )
1395 return Reflection;
1396 if ( !strcmp(param, "Relative") )
1397 return Relative;
1398 if ( !strcmp(param, "Result") )
1399 return Result;
1400 if ( !strcmp(param, "ScanResult") )
1401 return ScanResult;
1402 if ( !strcmp(param, "SmallSide") )
1403 return SmallSide;
1404 if ( !strcmp(param, "Standard") )
1405 return Standard;
1406 if ( !strcmp(param, "Start") )
1407 return Start;
1408 if ( !strcmp(param, "ToSmallerAngle") )
1409 return ToSmallerAngle;
1410 if ( !strcmp(param, "ToSmallerAngle") )
1411 return ToSmallerAngle;
1412
1413 return (ECmdParam)0;
1414 }
1415
1416 //*****************************************************************************
1417 // TOTER CODE
1418 //*****************************************************************************
1419
1420 //Datum: 28.07.2002
1421 /*int TSteering::CallMacro ( TMacroTag* )
1422 {
1423 /*
1424 if(pMacro == NewMacroPtr)
1425 {
1426 // Macro sollte sich nicht selbst aufrufen
1427 // nFailureId= 12;
1428 CmdExecuted();
1429 return FALSE;
1430 }
1431 // Sichern von Einstellungen, die Befehlsübergreifend sind
1432 PushParam();
1433 return StartMacroExecution(NewMacroPtr);
1434 * /
1435 return TRUE;
1436 };
1437 BOOL TSteering::IsMacroCalled( void ) {
1438 if ( nCmdIdx < 0 ) return FALSE;
1439 return TRUE;
1440 };
1441 int TSteering::ReturnMacroCall( void ) {
1442 /*
1443 PopParam();
1444 nMacroStep++;
1445 StartCmdExecution(pMacro[nMacroStep]);
1446 * /
1447 return TRUE;
1448 };*/
1449
1450 //#############################################################################
1451 // TMacroExecuteDlg
1452 //#############################################################################
1453
1454 TMacroExecuteDlg::TMacroExecuteDlg(TModelessDlg **aRef): TModelessDlg("EXECUTEMACRO", aRef, GetMainInstance() )
1455 {
1456 bInterrupted= FALSE;
1457 bActionCaused= FALSE;
1458 };
1459
1460 BOOL TMacroExecuteDlg::Dlg_OnInit(HWND hwnd, HWND hwndCtl, LPARAM)
1461 {
1462 int idx;
1463
1464 // Initialisieren der Ablaufsteuerung
1465 CheckDlgButton(hwnd, id_DetailedReport, Steering.IsResponding());
1466 CheckDlgButton(hwnd, id_SaveReport, TRUE);
1467 EnableWindow(GetDlgItem(hwnd, cm_Interrupt), bActionCaused);
1468 hMacroList= GetDlgItem(hwnd, id_ChooseMacro);
1469 idx= 0;
1470 do
1471 {
1472 TheMacro= Steering.GetMacroByNumber(idx++);
1473 if (TheMacro)
1474 ComboBox_AddString(hMacroList, TheMacro->Name);
1475 } while (TheMacro); // 22.04.2003 Kullmann+Reinecker: anstatt while (1) { ... if (!TheMacro) break;... }
1476 TheMacro= Steering.GetMacroByNumber(0);
1477 if (TheMacro)
1478 ComboBox_SelectString(hMacroList, 0, TheMacro->Name);
1479 else
1480 ComboBox_SelectString(hMacroList, 0, "");
1481 FORWARD_WM_COMMAND(hwnd, cm_ParamSet, hwndCtl, 0, SendMessage);
1482 return TRUE;
1483 };
1484
1485 void TMacroExecuteDlg::Dlg_OnCommand(HWND hwnd, int cmd, HWND hwndCtl, UINT codeNotify)
1486 {
1487 //! static HWND hDlgItem;
1488 int id;
1489 EMacroId OldId;
1490
1491 switch (cmd)
1492 {
1493 case cm_CounterSet: //***********************************
1494 //** Ausgabe der aktuellen Position
1495 TDetectorManager::DetectorManager().GetDetector()->UpdateViews(TRUE);
1496 Steering.DetectorRequest();
1497 break;
1498
1499 case cm_SteeringReady:
1500 EnableWindow(GetDlgItem(GetHandle(), cm_Start), TRUE);
1501 EnableWindow(GetDlgItem(GetHandle(), cm_Interrupt), FALSE);
1502 if ( TDetectorManager::DetectorManager().GetDetector()->GetCounterWnd() != 0)
1503 TDetectorManager::DetectorManager().GetDetector()->MeasureStart();
1504 break;
1505
1506 case cm_Start: //****************************************
1507 if (bInterrupted)
1508 {
1509 bInterrupted= Steering.ToggleInterrupt();
1510 PostMessage(GetHandle(), WM_COMMAND, (WPARAM)cm_ParamSet, 0);
1511 PostMessage(GetHandle(), WM_COMMAND, (WPARAM)cm_ParamSet, 0);
1512 break;
1513 }
1514 Steering.StartUp(GetHandle(), mlGetAxis(), TDetectorManager::DetectorManager().GetDetector());
1515 // Testgruppe: Fehler behoben 09.08.2002
1516 // Steering.Visualising( TRUE, TRUE ); ignorierte Zustand von bSendReport
1517 Steering.Visualising( Steering.IsResponding(), TRUE );
1518 if (Steering.StartMacroExecution(TheMacro, GetHandle()))
1519 {
1520 bActionCaused= TRUE;
1521 ListBox_ResetContent(GetDlgItem(GetHandle(), id_Report));
1522 }
1523 else
1524 MessageBox("Fehler beim Starten", "Meldung", MBINFO);
1525 PostMessage(GetHandle(), WM_COMMAND, (WPARAM)cm_ParamSet, 0);
1526 break;
1527
1528 case cm_Interrupt:
1529 if (!bActionCaused)
1530 break;
1531 if (bInterrupted)
1532 {
1533 // Macro beenden
1534 Steering.Reset();
1535 bActionCaused= FALSE;
1536 bInterrupted= FALSE;
1537 }
1538 else
1539 bInterrupted= Steering.ToggleInterrupt();
1540 PostMessage(GetHandle(), WM_COMMAND, (WPARAM)cm_ParamSet, 0);
1541 break;
1542
1543 case cm_ParamSet:
1544 #ifdef GermanVersion
1545 if (bActionCaused && bInterrupted)
1546 {
1547 SetWindowText(GetDlgItem(GetHandle(), cm_Start), "Weiter");
1548 SetWindowText(GetDlgItem(GetHandle(), cm_Interrupt), "Beenden");
1549 }
1550 else
1551 {
1552 SetWindowText(GetDlgItem(GetHandle(), cm_Start), "Start");
1553 SetWindowText(GetDlgItem(GetHandle(), cm_Interrupt), "Anhalten");
1554 }
1566 #endif
1567 EnableWindow(GetDlgItem(GetHandle(), cm_Start), bInterrupted == bActionCaused);
1568 EnableWindow(GetDlgItem(GetHandle(), cm_Interrupt), !(!bInterrupted && !bActionCaused));
1569 EnableWindow(GetDlgItem(GetHandle(), cm_DeleteMacro), !bActionCaused);
1570 EnableWindow(GetDlgItem(GetHandle(), cm_LoadMacro), !bActionCaused);
1571 break;
1572
1573 case id_DetailedReport:
1574 Steering.SetResponse(!Steering.IsResponding());
1575 CheckDlgButton(GetHandle(), id_DetailedReport, Steering.IsResponding());
1576 break;
1577
1578 case cm_LoadMacro:
1579 id= ComboBox_GetCount(hMacroList);
1580 while (id--)
1581 ComboBox_DeleteString(hMacroList, id);
1582 Steering.LoadMacroByUser();
1583 //! Diese (bisherige) Version fuegte am Ende der startbaren Makros eine
1584 //! Leerzeile ein, die bei Auswahl und anschl. Start zum Absturz fuehrte
1585 /*
1586 id= 0;
1587 for(;;)
1588 {
1589 TheMacro= Steering.GetMacroByNumber(id++);
1590 if(!TheMacro) break;
1591 ComboBox_AddString(hMacroList,TheMacro->Name);
1592 }
1593 */
1594 //! Workaround nutzt tatsaechliche Makro-Anzahl
1595 for (id= 0; id < Steering.GetMacroCount(); id++)
1596 {
1597 TheMacro= Steering.GetMacroByNumber(id);
1598 ComboBox_AddString(hMacroList, TheMacro->Name);
1599 }
1600 TheMacro= Steering.GetMacroByNumber(0);
1601 ComboBox_SelectString(hMacroList, 0, TheMacro->Name);
1602 break;
1603
1604 case cm_DeleteMacro:
1605 id= ComboBox_GetCount(hMacroList);
1606 while (id--)
1607 ComboBox_DeleteString(hMacroList, id);
1608 Steering.DeleteMacro(TheMacro);
1609 id= 0;
1610 do
1611 {
1612 TheMacro= Steering.GetMacroByNumber(id++);
1613 if (TheMacro)
1614 ComboBox_AddString(hMacroList, TheMacro->Name);
1615 } while (TheMacro); // 22.04.2003 Kullmann+Reinecker: anstatt while (1) { ... if (!TheMacro) break;... }
1616 TheMacro= Steering.GetMacroByNumber(0);
1617 if (TheMacro)
1618 ComboBox_SelectString(hMacroList, 0, TheMacro->Name);
1619 else
1620 ComboBox_SelectString(hMacroList, 0, "");
1621 break;
1622
1623 case id_ChooseMacro:
1624 if (codeNotify==CBN_SELCHANGE)
1625 {
1626 id= ComboBox_GetCurSel(hMacroList);
1627 if (CB_ERR == id)
1628 break;
1629 OldId= TheMacro->Id;
1630 TheMacro= Steering.GetMacroByNumber(id);
1631 if (!TheMacro)
1632 TheMacro= Steering.GetMacroByNumber(OldId);
1633 }
1634 break;
1635
1636 default:
1637 TModelessDlg::Dlg_OnCommand(hwnd, cmd, hwndCtl, codeNotify);
1638 }
1639 };
1640
1641 void TMacroExecuteDlg::LeaveDialog(void)
1642 {
1643 int count;
1644 int hFile;
1645 HWND hwndCtl;
1646 char lpszBuffer[MaxString];
1647 OFSTRUCT of;
1648
1649 if (IsDlgButtonChecked(GetHandle(), id_SaveReport))
1650 {
1651 hwndCtl= GetDlgItem(GetHandle(), id_Report);
1652 hFile= OpenFile("macro.log", &of, OF_CREATE);
1653 MessageLine= ListBox_GetCount(hwndCtl);
1654 for (count= 0; count < MessageLine; count++)
1655 {
1656 ListBox_GetText(hwndCtl, count, lpszBuffer);
1657 _lwrite(hFile, (LPSTR)lpszBuffer, strlen(lpszBuffer));
1658 _lwrite(hFile, (LPSTR)"\r\n", strlen("\r\n"));
1659 }
1660 _lclose(hFile);
1661 }
1662 if (bActionCaused)
1663 {
1664 if (!bInterrupted)
1665 Steering.ToggleInterrupt();
1666 Steering.Reset();
1667 }
1668 };
1669
1670 BOOL TMacroExecuteDlg::CanClose(void)
1671 {
1672 return TRUE;
1673 };
1674
1675
1676
1677 /*27.04.2004
1678 //#############################################################################
1679 // TEditWindow
1680 //#############################################################################
1681
1682 TEditWindow::TEditWindow(LPSTR aFileName) : TMDIWindow()
1683 {
1684 bIsNewFile= TRUE;
1685 bFileChanged= FALSE;
1686 if (aFileName)
1687 lstrcpy((LPSTR)FileName, aFileName);
1688 WindowType= wtEdit;
1689
1690 HMENU TheMenu= CreatePopupMenu();
1691 AppendMenu(TheMenu, MF_STRING, -1, "Item");
1692 };
1693
1694 TEditWindow::~TEditWindow()
1695 {};
1696
1697 void TEditWindow::Create(HWND)
1698 {
1699 if (strcmp(FileName, ""))
1700 ReadFile();
1701 SetTitle();
1702 };
1703
1704 void TEditWindow::Size(HWND hWnd, WPARAM, LPARAM)
1705 {
1706 GetWindowRect(hWnd, &WndRect);
1707 };
1708
1709 BOOL TEditWindow::SetTitle()
1710 {
1711 strcpy(m_Title, "Text:");
1712 if ( !strcmp(FileName, "") )
1713 {
1714 strcat(m_Title, "<untitled.txt>");
1715 bFileChanged= TRUE;
1716 }
1717 else
1718 strcat(m_Title, FileName);
1719 return TMDIWindow::SetTitle();
1720 };
1721
1722 void TEditWindow::Paint(HDC hdc, PAINTSTRUCT *ps)
1723 {
1724 char buf[MaxString];
1725 HFONT hFont;
1726
1727 SetMapMode(hdc, MM_TEXT);
1728 LOGFONT lf;
1729 memset(&lf, 0, sizeof(LOGFONT));
1730 lf.lfHeight= 12;
1731 lf.lfWidth= 4;
1732 lf.lfWeight= 600;
1733 lf.lfUnderline= FALSE;
1734 lstrcpy(lf.lfFaceName, "Courier New");
1735 hFont= CreateFontIndirect(&lf);
1736 //Datum: 15.08.2002 das zurückgegebene Objekt wird nur geschrieben, am Ende des Zeichnungsvorgangs aber nicht wiederhergestellt (damit Warning) HGDIOBJ testobc=
1737 SelectObject(hdc, hFont); // das zurückgegeben Objekt sollte am Ende des Zeichnungsvorgangs wieder ausgewählt werden!!!
1738 // Zeichnen der Daten
1739 sprintf(buf, "%s", "Text");
1740 DrawText(hdc, (LPSTR)buf, strlen(buf) - 1, &(ps->rcPaint), DT_RIGHT | DT_SINGLELINE);
1741 DeleteObject(hFont);
1742 };
1743
1744 BOOL TEditWindow::CanClear()
1745 {
1746 char buf[MaxString];
1747 int rslt;
1748
1749 if (IsModified())
1750 {
1751 if (!FileName)
1752 strcpy(buf, "Untitled file has changed. Save?");
1753 else
1754 sprintf(buf, "File \"%s\" has changed . Save?", FileName);
1755 rslt= MessageBox(GetHandle(), buf, "File Changed", MB_YESNO | MB_ICONEXCLAMATION);
1756 return (rslt == IDYES ? SaveFile(def) : rslt != IDNO);
1757 }
1758 else
1759 return TRUE;
1760 };
1761
1762 BOOL TEditWindow::ReadFile()
1763 {
1764 BOOL ret= TRUE;
1765 return ret;
1766 };
1767
1768 BOOL TEditWindow::NewFile()
1769 {
1770 if (CanClear())
1771 {
1772 ClearWindow();
1773 ClearModify();
1774 bIsNewFile= TRUE;
1775 strcpy(FileName, "");
1776 SetTitle();
1777 }
1778 return TRUE;
1779 };
1780
1781 BOOL TEditWindow::SaveFile(EAskType)
1782 {
1783 if (IsModified())
1784 if (FileName) {
1785 // Inhalt des Fensters speichern
1786 } else return SaveFileAs();
1787 return TRUE;
1788 };*/
1789
1790 //#############################################################################
1791 // LASTLINE
1792 //#############################################################################
1793
1794