WORKFLOW.H

gehe zur Dokumentation dieser Datei

//---------------------------------------------------------------------------//
// WORKFLOW.H                                                                //
//                                                                           //
// Subsystem : Ablaufsteuerung  - Makroverarbeitung)                         //
// Benutung durch andere Subsysteme erforderlich: JA                         //
// Implementation: M_STEERG.CPP                                              //
//---------------------------------------------------------------------------//

#ifndef _WORKFLOW_H_
#define _WORKFLOW_H_

#include "detecuse\detecuse.h" // TDetector
//#include "datavisa\datavisa.h" // TPlotWindow
#include "workflow\Enums.h"


class TSteering
{
        friend class TCmd;
        //Datum: 28.07.2002 friend class TMacroExecuteDlg;
        //Datum: 28.07.2002 friend TIMECALLBACK RecallSteering;

// Konstruktoren und Destruktoren
public:

        TSteering ( void );

        virtual ~TSteering ( void );

private:

        TSteering ( TSteering& ) {}

        TSteering& operator= ( const TSteering& ) { return *this; }



// Makros aus Dateien laden
public:

        BOOL Initialize ( const HWND hwnd, const int mid, TDetector* d );

        BOOL LoadMacroByUser ( void );

// Kommando- und Makroverarbeitung vorbereiten
public:

        BOOL StartUp ( const HWND hwnd, const int mid, TDetector* d );

        void Visualising ( BOOL a, BOOL b );

// Kommando- und Makroverarbeitung starten
public:

        BOOL StartMacroExecution ( TMacroTag* macro, HWND hwnd );

        int StartCmdExecution ( ECmdId id, int p1, int p2, LPSTR p3, HWND );

// Kommando- und Makroverarbeitung pausieren/fortsetzen/stoppen
public:

        BOOL ToggleInterrupt ( void );

        BOOL Reset ( BOOL=TRUE );

// Schnittstelle zu anderen Subsystemen
public:

        BOOL DetectorRequest ( void );

        void WakeUp ( void );

// Makroliste bearbeiten: Makros auslesen, löschen und Makroanzahl ermitteln
public:

        TMacroTag *GetMacroById ( EMacroId id );

        TMacroTag *GetMacroByNumber ( int );
        
        TMacroTag *GetMacroByName ( LPSTR s );

        BOOL DeleteMacro ( TMacroTag* macro );

        int GetMacroCount ( void );

// POLLING zum Fortschritt der Makroverarbeitung
public:

        BOOL IsActive ( void );

        BOOL IsReset ( void );

        BOOL GetProgress ( int& ind, LPSTR s, int& n);

// Accessor- und Mutator-Methoden
public:

        BOOL IsPositionValid ( void );

        double GetDistance ( void );

        void SetStartPoint ( double p );
        
        double GetStartPoint ( void );

        float GetIntensity ( void );

        float GetSigma ( void );

        void SetNoiseLevel ( float nl );
        
        float GetNoiseLevel ( void );


        void SetNorm ( float norm );
        
        float GetNorm ( void );

        void SetResponse ( BOOL sr );
        
        BOOL IsResponding ( void );

        void SetHwb ( double hwb );
        
        double GetHwb ( void );


// private Methoden
private:

        // bestimmtes Makro aus einer Datei laden
        BOOL LoadMacro ( LPSTR, LPSTR );

        // das angebene Einzelkommando ausführen; am Ende NotifyCmdReady() aufrufen
        int StartCmdExecution ( TCmdTag );

        // führt das nächste Kommando der Makroverarbeitung ODER ruft NotifyCmdReady() oder NotifyMacroReady()
        BOOL ReadyReaction ( void );

        // führt das nächste Kommando der Makroverarbeitung aus; ggf. wird NotifyMacroReady() aufgerufen
        int ExecuteNextCmd ( void );

        // cm_SteeringReady an hHostWindow senden
        void NotifyCmdReady ( void ); // Einzelkommandoverarbeitung beendet
        void NotifyMacroReady ( void ); // Makroverarbeitung beendet

        // Kommandopausierung pausieren per Timer: Start, Stop
        BOOL StartTimer ( void );
        void StopTimer ( void );
        static void CALLBACK RecallSteering ( UINT, UINT, DWORD, DWORD, DWORD );

        // Meldung MessageBuffer in der Statuszeile oder einem Listenfeld (je nach Visualising-Aufruf) ausgeben
        void SendReport ( void );

        // parsen von Makrobezeichnung, Kommandobezeichnung und -parametern
        BOOL ParsingMacroId ( TMacroTag&, LPSTR );
        BOOL ParsingCmd ( TCmdTag&, LPSTR, LPSTR, LPSTR, LPSTR );
        static ECmdParam ParsingCmdParam ( LPSTR param );

