File: DIFRKMTY\S_EXTERN.CPP
1 //##############################################################################
2 // //
3 // S_EXTERN.CPP //
4 // //
5 // Subsystem: Diffraktometrie/ Reflektometrie //
6 // DAS MDI-Fenster für Continious-, Step- und DynamicStepScan //
7 // Benutzung durch andere Subsysteme erforderlich: JA //
8 // //
9 //##############################################################################
10 //! Kommentierung und Aenderungen B. Buss, 2000/2001, HUB IfI
11
12 #include <direct.h>
13
14 #include "internls\evrythng.h" // GermanVersion
15 #include "winresrc\rc_def.h" // Ressourcen-IDs
16 #include "help\help_def.h" // Help-IDs
17 #pragma hdrstop
18
19 #include "difrkmty\s_extern.h" // SCHNITTSTELLE für diese Datei
20 #include "difrkmty\s_intern.h" // TSetupContinuousScanDlg, TSetupStepScanDlg, TSetupDynamicStepDlg
21
22 #include "datavisa\datavisa.h"
23 #include "detecuse\detecuse.h"
24 #include "motrstrg\motrstrg.h"
25 #include "workflow\workflow.h"
26
27 //! neu: klier Allgemeine Einstellungen
28 #include "mespara\mespara.h"
29 //! neu: klier Protokollbuch
30 #include "protocol\protocol.h"
31
32 //--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--
33
34 //##############################################################################
35 // externe Abhängigkeiten
36 //##############################################################################
37
38 extern TMain Main; // in M_MAIN.CPP deklariertes Hauptprogramm
39 extern TSteering Steering; // in M_STEERG.CPP
40
41 //! neu: klier Allgemeine Einstellungen
42 extern TMeasurementParameter MeasurementParameter; // in M_MAIN.CPP
43
44 #define ContinuousScanCapability
45 //17.07.2003 #define WRITE OF_WRITE
46
47 //#############################################################################
48 // sprachspezifische Konstanten
49 //#############################################################################
50
51 #ifdef GermanVersion
52 static const char szTitle[]= "LineScan: ";
53 static const char szMessageScan[]= "Meldung";
54 static const char szMsgFailureScan[]= "Fehler";
55 static const char szMsgLine101[]= "Einen Standard-Scan mit %s\r\nBereich (%s >> %s) \r\nstarten ?";
56 static const char szMsgLine102[]= "Einen Omega2Theta-Scan mit Omega\nvon %s bis %s starten ?";
57 static const char szMsgLine103[]= "%smit Omega von %s bis %s starten ?";
58 static const char szMsgLine104[]= "Einen kontinuierlichen Scan mit %s\nvon %s nach %s starten ?";
59 static const char szMsgLine105[]= "Es ist ein Fehler aufgetreten. %d";
60 static const char szMsgLine106[]= "Die Messung wurde abgeschlossen \nund gespeichert.";
61 static const char szMsgLine107[]= "Die Messung wurde abgeschlossen. Fehler beim Speichern.";
62 static const char szMsgLine108[]= "Header ist nicht korrekt";
63 static const char szMsgLine109[]= "Datei existiert nicht !";
64 static const char szMsgLine110[]= "Alte Datendatei laden ...";
65 static const char szMsgLine111[]= "Datei wurde nicht geoeffnet !";
66 static const char szMsgLine112[]= "Punkte : %d";
67 static const char szMsgLine113[]= "Die Messung wurde abgeschlossen.";
68 static const char szMsgLine114[]= "Bereiche : %d";
69 static const char szMsgLine115[]= "Start Scan";
70 static const char szMsgLine116[]= "Anfahren der Startposition";
71 static const char szMsgLine117[]= "Anfahren der letzten Position";
72 static const char szMsgLine118[]= "Bereich von %f bis %f Intensität %f";
73 static const char szMsgLine119[]= "Messung wurde unterbrochen !";
74 static const char szMsgLine120[]= "Scanachse ???"; // max. _MAXLENUNIT-Zeichen
75 static const char szMsgLine121[]= "kontinuierlichen &Scan starten";
76 static const char szMsgLine122[]= "Step&Scan starten";
77 static const char szMsgLine123[]= "Die Messung wurde abgebrochen !";
78
79 //! neu: klier Protokollbuch
80 static const char szMsgLine133[]= "Soll die Messung im Protokollbuch gespeichert werden?";
81
82 static const char szAngleUnit[]= "Winkel von %s\nin %s";
83 static const char szAngleUnitEZ[]= "Winkel von %s";
117 #endif
118
119 //##############################################################################
120 // TScanParameters
121 //##############################################################################
122
123 //! einlesen der Ini-daten zu [Scan] und setzen von default-werten fuer StepScan
124 //! wird nur durch TScanWindow-konstruktor aufgerufen
125 TScanParameters::TScanParameters() : Scaler(2*nMaxScaleIdx, 0.0), Detector(0), Monitor(0)
126 {
127 char Param[ MaxString ];
128 char buf[ MaxString ];
129 int idx, mid= mlGetAxis();
130
131 Detector= TDetectorManager::DetectorManager().GetDetector(0, 0);
132
133 //! testet ob Omega-Motor angeschlossen ist
134 //! wenn ja => akt.Motor Omega setzen
135 //! wenn nein => akt. Motor
136 if ( mlIsAxisValid( Omega ) )
137 {
138 nMotor= mlGetIdByName( Omega );
139 mlSetAxis( nMotor );
140 }
141 else
142 nMotor= mlGetAxis();
143
144 //! setzen von Werten mit ihren Motorspez. Daten ..
145 /*17.07.2003
146 dArgumentMax= dArgumentWidth * 100.0;
147 dArgumentMin= -dArgumentWidth * 100.0;*/
148 dArgumentWidth= mGetValue( Width );
149 if ( !mGetDistance( dArgumentMin ) ) dArgumentMin= mGetValue(MinDistanceRel);
150 dArgumentMax= min( mGetValue(MaxDistanceRel), dArgumentMin + dArgumentWidth*200.0);
151 dSpeed= mGetValue( Speed );
152 //! 2thetawert initialisieren (symmetr. reflex)
153 d2ThetaStart= min( mlGetValue(mlGetIdByName(Theta), MaxDistanceRel), 2.0 * dArgumentMin);
154
155 nCollectionAmount= 100;
156 nNumberCycle= 1;
157 //! setzen von einigen Defaultwerten
158 eSaveFormat= ffTupel;
159 eScanType= stStandardScan;
160 bSaveContinuous= FALSE;
161 //! Aenderung Dynamische Schrittweite
162 bDynamicStepWidth= FALSE;
163 nStepScaleLevels= 0;
164
165
166 //! auslesen von ExposureTime,ExposureCounts,DynamicStepWidth aus Scan-Teil
167 //! in der Ini-Datei
168 GetPrivateProfileString( "Scan", "ExposureTime", "1.0", buf, MaxString,
169 GetCFile() );
170 fMaxTime= atof( buf );
171
172 GetPrivateProfileString( "Scan", "ExposureCounts", "10000", buf, MaxString,
173 GetCFile() );
174 dwMaxCounts= atol( buf );
175 //! wenn im inifile CreateIniDefaults=1 => dann ExposureCounts in Ini-File
176 //! speichern
177 if ( CreateIniDefaults() )
178 WritePrivateProfileString( "Scan", "ExposureCounts", buf, GetCFile() );
179
180 //! einlesen der Level fuer Schrittweitensteuerung aus ini-datei
181 //! (falls exist.)
182 //! einlesen der Level-Werte aus Ini-File
183 //! wenn nicht vorhanden, Default-Werte setzen
184 for (idx= 0; idx < nMaxScaleIdx; idx++)
185 {
186 char buf2[MaxString];
187 sprintf( Param, "Level%d", idx );
188 sprintf(buf2, "%f %f", (float)(idx + 1)*1000, (float) 1.0);
189 GetPrivateProfileString( "Scan", Param, buf2, buf, MaxString, GetCFile() );
190 sscanf( buf, "%f %f", &Scaler[ idx ], &Scaler[ idx + nMaxScaleIdx ] );
191 }
192 bSaveOnReady= GetPrivateProfileInt( "Scan", "SaveOnReady", 1, GetCFile() );
193
194 //! setzt die Achse, die auch beim Aufruf des Konstr. gesetzt war
195 mlSetAxis( mid );
196 };
197
198 //##############################################################################
199 // TScanWindow
200 //##############################################################################
201
202 TScanWindow::TScanWindow( HINSTANCE aInstance ) : TScanParameters(), TPlotWindow(aInstance), oldDetector(0)
203 {
204 bInterrupted= FALSE;
205 WindowType= wtScan;
206 bLineScanStarted= FALSE;
207 bScanSetupOk= FALSE;
208
209 //! erstellen der Menüeintraege
210 hHoleMenu= LoadMenu(GetMainInstance(), MAKEINTRESOURCE(menu_Scan));
211 // Fix für PopupMenüs aus Ressourcen (Dummy Popup)
212 TheMenu= GetSubMenu(hHoleMenu, 0);
213
214 //! speicher fuer 50 Messpunkte reservieren und Curve initializieren
215 MainCurve= ( TCurve* ) new TCurve();
216 //! FIX Fehler 77
217 bScanSetupOk= FALSE;
218 oldDetector= TDetectorManager::DetectorManager().GetDetector();
219
220 //! setzen der Filter und der Extension
221 strcpy( szExtension, "crv" );
222 strcpy( szFilter, "Scan Standard (*.crv)|*.crv||" );
223 };
224 //*****************************************************************************
225
226 //! loeschen der Kurve,des Menues und speichern von Werten in der Ini-Datei
227 TScanWindow::~TScanWindow()
228 {
229 char buf[ MaxString ];
230 RECT rc, rcm;
231
232 //! loeschen der Kurve
233 _FREEOBJ(MainCurve); //hp
234
235 //! loeschen des Menues
236 DestroyMenu( hHoleMenu );
237 //! anhalten des Detektor + Det. neustarten
238 mSetCorrectionState( FALSE );
239 Detector->MeasureStop();
240 Detector->SetControlWnd( NULL );
241 //! ermitteln der Pos. des Scanfensters + speichern der Koord., des aktuellen
242 //! Verzeichnisses, der ExposureTime und von 'SaveOnReady' im Ini-file
243 GetWindowRect( GetFrameHandle(), &rcm );
244 GetWindowRect( GetHandle(), &rc );
245 sprintf( buf, "%d", rc.left - rcm.left - 4 );
246 WritePrivateProfileString( "Scan", "xo", buf, GetCFile() );
247 sprintf( buf, "%d", rc.top - rcm.top - 42 );
248 WritePrivateProfileString( "Scan", "yo", buf, GetCFile() );
249 sprintf( buf, "%d", rc.right - rc.left );
250 WritePrivateProfileString( "Scan", "dx", buf, GetCFile() );
251 sprintf( buf, "%d", rc.bottom - rc.top );
252 WritePrivateProfileString( "Scan", "dy", buf, GetCFile() );
253 WritePrivateProfileString( "Scan", "DataPath", szDataPath, GetCFile() );
254 sprintf( buf, "%.2f", fMaxTime );
255 WritePrivateProfileString( "Scan", "ExposureTime", buf, GetCFile() );
256 sprintf( buf, "%d", bSaveOnReady );
257 WritePrivateProfileString( "Scan", "SaveOnReady", buf, GetCFile() );
258 // Kanal- oder Winkeldarstellung: zuletzt benutze Darstellungsoption speichern
259 IniWriteBool( GetCFile(), "Scan", "ChannelsOnXAxis", bSecondaryCoor );
260
261 //! Aenderung Dynamische Schrittweite
262 //! schreiben der aktuellen Einstellungen fuer Dyn. Schrittweite ins Ini-File
263 for (int idx= 0; idx < nMaxScaleIdx; idx++)
264 {
265 char Param[ MaxString ];
266 sprintf( Param, "Level%d", idx );
267 sprintf(buf, "%.0f %.2f", Scaler[ idx ], Scaler[ idx + nMaxScaleIdx ]);
268 WritePrivateProfileString( "Scan", Param, buf, GetCFile() );
269 }
270 //! registr. des Scanfenster als Kindfenster und sein handle geloescht
271 Main.SetScanWindow(NULL);
272 Main.ScanWindow= NULL;
273
274 TDetectorManager::DetectorManager().SetDetector(oldDetector);
275 if ( oldDetector ) oldDetector->MeasureStart();
276 };
277 //*****************************************************************************
278
279 //! Darstellen des StepScan-Fenster
280 void TScanWindow::OnCreate()
281 {
282 RECT rc;
283
284 //! ScanFenster als Kindfenster + sein Handle
285 Main.SetScanWindow( GetHandle() );
286 Main.ScanWindow= this;
287
288 // HotKey's für F1
289 LoadHotKeys( LoadAccelerators(GetMainInstance(), MAKEINTRESOURCE(ACC_Scan)) ); // Accelerator aus Ressourcen laden
290
291 Delay( 2000 );
292
293 //! koordinaten des stepscanfenster,Arbeitsverzeichnis aus dem IniFile holen
294 //! .crv als Datei endung festlegen
295 rc.left= GetPrivateProfileInt( "Scan", "xo", 500, GetCFile() );
296 rc.top= GetPrivateProfileInt( "Scan", "yo", 400, GetCFile() );
297 rc.right= rc.left + GetPrivateProfileInt( "Scan", "dx", 170, GetCFile() );
298 rc.bottom= rc.top + GetPrivateProfileInt( "Scan", "dy", 50, GetCFile() );
299 GetPrivateProfileString( "Scan", "DataPath", "c:\\", szDataPath, _MAX_PATH,
300 GetCFile() );
301 if ( szDataPath[ max(0, strlen(szDataPath)-1) ] != '\\' )
302 strcat( szDataPath, "\\" );
303 // Kanal- oder Winkeldarstellung: zuletzt benutze Darstellungsoption wiederherstellen
304 bSecondaryCoor = IniReadBool( GetCFile(), "Scan", "ChannelsOnXAxis", FALSE );
305
306 //! Titelzeile des Fensters bestimmen + aktualisieren des Hauptmenues +
307 //! darstellen des Scanfensters
308 //! passt y-Scale(Intensitaet) an aktuelle Messkurve an
309 SetTitle();
310 SetRanges();
311 SetWindowPos( GetHandle(), NULL, rc.left, rc.top, rc.right - rc.left,
312 rc.bottom - rc.top, SWP_NOZORDER );
313 };
314 //*****************************************************************************
315
316 LRESULT TScanWindow::OnCommand(WPARAM wParam, LPARAM lParam)
317 {
318 TModalDlg *dlg= 0;
319 WPARAM Cmd= GET_WM_COMMAND_ID(wParam, lParam);
320 switch (Cmd)
321 {
322 case cm_New: // Hauptmenü
323 Steering.Reset();
324 bLineScanStarted= FALSE; // für Steering.Reset() abschalten
325 bInterrupted= FALSE;
326 SetFileName("");
327 New(); // das alles darf nicht in New() verschoben werden = NUR HIER wenn Menüpunkt geklickt wurde
328 return 0l;
329
330 case cm_SetupStepScan: //! Aufruf der Dialogbox 'Einstellungen StepScan'
331 dlg= new TSetupStepScanDlg( this );
332 if ( dlg ) dlg->ExecuteDialog( GetHandle() );
333 _FREEOBJ(dlg);
334 SetRanges();
335 //! Scanstart ist erlaubt (param. gueltig)
336 bScanSetupOk= TRUE;
337 //! fenster neuzeichnen
338 UpdateWnd();
339 return 01;
340
341 case cm_SetupContinuousScan: //! Aufruf der Dialogbox 'Einstellungen ContinuousScan'
342 dlg= new TSetupContinuousScanDlg( this );
343 if ( dlg ) dlg->ExecuteDialog( GetHandle() );
344 _FREEOBJ(dlg);
345 SetRanges();
346 //! Scanstart ist erlaubt (param. gueltig)
347 bScanSetupOk= TRUE;
348 //! fenster neuzeichnen
349 UpdateWnd();
350 return 01;
351
352 case cm_InitializeScan: // vom Kontextmenü
353 case cm_InitializeLineScan: // via SendMessage zum wiederholten Aufruf (warten bis Startposition erreicht)
354 switch ( eScanType ) {
355 case stStandardScan: //! standard scan starten
356 InitializeStandardScanTask();
357 break;
358
359 case stOmega2ThetaScan: //! Omega2ThetaScan starten
360 InitializeOmega2ThetaScanTask();
361 break;
362
363 case stContinuousScan: //! ContinuousScan starten
364 InitializeContinuousScanTask();
365 break;
366 }
367 return 01;
368
369 case cm_Help:
370 WinHelp(GetHandle(), GetHelpFile(), HELP_CONTEXT, Help_LineScan);
371 return 0l; // Botschaft verarbeitet
372
373 default:
374 return TPlotWindow::OnCommand(wParam, lParam);
375 }
376 }
377 //*****************************************************************************
378
379 //! loescht aktuelle Kurve + baut StepScanfenster neu auf
380 //! Rueckkehrcode immer True
381 BOOL TScanWindow::New( void )
382 {
383 //! zuruecksetzen der akt. Kurve auf seine Initial.Werte
384 MainCurve->New();
385
386 //! ruecksetzen von Parametern + loeschen des Fensterinhalt + neuen
387 //! Fenstertitel
388 return TPlotWindow::New();
389 };
390 //*****************************************************************************
391
392 //! setzt Titel des ScanFensters
393 //! Rueckkehrcode immer True
394 BOOL TScanWindow::SetTitle()
395 {
396 strcpy( m_Title, szTitle );
397 //! haengt "<untitled.crv>" bei neuer Datei , sonst FileName an
398 //! und schreibt ihn ins Fenster
399 if ( bIsNewFile )
400 strcat( m_Title, "<untitled.crv>" );
401 else
402 strcat( m_Title, FileName );
403 return TMDIWindow::SetTitle();
404 };
405 //*****************************************************************************
406
407 //! setzt x-achse von startwinkel -> endwinkel (default 0.01,100)
408 //! setzt y-achse auf min -> max intensitaet siehe Dlg.box 'Displayoptions'
409 //! (default 1E1,1E5)
410 void TScanWindow::SetRanges( void )
411 {
412 TPlotWindow::SetRanges();
413 CoorSys.xMin= dArgumentMin;
414 CoorSys.xMax= dArgumentMax;
415 };
416 //*****************************************************************************
417
418 void TScanWindow::InitializeStandardScanTask()
419 {
420 char fmt[ MaxString ];
421 char buf[ MaxString ];
422
423 //! setzt geschwindigkeit des akt. motors auf 1000? warum!
424 mSetValue( Speed, 1000.0 );
425 //! ? nicht weiter verfolgt
426 mSetCorrectionState( TRUE );
427 // Motor initialisieren
428 //! Motor einstellen
429 mlSetAxis( nMotor );
430 sprintf( fmt, szMsgLine101, mGetAxisName(), mGetDF(), mGetDF() );
431 sprintf( buf, fmt, dArgumentMin, dArgumentMax );
432 //! sicherheitsabfrage, ob scan wirklich starten
433 if ( IDNO == MessageBox( buf, szMsgLine115, MBASK ) )
434 return;
435
436 bLineScanStarted= TRUE; // beginnt nach Akzeptieren des Meldungsfensters
437 //! entfernt alle wm_Timer nachrichten aus warteschlange und setzt
438 //! Detektor auf inaktiv
439 Detector->MeasureStop();
440 //! gibt die Werte Zeit,Impulse und Fehler an Detektor weiter
441 Detector->SetControlWnd( GetHandle() );
442 Detector->SetExposureSettings( TExposureSettings(fMaxTime, dwMaxCounts) );
443
444 //! FIX Fehler 15
445 if (Monitor != 0 )
446 {
447 Monitor->MeasureStop();
448 Monitor->SetControlWnd( GetHandle() );
449 Monitor->SetExposureSettings(
450 TExposureSettings( 0.8*fMaxTime, dwMaxCounts) );
451 }
452
453 //! FIX Fehler 70
454 MainCurve->New();
455 //! abfrage des Dateinamens, unter dem die Kurve bei Staendig Sichern
456 //! oder bei Bei Beenden speichern abgelegt werden soll
457 //! FIX Fehler 5
458 if ( bSaveContinuous || bSaveOnReady )
459 SaveFile( atNewName );
460
461 //klier 01.03.2003
462 if (MessageBox( szMsgLine133, szMessageScan, MBASK ) == IDYES)
463 InitializeMeasurementProtocol();
464 else
465 SetProtocolDiffractometryOff();
466
467 //! ? ruecksetzen aller Steering-kommandos und Events
468 Steering.Reset(FALSE);
469 //! ? setzen des eingestellten Motors,Detektors und Kontrollfenster
470 Steering.StartUp( GetHandle(), nMotor, Detector );
471 //! alt // Scan starten
472 //! Darstellungsoptionen fuer Scan setzen
473 Steering.Visualising( TRUE, FALSE );
474 //! starten des standardscan
475 strcpy( buf, "" );
476 Steering.StartCmdExecution( Scan, ForScan, 0, buf, GetHandle() );
477 }
478 //*****************************************************************************
479
480 void TScanWindow::InitializeOmega2ThetaScanTask()
481 {
482 char fmt[ MaxString ];
483 char buf[ MaxString ];
484
485 // Motor initialisieren
486 //! Motor einstellen
487 mlSetAxis( nMotor );
488 //! setzt geschwindigkeit des akt. motors auf 1000? warum!
489 mSetValue( Speed, 1000 );
490 //! ? von uns nicht weiter verfolgt
491 mSetCorrectionState( TRUE );
492 // Sensoren initialisieren
493 sprintf( fmt, szMsgLine102, mGetDF(), mGetDF() );
494 sprintf( buf, fmt, dArgumentMin, dArgumentMax );
495 //! sicherheitsabfrage, ob scan wirklich starten
496 if ( IDNO == MessageBox( buf, szMsgLine115, MBASK ) )
497 return;
498
499 bLineScanStarted= TRUE; // beginnt nach Akzeptieren des Meldungsfensters
500 //! entfernt alle wm_Timer nachrichten aus warteschlange und setzt
501 //! Detektor auf inaktiv
502 Detector->MeasureStop();
503 //! gibt die Werte Zeit,Impulse und Fehler an Detektor weiter
504 Detector->SetControlWnd( GetHandle() );
505 Detector->SetExposureSettings( TExposureSettings(fMaxTime, dwMaxCounts) );
506
507 //! FIX Fehler 15
508 if (Monitor != 0 )
509 {
510 Monitor->MeasureStop();
511 Monitor->SetControlWnd( GetHandle() );
512 Monitor->SetExposureSettings( TExposureSettings( 0.8*fMaxTime, dwMaxCounts) );
513 }
514
515 //! ? setzen des eingestellten Motors,Detektors und Kontrollfenster
516 Steering.Reset(FALSE);
517 //! abfrage des Dateinamens, unter dem die Kurve bei Staendig Sichern
518 //! oder bei Bei Beenden speichern abgelegt werden soll (fehler)
519 if ( bSaveContinuous || bSaveOnReady )
520 SaveFile( atNewName );
521
522 //klier 16.08.02
523 if (MessageBox( szMsgLine133, szMessageScan, MBASK ) == IDYES)
524 InitializeMeasurementProtocol();
525 else
526 SetProtocolDiffractometryOff();
527
528 //! ? setzen des eingestellten Motors,Detektors und Kontrollfenster
529 Steering.StartUp( GetHandle(), nMotor, Detector );
530 //! alt // Scan starten
531 //! Darstellungsoptionen fuer Scan setzen
532 Steering.Visualising( TRUE, FALSE );
533 //! starten des Omega2ThetaScan
534 strcpy( buf, "" );
535 Steering.StartCmdExecution( Scan, ForScan, stOmega2ThetaScan, buf,
536 GetHandle() );
537 }
538 //*****************************************************************************
539
540 void TScanWindow::InitializeContinuousScanTask()
541 {
542 //! gibt Vorbereitungsschritt an in dem sich kont. Scan befindet
543 static int nContStep= 1; //! neu cont
544 static double dStartPos; //! neu cont
545 static double dAccelerationDistance= 0.0; //! neu cont
546 static float fAccelerationTime= 0.0; //! neu cont
547 float fdummy1, fdummy2, fdummy3; //! neu cont
548 static int nAreaNumber; //! neu cont
549 static HCURSOR hOldCursor= 0; //! neu cont
550
551 char fmt[ MaxString ];
552 char buf[ MaxString ];
553
554 //! neuen Scan starten (auch nach abgebrochenem Scan)
555 if ( !bLineScanStarted || bInterrupted)
556 nContStep= 1;
557
558 switch (nContStep)
559 {
560 case 1: //! start eines neuen Scan savedialog+scanstart meldung
561 //! mit hoher Geschwindigkeit zur Startpos.
562 mlSetAxis( nMotor );
563 mSetValue(Speed, 1000.0);
564 sprintf( fmt, szMsgLine104, mGetAxisName(), mGetDF(), mGetDF() );
565 sprintf( buf, fmt, dArgumentMin, dArgumentMax );
566 //! sicherheitsabfrage, ob scan wirklich starten
567 if ( IDNO == MessageBox( buf, szMsgLine115, MBASK ) )
568 return;
569
570 bLineScanStarted= TRUE; // beginnt nach Akzeptieren des Meldungsfensters
571 //! speicherdialog
572 if ( bSaveOnReady )
573 SaveFile( atNewName );
574
575 //klier 01.03.2003
576 if (MessageBox( szMsgLine133, szMessageScan, MBASK ) == IDYES)
577 InitializeMeasurementProtocol();
578 else
579 SetProtocolDiffractometryOff();
580
581 //! loescht akt. Kurve
582 New();
583 //! Beschleunigungs- bzw. Bremsweg und -zeit berechnen
584 //! vorerst auskomment. da die Ini-File-Param. fehlerhaft sind
585 /* fAccelerationTime= fabs(dSpeed / mGetValue( Acceleration ));
586 dAccelerationDistance= fabs(0.5 * mGetValue( Acceleration ) *
587 (fAccelerationTime * fAccelerationTime));*/
588 //! merken der Motorposition vor Scanstart (spaeter dahin zurueck)
589 mlGetDistance(nMotor, Steering.dStartPoint);
590 //! noch vorlauf(Beschleunigungsweg) einrechnen
591 dStartPos= dArgumentMin - dAccelerationDistance;
592 //! Anzahl der zu messenden Bereiche
593 nAreaNumber= nCollectionAmount;
594 //! Zeiger, dass Messung aktiv ist, setzen
595 bMeasurementActive= TRUE;
596 // Schritt abgeschlossen
597 nContStep++;
598 // diese Methode (zeitversetzt) erneut für nächstes <nContStep> aufrufen
599 PostMessage( GetHandle(), WM_COMMAND, cm_InitializeLineScan , 0 );
600 break;
601
602 case 2:
603 //! setzen des ausgewaehlten Detektor und Motor
604 TDetectorManager::DetectorManager().SetDetector( Detector );
605 //! Scanfenster dem Detektor bekannt machen (fuer benachrichtigung)
606 (dynamic_cast<TZeroDimDetector*>(Detector))->SetEventHost(GetHandle());
607 //! entfernt alle wm_Timer nachrichten aus warteschlange und setzt
608 //! Detektor auf inaktiv
609 Detector->MeasureStop();
610 //! gibt die Werte Zeit,Impulse und Fehler an Detektor weiter
611 Detector->SetControlWnd( GetHandle() );
612 Detector->SetExposureSettings( TExposureSettings(fMaxTime, dwMaxCounts) );
613 //! eventuell laufende kommandos loeschen
614 Steering.Reset(FALSE);
615 //! Startposition anfahren
616 mlMoveToDistance(nMotor, dStartPos );
617 //! Fenster neuzeichnen und wait-Cursor
618 UpdateWnd( ptFlush );
619 hOldCursor= SetDefaultCursor( IDC_WAIT );
620 // Schritt abgeschlossen
621 nContStep++;
622 // diese Methode (zeitversetzt) erneut für nächstes <nContStep> aufrufen
623 PostMessage( GetHandle(), WM_COMMAND, cm_InitializeLineScan , 0 );
624 break;
625
626 case 3: //! warten bis startpositionerreicht und anschliessend bewegung zur endpos. starten
627 if (mlIsMoveFinish(nMotor))
628 {
629 /*double distance;
630 mlGetDistance(nMotor,distance);
631 sprintf(buf," %f %d",distance,nAreaNumber);
632 MessageBox(GetFocus(),buf,"hh",MBINFO);*/
633 DelayTime(100);
634 //! normalen cursor setzen
635 SetCursor( hOldCursor );
636 //! setzt geschwindigkeit des akt. Motors
637 mlSetAxis(nMotor);
638 mSetValue( Speed, dSpeed );
639 //! motor startet zur angeg. Pos. + Bremsweg
640 mlMoveToDistance(nMotor, (dArgumentMax + dAccelerationDistance));
641 //! Beschleunigungszeit abwarten
642 if ( fAccelerationTime >= 0.03)
643 DelayTime((int)(fAccelerationTime * 1000 - 20));
644 //! startet einen wiederkehrenden Event (jeweils nach fMaxTime) aufruf
645 //! von EventHandler() des jeweiligen Det. der waehrend des scans
646 //! CounterSetRequest und wenn fertig SteeringReady aufruft
647 (dynamic_cast<TZeroDimDetector*>(Detector))->InitializeEvent( GetHandle(), nAreaNumber );
648 //! fenster neuzeichnen
649 UpdateWnd();
650 nContStep++;
651 // KEIN cm_InitalizeLineScan !!! case 4 wird zum Fortsetzen eines unterbrochenen Scans verwendet
652 }
653 else
654 PostMessage( GetFrameHandle(), WM_COMMAND, cm_InitializeLineScan, 0 );
655 break;
656
657 //! Fortsetzen eines unterbrochenen Scans
658 case 4:
659 //! endwert des letzen gemessenen bereiches ermitteln
660 MainCurve->SetPPLast();
661 MainCurve->PGet(fdummy1, fdummy2, fdummy3);
662 //! Beschleunigungsweg einrechnen
663 dStartPos= (double)fdummy3 - dAccelerationDistance;
664 MainCurve->BackStep();
665 //! verbleibende Anzahl von Bereichen ermitteln
666 nAreaNumber= nCollectionAmount - MainCurve->GetPNumber();
667 //! wieder bei case 2 anfangen
668 nContStep= 2;
669 PostMessage( GetHandle(), WM_COMMAND, cm_InitializeLineScan , 0 );
670 SetInfo(szMsgLine117);
671 break;
672 } //! end switch nContStep
673 }
674 //*****************************************************************************
675
676 //#############################################################################
677 // Schnittstellen fuer Ablaufsteuerung
678 //#############################################################################
679
680 //! behandelt eigentlichen Scanablauf
681 //! aufruf aus m_main.cpp wenn cm_CounterSet
682 void TScanWindow::CounterSetRequest( LPARAM lParam)
683 {
684 float x, y;
685 //! FIX Fehler 15
686 static float z= 0.0;
687 //! merkt sich bei kont.scan das akuelle Bereichsende
688 //! (ist im naechsten durchgang bereichsanfang)
689 static float fLeft;
690 // double dDistance;
691
692 // Funktion behandelt Meldung cm_CounterSet
693 //! wenn Messung unterbrochen oder keine Messung aktiv dann abbrechen
694 if ( bInterrupted )
695 return;
696 if ( !bMeasurementActive )
697 return;
698 //! (Kurve wurde geaendert) setzen
699 bFileChanged= TRUE;
700
701 if ( eScanType == stContinuousScan )
702 {
703 //! bei erstem Aufruf Bereichsanfang festlegen
704 if (MainCurve->GetPNumber() < 1)
705 fLeft= (float) dArgumentMin;
706
707 char buf[MaxString];
708 //! ermittelt akt. position + ablegen in x
709 mlSetAxis(nMotor);
710 x= mGetDistanceProcess();
711 // x= dDistance;
712 //! holt gemessene Intensitaet des gerade abgefahrenen Bereiches von
713 //! Detektor
714 (dynamic_cast<TZeroDimDetector*>(Detector))->GetEventIntensity( y );
715
716 //! Statuszeile ausgeben
717 sprintf(buf, szMsgLine118, fLeft, x, y);
718 SetInfo(buf);
719 //! Intensitaet ueber Bereichsmittelpunkt einzeichnen
720 z= (x + fLeft) / 2;
721 //! Punkt zu Kurve hinzufuegen
722 MainCurve->PAdd( z , y, x);
723 //! akt. Endpunkt ist naechster Startpunkt
724 fLeft= x;
725 //! Neuen punkt ins Fenster zeichnen
726 UpdateWnd( ptPaintPoint );
727 //! test ob Motor die Endposition unerwartet frueh erreicht hat
728 //! kann vorkommen wenn die Motorparameter im ini-file nicht korrekt sind
729 //! und somit der Motor schneller faehrt, als er es laut Speed sollte
730 if (mlIsMoveFinish(nMotor))
731 {
732 //! Detektor anhalten
733 (dynamic_cast<TZeroDimDetector*>(Detector))->KillEvent();
734 //! Scan beenden
735 PostMessage( GetHandle(), WM_COMMAND, cm_SteeringReady , 0 );
736 }
737 }
738 else
739 {
740 //! wenn Monitoring dann holen der Intensitaet von diesem Detektor
741 //! und ablegen dieses Wertes z (in steering) sonst z=0 setzen
742 if ( Monitor != 0 )
743 { //! FIX Fehler 15
744 if ( lParam == Monitor->GetId() )
745 {
746 // normalize signal
747 Monitor->GetIntegral( z );
748 Steering.SetNorm( z );
749 return;
750 }
751 }
752 else
753 z= 0.0;
754
755 //! wenn motor auf position fuer eine Messung
756 if ( Steering.IsPositionValid() )
757 {
758 // dann motorpos. in x
759 x= mlGetValue( nMotor, Distance );
760 // Detektorintensitaet in y
761 Detector->GetIntegral( y );
762 if ( eScanType == stOmega2ThetaScan )
763 // Thetamotorpos. in z
764 z= mlGetValue( mlGetIdByName( Theta ), Distance );
765
766 // tripel(x,y,z) an Kurve anhaengen
767 MainCurve->PAdd( x, y, z );
768 UpdateWnd( ptPaintPoint ); // update data window
769
770 //! wenn Staendig sichern eingestellt wurde dann cm_UpdateFile senden
771 if ( bSaveContinuous ) // store actual value
772 SendMessage( GetHandle(), WM_COMMAND, cm_UpdateFile, 0 );
773 }
774 //! sendet wieder cm_CounterSet ab
775 Detector->UpdateViews(TRUE);
776 //! ? wenn monitor eingest. dann normieren der Detektorintensitaet mit
777 //! der Monitorint. + naechste pos. anfahren
778 Steering.DetectorRequest();
779 }
780 };
781 //*****************************************************************************
782
783 void TScanWindow::GetTitleX(int i, int tilesx, char *buf,bool reduceLines) {
784 // Zahlenwerte
785 TPlotWindow::GetTitleX(i, tilesx, buf, reduceLines);
786
787 // letzte Beschriftung = Beschriftung der Abzissen-Achse
788 if ( i == tilesx ) {
789 if ( eLoadFormat != ffDtnFile) {
790 if ( !strcmp(abzisse, szMsgLine120) ) sprintf(buf, abzisse); // Scanachse ???
791 else if ( reduceLines || strcmp(abzisse, mGetAxisName()) ) sprintf(buf, szAngleUnitEZ, abzisse);
792 else sprintf(buf, szAngleUnit, abzisse, mGetUnitName() );
793 }
794 // ansonsten <buf> unverändert lassen: dann wird die Achse mit Zahlenwerten beschriftet
795 }
796 };
797 void TScanWindow::GetTitleY(int i, int titlesy, char *buf, bool reduceLines) {
798 // Zahlenwerte
799 TPlotWindow::GetTitleY(i, titlesy, buf, reduceLines);
800
801 // letzte Beschriftung = Beschriftung der Ordinaten-Achse
802 if ( i==tilesy ) switch ( eOutputType ) {
803 case otMatrixBitmap:
804 case otReciprokeLatticeBitmap:
805 sprintf(buf, ""); // keine Beschriftung
806 break;
807
808 // ansonsten <buf> unverändert lassen: dann wird "linear oder logarithmisch" beschriftet
809 }
810 }
811 //*****************************************************************************
812
813 void TScanWindow::SetKSProperties( TKSProperties* ksp )
814 { // Kullmann, Reinecker: ATOS-Testfall MS.2 Fehlerbehebung
815 if (!ksp)
816 return;
817
818 // !!! LowerBound und UpperBound setzen, sonst gehen ksp->fMinY und ksp->fMaxY beim nächsten SetRanges verloren
819 LowerBound= CoorSys.yMin= ksp->fMinY;
820 UpperBound= CoorSys.yMax= ksp->fMaxY;
821 dArgumentMin= CoorSys.xMin= ksp->fMinX;
822 dArgumentMax= CoorSys.xMax= ksp->fMaxX;
823 if (ksp->bLogarithmicY)
824 CoorSys.yScal= sLogarithmic;
825 else
826 CoorSys.yScal= sLinear;
827
828 CoorSys.xScal= sLinear; // Logarithmic; geaendert, weil xST meiner Meinung nach nie Logarithmic
829 bAltCoorSystem= FALSE;
830
831 UpdateWnd();
832 }
833 //*****************************************************************************
834
835 //! wird augerufen nachdem AreaScan abgeschlossen wurde
836 //! aus m_main.cpp bei cm_SteeringReset
837 void TScanWindow::SteeringReset( LPARAM lParam )
838 {
839 if ( !bLineScanStarted ) return;
840
841 // Funktion behandelt Meldung cm_CmdExecuted
842 // Funktion behandelt Meldung cm_SteeringReady
843 //! Messung als beendet erklaeren
844 bLineScanStarted= FALSE;
845 bMeasurementActive= FALSE;
846 if ( Detector ) Detector->MeasureStop();
847 SetInfo(szMsgLine123);
848 }
849 //*****************************************************************************
850
851 //! wird augerufen nachdem Scan abgeschlossen wurde
852 //! aus m_main.cpp bei cm_SteeringReady
853 void TScanWindow::SteeringReady( LPARAM lParam )
854 {
855 if ( !bLineScanStarted ) return;
856 char buf[ MaxString ];
857
858 // Funktion behandelt Meldung cm_SteeringReady
859 //! Messung als beendet erklaeren
860 bLineScanStarted= FALSE;
861 bMeasurementActive= FALSE;
862 //! abhaengig von ScanTyp
863 switch ( eScanType )
864 {
865 //! standard u. Omega2Theta
866 case stStandardScan:
867 case stOmega2ThetaScan:
868 // Step-Scan wurde ausgefuehrt
869 switch ( HIWORD( lParam ) )
870 {
871 case R_Failure: //! wenn fehler
872 //klier 16.08.02
873 SetProtocolDiffractometryOff();
874
875 sprintf( buf, szMsgLine105, LOWORD( lParam ));
876 MessageBox( buf, szMsgFailureScan, MBSTOP );
877 break;
878
879 //! sonst
880 default:
881 //! bei eingestelltem Staendig sichern, Headerinfo aktualisieren
882 //! FIX Fehler 6
883 if ( bSaveContinuous )
884 {
885 // Header aktualisieren
886 SaveMeasurementInfo( TRUE ); // update file header
887 bFileChanged= FALSE;
888 }
889 //! bei eingest. Bei Beenden speichern Kurve+ Header speichern
890 //! (Fehler)
891 if ( bSaveOnReady )
892 if ( SaveFile( atNoAsk ) )
893 sprintf( buf, szMsgLine106 );
894 else
895 sprintf( buf, szMsgLine107 );
896 //! FIX Fehler 76
897 else if ( bSaveContinuous )
898 sprintf( buf, szMsgLine106 );
899 else
900 sprintf( buf, szMsgLine113 );
901 MessageBox( buf, szMessageScan, MBINFO );
902
903 //klier 01.03.2003
904 if (IsProtocolDiffractometryOn())
905 {
906 if (!bSaveContinuous && !bSaveOnReady)
907 {
908 SetMeasurementProtocolParameter();
909 SaveProtocolDiffractometryParameter();
910 }
911 ViewOnProtocolDiffractometryDlg();
912 SetProtocolDiffractometryReadOnly();
913 SetProtocolDiffractometryOff();
914 }
915 }
916 //! ? von uns nicht weiter verfolgt
917 mSetCorrectionState( FALSE );
918 //! entfernt alle wm_Timer nachrichten aus warteschlange und setzt
919 //! Detektor auf inaktiv
920 Detector->MeasureStop();
921 //! ? Parameter zuruecksetzen
922 Detector->PopSettings();
923 //! kontrollfenster auf NULL setzen
924 Detector->SetControlWnd( NULL );
925 //! setzt timer wieder auf alten fExposureTime(Messzeit)
926 Detector->MeasureStart();
927 break;
928
929 case stContinuousScan: //! bei ContinuousScan
930 //! test ob Zielposition noch nicht erreicht
931 //! kann vorkommen, wenn der Motor langsamer faehrt, als er es laut speed
932 //! duerfte (Ursache fehlerhafte ini-parameter des motors)
933 if (!mlIsMoveFinish(nMotor))
934 {
935 //! weitere 10 Bereiche messen (hoechstens)
936 bLineScanStarted= TRUE;
937 bMeasurementActive= TRUE;
938 (dynamic_cast<TZeroDimDetector*>(Detector))->InitializeEvent( GetHandle(), 10 );
939 break;
940 }
941 //! messung als beendet kennzeichnen
942 bLineScanStarted= FALSE;
943 bMeasurementActive= FALSE;
944 //! siehe m_layer.h :-(
945 //! motor sofort stoppen
946 mStopDrive( TRUE );
947 //! Detektor-Parameter zuruecksetzen
948 Detector->PopSettings();
949 //! setzt timer wieder auf alten fExposureTime(Messzeit) + Fenster neuz.
950 Detector->MeasureStart();
951 UpdateWnd();
952 //! Motor zurueck auf position vor scanstart fahren
953 mlSetAxis(nMotor);
954 mSetValue(Speed, 1000.0);
955 mlMoveToDistance(nMotor, Steering.dStartPoint);
956 //! in abhaenigkeit von speicheroption Meldung ausgeben
957 if (bSaveOnReady)
958 if ( SaveFile( atNoAsk ) )
959 sprintf( buf, szMsgLine106 );
960 else
961 sprintf( buf, szMsgLine107 );
962 else
963 sprintf( buf, szMsgLine113 );
964
965 MessageBox( buf, szMessageScan, MBINFO );
966
967 //klier 01.03.2003
968 if (IsProtocolDiffractometryOn())
969 {
970 if (!bSaveContinuous && !bSaveOnReady)
971 {
972 SetMeasurementProtocolParameter();
973 SaveProtocolDiffractometryParameter();
974 }
975 ViewOnProtocolDiffractometryDlg();
976 SetProtocolDiffractometryReadOnly();
977 SetProtocolDiffractometryOff();
978 }
979 break;
980 }
981 };
982 //*****************************************************************************
983
984 //! aktive Messung unterbrechen und fortsetzen ueber Menue oder esc-taste
985 void TScanWindow::Interrupt()
986 {
987 if ( !bLineScanStarted ) return;
988
989 //! in Abhaengigkeit von Art des Scan
990 switch ( eScanType )
991 {
992 case stStandardScan:
993 case stOmega2ThetaScan:
994 //! bInterrupted umkehren wenn Messung aktiv ist
995 TMDIWindow::Interrupt();
996 if ( bInterrupted ) //! Messung unterbrechen (wenn Messung nicht läuft, müssen wir auch eine andere Makroverarbeitung abbrechen können - wenn gerade unser Fenster geöffnet ist)
997 {
998 Steering.ToggleInterrupt();
999 //! motor anhalten
1000 mStopDrive( TRUE );
1001 //! Detekor anhalten !!!
1002 (dynamic_cast<TZeroDimDetector*>(Detector))->KillEvent();
1003 mSetCorrectionState( FALSE );
1004 SetInfo( szMsgLine119 );
1005 } else { //! Messung fortsetzen
1006 mSetCorrectionState( TRUE );
1007 Steering.ToggleInterrupt();
1008 }
1009 break;
1010
1011 case stContinuousScan: //! kont. scan
1012 //! messung unterbrechen/fortsetzen (menuepunkt aktualisieren)
1013 TMDIWindow::Interrupt();
1014 if ( bInterrupted ) //! Messung unterbrechen (wenn Messung nicht läuft, müssen wir auch eine andere Makroverarbeitung abbrechen können - wenn gerade unser Fenster geöffnet ist)
1015 {
1016 Steering.ToggleInterrupt();
1017 //! motor anhalten
1018 mStopDrive( TRUE );
1019 //! Detekor anhalten !!!
1020 (dynamic_cast<TZeroDimDetector*>(Detector))->KillEvent();
1021 //! statuszeilenmeldung
1022 SetInfo( szMsgLine119 );
1023 } else { //! Messung fortsetzen
1024 //! wiederaufnehmen des kont.scan erfolgt in InitializeTask unter case 4
1025 PostMessage( GetHandle(), WM_COMMAND, cm_InitializeLineScan , 0 );
1026 }
1027 break;
1028 }
1029 };
1030 //#############################################################################
1031 // Read/Write
1032 //#############################################################################
1033
1034 //! laden der Messungsinfos aus einer .crv bzw. .bk/.dtn datei
1035 //! wird von TScanWindow::LoadOldData() in m_scan.cpp aufgerufen
1036 //! hFile ist Filehandle der Messdatei
1037 //! Rueckkehrcode False wenn Datei zu kurz, [HEADER] nicht vorhanden oder
1038 //! Filetyp ungleich 1 ist
1039 //! true sonst
1040 BOOL TScanWindow::LoadMeasurementInfo( TTxtRead &aFile ) {
1041 strcpy(abzisse, szMsgLine120);
1042
1043 // Header-Informationen auswerten
1044 aFile.Restart();
1045 bool HeaderGef= false;
1046 while ( !aFile.IsEOF() ) { // zeilenweise einlesen
1047 char *line= aFile.NextLine(); // line nicht freigeben, das erledigt TTxtRead
1048 if ( strstr(line, "[Header]") ) { // [Header] gefunden :-)
1049 HeaderGef= true;
1050 continue; // Zeile überlesen
1051 }
1052 if ( !HeaderGef ) continue; // solange [Header] nicht gefunden: Zeilen überlesen
1053 if ( strstr(line, "[Data]") ) break; // bei [Data]: Header komplett = fertig :-)
1054
1055
1056 char *keyword= strtok( line, " =\n\r" ); // den ersten Teil vor "=" auslesen
1057 char *info= strtok( NULL, " =\n\r" ); // den ersten Teil nach "=" auslesen
1058 while ( keyword && info ) { // solange weitere Daten in dieser Zeile
1059 /*if ( !strcmp(keyword, "Date") ||
1060 !strcmp(keyword, "Time") ||
1061 !strcmp(keyword, "HV") )
1062 {
1063 // einfach überlesen
1064
1065 } else */ if ( !strcmp(keyword, "User") ) {
1066 MeasurementParameter.SetUser( info );
1067
1068 } else if ( !strcmp(keyword, "Target") ) {
1069 MeasurementParameter.SetTarget( info );
1070
1071 } else if ( !strcmp(keyword, "Orientation") ) {
1072 MeasurementParameter.SetOrientation( info );
1073
1074 } else if ( !strcmp(keyword, "Reflection") ) {
1075 MeasurementParameter.SetReflection( info );
1076
1077 } else if ( !strcmp(keyword, "WaveLength") ) {
1078 MeasurementParameter.SetWaveLength( info );
1079
1080 } else if ( !strcmp(keyword, "ArgumentMin") ) {
1081 dArgumentMin= atof( info );
1082
1083 } else if ( !strcmp(keyword, "ArgumentMax") ) {
1084 dArgumentMax= atof( info );
1085
1086 } else if ( !strcmp(keyword,"ArgumentWidth") ) {
1087 dArgumentWidth= atof( info );
1088
1089 } else if ( !strcmp(keyword, "Scanaxis") ) {
1090 strcpy(abzisse, info);
1091
1092 } else if ( !strcmp(keyword, "TimePerScan") ) {
1093 fMaxTime= atof( info );
1094
1095 } else if ( !strcmp( keyword, "FileType" ) ) {
1096 //! Standard-scan
1097 if ( !strcmp(info, "1") || !strcmp(info, "Standard") ) {
1098 eScanType= stStandardScan;
1099 eSaveFormat= ffStandardFile;
1100 TPlotWindow::SetLoadFormat(eSaveFormat);
1101
1102 //! bkFile Format eingefuehrt
1103 } else if ( !strcmp(info, "2") || !strcmp(info, "Comparison") ) {
1104 eScanType= stStandardScan;
1105 eSaveFormat= ffBkFile;
1106 TPlotWindow::SetLoadFormat(eSaveFormat);
1107
1108 //! dtnFile Format eingefuehrt
1109 } else if ( !strcmp(info, "3") || !strcmp(info, "Aquisition") ) {
1110 eScanType= stStandardScan;
1111 eSaveFormat= ffDtnFile;
1112 TPlotWindow::SetLoadFormat(eSaveFormat);
1113
1114 //! Omega2Thetascan
1115 } else if ( !strcmp(info, "Omega2Theta") ) {
1116 eScanType= stOmega2ThetaScan;
1117 eSaveFormat= ffStandardFile;
1118 TPlotWindow::SetLoadFormat(eSaveFormat);
1119
1120 //! kont.scan
1121 } else if ( !strcmp( info, "Continuous") ) {
1122 eScanType= stContinuousScan;
1123 eSaveFormat= ffStandardFile;
1124 TPlotWindow::SetLoadFormat(eSaveFormat);
1125
1126 // falsches Datei-Format
1127 } else {
1128 TPlotWindow::SetLoadFormat(ffUnknown);
1129 return false;
1130 }
1131 }
1132
1133 keyword= strtok( NULL, " =\n\r" ); // den nächsten Teil vor "=" auslesen
1134 info= strtok( NULL, " =\n\r" ); // den nächsten Teil nach "=" auslesen
1135 }
1136 }
1137 if ( !HeaderGef ) return FALSE; // [Header] nicht vorhanden
1138
1139 return TRUE;
1140 };
1141 //*****************************************************************************
1142
1143 //! Speichern bzw. Aktualisieren der Headerinformation
1144 //! UpdateHeader ==0 => neu erstellen
1145 //! ==1 => aktualisieren
1146 //! Rueckkehrcode False wenn Fehler bei speichern sonst true
1147 BOOL TScanWindow::SaveMeasurementInfo( BOOL UpdateHeader )
1148 {
1149 //! FIX Fehler 11
1150 int hFile;
1151 OFSTRUCT of;
1152 UINT nSize;
1153 char format[ MaxString ];
1154 char buf[ 2 * MaxString ], buf2[ 20 ], buf3[ 20 ];
1155 SYSTEMTIME t;
1156
1157
1158 //klier 01.03.2003
1159 SetMeasurementProtocolParameter();
1160 SaveProtocolDiffractometryParameter();
1161
1162 //! UpdateHeader ==0 => neu erstellen
1163 //! ==1 => aktualisieren
1164 //! FIX Fehler 11
1165 if ( UpdateHeader )
1166 hFile= OpenFile(FileName, &of, OF_WRITE);
1167 else
1168 {
1169 hFile= OpenFile(FileName, &of, OF_CREATE);
1170 }
1171 //! Fehler bei oeffnen der Datei => abbruch
1172 //! FIX Fehler 11
1173 if ( hFile==HFILE_ERROR )
1174 return FALSE;
1175 //! akt. Uhrzeit + Datum holen
1176 GetLocalTime( &t );
1177 //! Headerinformationen in String ablegen
1178 char *data= new char[ DATAOFFSET + 1 ];
1179 strcpy( format, "Comment=%s" );
1180 sprintf( buf, format, MeasurementParameter.GetComment() );
1181 strcpy( data, buf );
1182 strcat( data, EOL );
1183
1184 strcat( data, "[Header]" );
1185 strcat( data, EOL );
1186 strcpy( format, "User=%s Date=%02i.%02i.%i Time=%2d:%02d:%02d DataOffset=%d" );
1187 sprintf( buf, format, MeasurementParameter.GetUser(), t.wDay, t.wMonth, t.wYear, t.wHour, t.wMinute, t.wSecond, DATAOFFSET );
1188 strcat( data, buf );
1189 strcat( data, EOL );
1190
1191 //! bezeichnerstring der linescanart ermitteln
1192 switch (eScanType)
1193 {
1194 case stContinuousScan:
1195 strcpy(buf2, "Continuous");
1196 break;
1197
1198 case stOmega2ThetaScan:
1199 strcpy(buf2, "Omega2Theta");
1200 break;
1201
1202 default: // auch StandardScan
1203 strcpy(buf2, "Standard");
1204 }
1205
1206 strcpy( format, "Point_Number=%d FileType=%s" );
1207 sprintf( buf, format, MainCurve->GetPNumber(), buf2 );
1208 strcat( data, buf );
1209 strcat( data, EOL );
1210
1211 strcpy( format, "Target=%s Reflection=%s Orientation=%s" );
1212 MeasurementParameter.GetReflection(buf2);
1213 MeasurementParameter.GetOrientation(buf3);
1214 sprintf( buf, format, MeasurementParameter.GetTarget(), buf2, buf3);
1215 strcat( data, buf );
1216 strcat( data, EOL );
1217
1218 mlSetAxis( nMotor );
1219 sprintf( format, "ArgumentMin=%s ArgumentWidth=%s ArgumentMax=%s", mGetDF(),
1220 mGetSF(), mGetDF() );
1221 sprintf( buf, format, dArgumentMin, dArgumentWidth, dArgumentMax );
1222 sprintf(format, " Scanaxis=%s", mGetAxisName());
1223 strcat(buf, format);
1224 strcat( data, buf );
1225
1226 //klier 30.01.2003 Der Wert für das Offset wird mit ausgegeben
1227 // sprintf(format, " Offset=%s", mGetDF());
1228 // sprintf(buf, format, mlGetOffset(nMotor));
1229 // strcat( data, buf );
1230
1231 strcat( data, EOL );
1232
1233 strcpy( format, "WaveLength=%.3f Current=%d HV=%d" );
1234 sprintf( buf, format, MeasurementParameter.GetWaveLength(),
1235 MeasurementParameter.GetCurrent(), MeasurementParameter.GetVoltage() );
1236 strcat( data, buf );
1237 strcat( data, EOL );
1238
1239 strcpy( format, "TimePerScan=%.2f" );
1240 sprintf( buf, format, fMaxTime );
1241 strcat( data, buf );
1242
1243 //! string am ende der Info. bis zum Wert DATAOFFSET(=1000) mit Leerzeichen
1244 //! auffuellen incl. mit [DATA] abschliessen
1245 for ( nSize= strlen( data ); nSize < DATAOFFSET - 10; nSize++ )
1246 data[ nSize ]= ' ';
1247 data[ nSize ]= 0x0;
1248 strcat( data, EOL );
1249 strcat( data, "[Data]" );
1250 strcat( data, EOL );
1251 //! schreiben der Headerinfo. in die Datei + schliessen der Datei
1252 //! FIX Fehler 11
1253 _lwrite(hFile, data, strlen(data));
1254 _lclose(hFile);
1255 _FREELIST(data);
1256 return TRUE;
1257 };
1258 //*****************************************************************************
1259
1260 //! klier 01.03.2003 Protokollbuch
1261 //! initialisiert Speicherung im Protokollbuch
1262 void TScanWindow::InitializeMeasurementProtocol( void )
1263 {
1264 SetProtocolDiffractometryOn();
1265 //klier 01.03.2003
1266 SetProtocolDiffractometryDetektor(Detector->GetCharacteristic());
1267 // SetProtocolDiffractometryDetektor(Detector->GetDimension());
1268
1269 //JP 20.08.2002
1270 // Fall kann nicht eintreten, da in Auswahlbox nur 0dim.-Detektoren
1271 // auswaehlbar sind
1272 // if(Detector->GetDetectorDimensions()==1) {
1273 // TOneDimDetector* Psd= dynamic_cast<TOneDimDetector*>(Detector);
1274 // SetProtocolDiffractometryWinkelbereich( Psd->GetAngleRange() );
1275 // SetProtocolDiffractometryKanalabstand( Psd->GetAngleStep() );
1276 // SetProtocolDiffractometryMesskanal( Psd->GetWidth() );
1277 // SetProtocolDiffractometryAddiere( Psd->GetAddedChannels() );
1278 // }
1279 SetProtocolDiffractometryMonitor("-");
1280 if (eScanType != stContinuousScan)
1281 if ( Monitor != 0 )
1282 SetProtocolDiffractometryMonitor(Monitor->GetCharacteristic());
1283 SetProtocolDiffractometryMesszeit(fMaxTime);
1284 SetProtocolDiffractometryImpulse(dwMaxCounts);
1285
1286 SetMeasurementProtocolParameter();
1287 ViewOnProtocolDiffractometryDlg();
1288 };
1289 //*****************************************************************************
1290
1291 //! klier 01.03.2003 Protokollbuch
1292 //! Speichert Informationen im Protokollbuch
1293 void TScanWindow::SetMeasurementProtocolParameter( void )
1294 {
1295 char buf[ MaxString ];
1296
1297 if (IsProtocolDiffractometryOn())
1298 {
1299 if (bSaveContinuous || bSaveOnReady)
1300 SetProtocolDiffractometryMessdatei(FileName);
1301 SetProtocolDiffractometryNutzer(MeasurementParameter.GetUser());
1302 SetProtocolDiffractometryScanart("LineScan");
1303 //! bezeichnerstring der linescanart ermitteln
1304 switch (eScanType)
1305 {
1306 case stContinuousScan:
1307 SetProtocolDiffractometryScanmethode("ContinuousScan");
1308 SetProtocolDiffractometryScantyp("Omega");
1309 sprintf( buf, mGetDF(), dSpeed );
1310 SetProtocolDiffractometryGeschwindigkeit1(buf);
1311 break;
1312
1313 case stOmega2ThetaScan:
1314 SetProtocolDiffractometryScanmethode("StepScan");
1315 SetProtocolDiffractometryScantyp("Omega2Theta");
1316 break;
1317
1318 case stStandardScan:
1319 //Fehler? Kullmann+Reinecker: Entweder ein break oder gleich default?
1320 default:
1321 SetProtocolDiffractometryScanmethode("StepScan");
1322 SetProtocolDiffractometryScantyp("Omega");
1323 }
1324 MeasurementParameter.GetReflection(buf);
1325 SetProtocolDiffractometryUReflex(buf);
1326 MeasurementParameter.GetOrientation(buf);
1327 SetProtocolDiffractometryOrientierung(buf);
1328
1329 if (eScanType == stOmega2ThetaScan)
1330 {
1331 SetProtocolDiffractometryScanachse2("Theta");
1332 sprintf(buf, mGetDF(), d2ThetaStart);
1333 SetProtocolDiffractometryMinimum2(buf);
1334 sprintf(buf, mGetSF(), 2*dArgumentWidth);
1335 SetProtocolDiffractometrySchrittweite2(buf);
1336 sprintf(buf, mGetDF(), (dArgumentMax - dArgumentMin)*2 + d2ThetaStart);
1337 SetProtocolDiffractometryMaximum2(buf);
1338 sprintf(buf, mGetDF(), mlGetOffset(mlGetIdByName( Theta )));
1339 SetProtocolDiffractometrySOffset2(buf);
1340 }
1341 mlSetAxis( nMotor );
1342 SetProtocolDiffractometryScanachse1(mGetAxisName());
1343 sprintf(buf, mGetDF(), dArgumentMin);
1344 SetProtocolDiffractometryMinimum1(buf);
1345 sprintf(buf, mGetSF(), dArgumentWidth);
1346 SetProtocolDiffractometrySchrittweite1(buf);
1347 sprintf(buf, mGetDF(), dArgumentMax);
1348 SetProtocolDiffractometryMaximum1(buf);
1349 //klier 30.01.2003 Der Wert für das Offset wird mit ausgegeben
1350 sprintf(buf, mGetDF(), mlGetOffset(nMotor));
1351 SetProtocolDiffractometrySOffset1(buf);
1352
1353 sprintf(buf, "%.3f", MeasurementParameter.GetWaveLength());
1354 SetProtocolDiffractometryWellenlaenge(buf);
1355 sprintf(buf, "%d", MeasurementParameter.GetCurrent());
1356 SetProtocolDiffractometryStrom(buf);
1357 sprintf(buf, "%d", MeasurementParameter.GetVoltage());
1358 SetProtocolDiffractometrySpannung(buf);
1359 }
1360 };
1361 //*****************************************************************************
1362
1363 //! speichern einer .crv Datei
1364 //! Rueckkehrcode False wenn Fehler bei anlegen der Datei oder bei speichern
1365 //! der Headerinfo. sonst true
1366 BOOL TScanWindow::SaveFile( EAskType ask )
1367 {
1368 char fmt[ 30 ], buf[ MaxString ];
1369 FILE* hFile;
1370 float x, y, z, x2, y2, z2;
1371
1372 //! anlegen der Datei (event. mit eingabe des Dateinamen)
1373 if ( !TPlotWindow::SaveFile( ask ) )
1374 return FALSE;
1375
1376 //! ueberschreiben der Datei mit Headerinfo.
1377 if ( !SaveMeasurementInfo( FALSE ) )
1378 {
1379 MessageBox( szMsgLine108, szMessageScan, MBINFO );
1380 return FALSE;
1381 }
1382 //! oeffnen der datei + mauszeiger beschaeftigtsymbol
1383 HCURSOR hOldCursor= SetDefaultCursor( IDC_WAIT );
1384 hFile= fopen( FileName, "r+" );
1385 //! auf ersten Messpunkt der Kurve gehen
1386 MainCurve->SetPP();
1387 //! setzt Dateizeiger auf ende der Datei
1388 fseek( hFile, 0, SEEK_END );
1389 sprintf( fmt, "%s %s %s\r\n", mGetSF(), "%.4f", "%.4f" );
1390 // 07.05.2004 MainCurve->FastOpen();
1391 //! Bereichstartpunkt fuer ersten bereich festlegen
1392 y2= dArgumentMin;
1393 //! holt einzelne tripel aus Kurve + fuegt sie an datei an
1394 while ( MainCurve->PGet( x, y, z ) ) // 07.05.2004 FastP...
1395 {
1396 //! bedeutung der kurvenwerte bei kont.scan anders
1397 if (eScanType == stContinuousScan)
1398 {
1399 //! zuordnung kont.Format
1400 //! Bereichsanfang,Bereichsende,Intensitaet
1401 x2= y2;
1402 y2= z;
1403 z2= y;
1404 }
1405 else
1406 {
1407 //! zuordnung normales Format
1408 //! motorpos,Intens.,sonderinfo(Monitorint. o. thetapos bei O2T-scan)
1409 x2= x;
1410 y2= y;
1411 z2= z;
1412 }
1413 sprintf( buf, fmt, x2, y2, z2 );
1414 fwrite( buf, strlen( buf ), 1, hFile );
1415 }
1416 //! nNumber sollte evtl. zur Fehlerbehandlung verwendet werden
1417 //! nicht von diffr.gruppe auskommentiert
1418 //! nNumber= fclose(hFile);
1419
1420 //! schliessen der Datei + setzen des alten Mauszeigers + schliessen der
1421 //! Kurve
1422 fclose( hFile );
1423 SetCursor( hOldCursor );
1424 // 07.05.2004 MainCurve->FastClose();
1425 //! variabl. setzen, um fenster ohne weitere Speicheranfrage verlassen zu
1426 //! koennen
1427 bFileChanged= FALSE;
1428 return TRUE;
1429 };
1430 //*****************************************************************************
1431
1432 //! haengt aktuelles tripel der Messkurve an Datei mit FileName an
1433 //! aufruf nur bei kontinuierlichem Speichern
1434 //! Rueckkehrcode False wenn fehler bei oeffnen der Datei sonst true
1435 BOOL TScanWindow::UpdateFile( void )
1436 {
1437 float x, y, z;
1438 char buf[ MaxString ];
1439 char fmt[ MaxString ];
1440 int hFile;
1441 OFSTRUCT of;
1442
1443 //! test ob neuer Dateiname (Fehler)
1444 if ( bIsNewFile )
1445 SaveFileAs();
1446 //! datei oeffnen + test auf fehler mit Fehlermeldung
1447 hFile= OpenFile( FileName, &of, OF_WRITE );
1448 if ( hFile==HFILE_ERROR )
1449 {
1450 MessageBox( szMsgLine109, szMsgFailureScan, MBINFO );
1451 return FALSE;
1452 }
1453 //! aktuelles tripel Messwerte (x,y,z) aus Kurve formatiert an datei
1454 //! anhaengen + datei schliessen
1455 MainCurve->PGet( x, y, z );
1456 sprintf( fmt, "%s %s %s\r\n", mGetSF(), "%.4f", "%.4f" );
1457 sprintf( buf, fmt, x, y, z );
1458 _llseek( hFile, 0, SEEK_END );
1459 _lwrite( hFile, ( LPSTR ) buf, strlen( buf ) );
1460 _lclose( hFile );
1461 return TRUE;
1462 };
1463 //*****************************************************************************
1464
1465 //! liest gespeicherte Kurve (.crv/.bk)
1466 //! Rueckkehrcode false wenn Fehler beim oeffnen der Datei, fehlerhaften
1467 //! Headerinfo. oder keine Eintraege nach[DATA] sonst true
1468 BOOL TScanWindow::LoadOldData()
1469 {
1470 //>>>
1471 const int LLength= 2500;
1472 char buf[ MaxString ];
1473 char buf2[ MaxString ];
1474 float x, y, z;
1475 int hFile, cnt;
1476 OFSTRUCT of;
1477 //! FIX Fehler 7
1478 BOOL bReady= FALSE;
1479
1480 //! ins Arbeitverzeichnis wechseln + 'Datei nachladen'-Dialog oeffnen + Dateinamen prüfen
1481 char Filter[]= "Curve Standard (*.crv)|*.crv|Compare Curve (*.bk)|*.bk|Curve Inquire Data (*.dtn)|*.dtn|";
1482 char NewFilename[ _MAX_PATH ];
1483 sprintf( NewFilename, "*.%s", szExtension );
1484 _chdir( szDataPath );
1485 if ( !FileOpenDialog( szMsgLine110, Filter, NewFilename, szDataPath) )
1486 return FALSE; // 'Abbruch' geklickt
1487 if ( strlen(NewFilename)==0 || strcmp(NewFilename, "*")==0 )
1488 return FALSE;
1489 char drv[ _MAX_DRIVE+1 ], dir[ _MAX_DIR+1 ], name[ _MAX_FNAME+1 ], ext[ _MAX_EXT+1 ];
1490 _splitpath( NewFilename, drv, dir, name, ext );
1491 if ( _stricmp(ext, ".CRV")!=0 && _stricmp(ext, ".BK")!=0 && _stricmp(ext, ".DTN")!=0 )
1492 return FALSE;
1493 strcpy( FileName, NewFilename);
1494 sprintf( szDataPath, "%s%s", drv, dir );
1495
1496 Steering.Reset();
1497 bLineScanStarted= FALSE; // für Steering.Reset() abschalten
1498 bInterrupted= FALSE;
1499
1500 //! setzt Wartemauszeiger
1501 HCURSOR hOldCursor= SetDefaultCursor( IDC_WAIT );
1502 //! laden der Headerinformation mit abbruch und Fehlermeldung bei Fehler
1503 TTxtRead Datei(FileName);
1504 if ( !LoadMeasurementInfo(Datei) )
1505 {
1506 SetCursor( hOldCursor );
1507 MessageBox( szMsgLine108, szMessageScan, MBINFO );
1508 return FALSE;
1509 }
1510 //! oeffnen dieser Datei zum lesen und Abbruch und Fehlermeldung falls nicht
1511 //! moeglich
1512 hFile= OpenFile( FileName, &of, OF_READ );
1513 if ( hFile==HFILE_ERROR )
1514 {
1515 SetCursor( hOldCursor );
1516 MessageBox( szMsgLine111, szMsgFailureScan, MBINFO );
1517 return FALSE;
1518 }
1519 //! Statuszeilenmeldung festlegen
1520 if (eScanType == stContinuousScan)
1521 strcpy(buf2, szMsgLine114);
1522 else
1523 strcpy(buf2, szMsgLine112);
1524 //! loeschen der aktuellen Kurve
1525 MainCurve->New();
1526
1527 // 07.05.2004 MainCurve->FastOpen();
1528 LPSTR lpBuf= new char [ LLength ];
1529 //! test ob Werte hinter [DATA] folgen
1530 if ( !SetFPOnData( hFile ) )
1531 return FALSE;
1532 //! zeilenweises einlesen und ablegen der Punkte in Kurve sowie Ausgabe der
1533 //! Anzahl der gelesenen tripel in 30er schritten bis Ende der Datei erreicht
1534 //! oder Zeile zu lang ?
1535 //! FIX Fehler 7
1536 for ( cnt= 0; !bReady; cnt++ )
1537 switch ( GetFileLine( hFile, lpBuf, LLength ) )
1538 {
1539 case R_Overflow:
1540 //! hier SetInfo eingebaut, damit korrekte Ausgabe der Anzahl der Punkte
1541 sprintf( buf, buf2, ++cnt );
1542 SetInfo( buf );
1543 bReady= TRUE;
1544 continue;
1545
1546 case R_EndOfFile:
1547 //! hier SetInfo eingebaut, damit korrekte Ausgabe der Anzahl der Punkte
1548 sprintf( buf, buf2, ++cnt );
1549 SetInfo( buf );
1550 bReady= TRUE;
1551 //Fehler? Kullmann+Reinecker: Fehlt hier vielleicht ein break?
1552
1553 default:
1554 if ( 3 != sscanf( lpBuf, "%f %f %f", &x, &y, &z ) )
1555 continue;
1556 if ( 0 == ( cnt % 30 ) )
1557 {
1558 sprintf( buf, buf2, cnt );
1559 SetInfo( buf );
1560 }
1561 //! zu zeichnene Kurve aus Datei erstellen (abhaengig von Scanart)
1562 if (eScanType == stContinuousScan)
1563 {
1564 //! intensitaeten ueber bereichsmitte abtragen
1565 x= (x + y) / 2;
1566 MainCurve->PAdd( x, z, y); // 07.05.2004 FastP...
1567 }
1568 else
1569 MainCurve->PAdd( x, y, z ); // 07.05.2004 FastP...
1570 }
1571
1572 //! setzen des norm. Mauszeigers + schliessen der akt. Kurve + setzen des
1573 //! x-Bereichs
1574 SetCursor( hOldCursor );
1575 //! eingefuegt fuer dtn File Achsenbeschriftung...
1576 //! im dtnFile ist Omega zu Anfang immer am kleinsten und steigt dann
1577 //! aber zugehoeriges Theta muss erst noch bestimmt werden...
1578 if (eLoadFormat == ffDtnFile)
1579 {
1580 float xtemp, ytemp, ztemp;
1581 MainCurve->SetPP();
1582 MainCurve->PGet(x, y, z); // 07.05.2004 FastP...
1583 MainCurve->SetPPLast();
1584 MainCurve->PGet(xtemp, ytemp, ztemp); // 07.05.2004 FastP...
1585 CoorSys.zMin= z;
1586 CoorSys.zMax= ztemp;
1587 }
1588
1589 // 07.05.2004 MainCurve->FastClose();
1590 //! bei kont. scan keine anpassung des koor.systems an position der kurve
1591 if ( eScanType != stContinuousScan)
1592 {
1593 dArgumentMin= MainCurve->GetMin( P_X );
1594 dArgumentMax= MainCurve->GetMax( P_X );
1595 }
1596 _FREELIST(lpBuf);
1597 //! variabl. setzen, um fenster ohne weitere Speicheranfrage verlassen zu
1598 //! koennen y-bereich neu festlegen + koord.system neu zeichnen
1599 bIsNewFile= FALSE;
1600 SetRanges();
1601 UpdateWnd();
1602 //! akt. Kurve wurde geladen (Fehler)
1603 bOldDataLoaded= TRUE;
1604 return TRUE;
1605 };
1606 //*****************************************************************************
1607
1608 //#############################################################################
1609 // Mausbedienung
1610 //#############################################################################
1611
1612 void TScanWindow::OnPopupMenuInit(WPARAM, LPARAM lParam)
1613 {
1614 if (eSaveFormat == ffDtnFile)
1615 EnableMenuItem(TheMenu, cm_SetupStepScan, MF_GRAYED);
1616 else
1617 EnableMenuItem(TheMenu, cm_SetupStepScan, MF_ENABLED);
1618 #ifndef ContinuousScanCapability
1620 #endif
1621
1622 //! dieses if eingefuegt, damit bei eingelesenem dtnfile keine Setupmenuaufruf moeglich
1623 if (eSaveFormat == ffDtnFile)
1624 {
1625 EnableMenuItem(TheMenu, cm_SetupStepScan, MF_GRAYED);
1626 EnableMenuItem(TheMenu, cm_InitializeScan, MF_GRAYED);
1627 EnableMenuItem(TheMenu, cm_FreezeCurve, MF_GRAYED);
1628 EnableMenuItem(TheMenu, cm_KillSecondCurve, MF_GRAYED);
1629 EnableMenuItem(TheMenu, cm_SaveSecondCurve, MF_GRAYED);
1630 }
1631 else
1632 {
1633 EnableMenuItem(TheMenu, cm_SetupStepScan, MF_ENABLED);
1634 //! abhaengig von eingestellter scanart menueeintrag fuer scanstart festlegen
1635 if (eScanType == stContinuousScan)
1636 ModifyMenu( TheMenu, cm_InitializeScan, MF_STRING | MF_BYCOMMAND, cm_InitializeScan,
1637 szMsgLine121 );
1638 else
1639 ModifyMenu( TheMenu, cm_InitializeScan, MF_STRING | MF_BYCOMMAND, cm_InitializeScan,
1640 szMsgLine122 );
1641 //! scanstart soll nur moeglich sein wenn keine Messung aktiv , akt. Messung
1642 //! unterbrochen , eine Einstellungsbox aufgerufen wurde
1643 //! FIX Fehler 77
1644 if ( ( bLineScanStarted && !bInterrupted ) || !bScanSetupOk )
1645 EnableMenuItem(TheMenu, cm_InitializeScan, MF_GRAYED);
1646 else
1647 EnableMenuItem(TheMenu, cm_InitializeScan, MF_ENABLED);
1648 //! neu fixscan
1649 if (1 > SecondCurve->GetPNumber())
1650 {
1651 EnableMenuItem( TheMenu, cm_FreezeCurve, MF_ENABLED );
1652 EnableMenuItem( TheMenu, cm_SaveSecondCurve, MF_GRAYED );
1653 EnableMenuItem( TheMenu, cm_KillSecondCurve, MF_GRAYED );
1654 //! ModifyMenu( TheMenu, 5, MF_STRING|MF_BYPOSITION,5,"Scan" );
1655 }
1656 else
1657 {
1658 EnableMenuItem( TheMenu, cm_FreezeCurve, MF_GRAYED );
1659 EnableMenuItem( TheMenu, cm_SaveSecondCurve, MF_ENABLED );
1660 EnableMenuItem( TheMenu, cm_KillSecondCurve, MF_ENABLED );
1661 //! ModifyMenu( TheMenu, 5, MF_STRING|MF_BYPOSITION,5,"fixierten Scan" );
1662 }
1663 }
1664 };
1665 /*2104.2004 //*****************************************************************************
1666
1667 //scheinbar ueberfluessig nur fuer TScan def. nicht geerbt
1668 BOOL TScanWindow::SaveDataBase( void )
1669 {
1670 return TRUE;
1671 };*/
1672