        //Datum: 04.08.2002 BOOL  GetFileLine( FILE*, LPSTR, int );
        //Datum: 28.07.2002 HWND  GetControlWnd ( void );
        //Datum: 28.07.2002 int   TimerRequest ( void );
        //Datum: 28.07.2002 BOOL  IsMacroCalled ( void );
        //Datum: 28.07.2002 int   ReturnMacroCall ( void );
        //Datum: 28.07.2002 int   CallMacro ( TMacroTag* );

        //*****************************************************************************
        // PUBLIC ATTRIBUTS NUR für die von TCmd abgeleiteten Kommandos
public:
        // Info's über Antriebspositionen
        double dGoalDistance;
        double dPeakPoint;
        double dStartPoint;

        // Info's über Detektormessungen
        float fGoalIntensity;
        float fPeakIntensity;
        float fStartIntensity; // nur ein Lesezugriff

        // berechnete Werte
        double dCalcResult;
        double dCalcArg[nMaxArg];

public:
        // Verknüpfung auf einen Detektor für TScanCmd, TAreaScanCmd und TGotoPeakCmd
        TDetector *Monitor;

        //*****************************************************************************
        // PRIVATE ATTRIBUTS
private:
        // Liste der Makros
        TMacroTag aMacroList[_MAXMACROCOUNT]; //Datum: 28.07.2002 neu Kullmann+Reinecker
        int nMacroNumber;

        // derzeit bearbeitetes Makro mit der Liste der enthaltenen Kommandos und dem Index des aktuellen Kommandos
        TMacroTag *TheMacro;
        TCmdTag *TheCmdList;
        int nCmdIdx;

        // derzeit ausgeführtes [Einzel-]kommando
        TCmd *TheCmd;

        // Makro-/ Einzelkommandoverarbeitung pausiert oder beendet/ abgebrochen
        BOOL bInterrupted;
        BOOL bSteeringActive;
        BOOL bReset;

        // Handle zu dem Fenster mit dem Listenfeld (Ressourcen-Id id_Report), das bei cm_CounterSet DetectorRequest aufrufen muss
        HWND hControlWnd;
        // Handle zu dem Fenster, das über die Windowsbotschaft cm_SteeringReady benachrichtigt werden soll, wenn die Makroverarbeitung beendet ist
        HWND hHostWindow;

        // zur Meldungsausgabe
        BOOL bSendReport;
        char MessageBuffer[MaxString];
        HWND hReportList;

        // Handle auf den Timer, der die Kommandopausierung erlaubt; 0 <--> Timer ist inaktiv
        // darf nicht static sein, weil RecallSteering sonst auf einem anderen nEvent arbeitet als StartTimer und StopTimer - Compiler-/Linkerfehler?!
        UINT nEvent;

        // gibt an, wie lange [in Millisekunden] die Kommandoverarbeitung dauern soll
        static const UINT nAskTicks;

        // Index des ausgewählten Antriebs und ausgewählter Detektor
        int nMotor;
        TDetector *Detector;

        // Detektorinfo's die nur in TSteering benutzt werden
        float fIncomingIntensity;
        float fIntensityNorm;
        float fNoiseLevel;

        // berechnete(r) Wert(e)
        float fHWB;
        BOOL bInquireResult; // ! nur ein Lesezugriff

        // speichert Detektorparameter vor Pausieren der Makroverarbeitung, um diese beim Fortsetzen wiederherstel-len zu können
        TExposureSettings exposure;

        //##die vier folgenden Varablen werden im Programmablauf zwar belegt, dann aber nicht weiter benutzt
        //Datum: 28.07.2002 BOOL  b_id_Angle;
        //Datum: 28.07.2002 BOOL  b_id_PeakIntensity;
        //Datum: 28.07.2002 BOOL  b_id_Intensity;
        //Datum: 28.07.2002 BOOL  b_id_HalfWidth;

        //Datum: 28.07.2002 BOOL  b_id_Report;
        //Datum: 28.07.2002 BOOL  bTimerActive;
        //Datum: 28.07.2002 int   nFailureId;
};

//#############################################################################
// TMacroExecuteDlg
//#############################################################################

class TMacroExecuteDlg : public TModelessDlg
{
public:
        TMacroExecuteDlg( TModelessDlg** );
private:
        TMacroTag *TheMacro;
        TDetector *Detector;
        HWND hMacroList;
        BOOL Dlg_OnInit( HWND, HWND, LPARAM );
        void Dlg_OnCommand( HWND, int, HWND, UINT );
        BOOL CanClose( void );
        void LeaveDialog( void );
        int MessageLine;
        BOOL bInterrupted;
        BOOL bActionCaused;
        int SetupTask;
        BOOL bCheckMacro;
};

#endif //_WORKFLOW_H_

//#############################################################################
// LASTLINE
//#############################################################################

---