// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtstlm.h,v $
// $Revision: 1.2 $
// $Author: baum $
// $Date: 2001/11/29 15:18:10 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name: Release-14 $
// State assigned to revision
// $State: Exp $
//
//
// $Log: gtstlm.h,v $
// Revision 1.2  2001/11/29 15:18:10  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

#ifndef _GTSTLM_H
#define _GTSTLM_H     1

#include "Strings.h"
#include "List.h"

#include "XGraph/Select.h"
#include "XGraph/Parent.h"
#include "XGraph/GeoObj.h"
#include "XGraph/Space.h"

#include "gtsbst.h"
#include "gtsvert.h"

extern class Arbeitsplan *apdummy;

//==================================================================
//		Definition
//		for abstract baseclass Prozesse
//==================================================================

class Prozess
{
  public:
    static Prozess* erzeugen (unsigned ptyp, unsigned betrifft);
    void setNr (unsigned nr)    { ObjNr = nr;   };
    unsigned int getTyp ()      { return ObjTyp; };
    unsigned int getNr  ()      { return ObjNr;  };
    unsigned int getLfdNr ()    { return ObjlfdNr; };
    void setLfdNr (unsigned nr) { ObjlfdNr = nr; };

    virtual void read    (InputFile& fin, unsigned nr) = 0;
    virtual void write   (ostream& ostrm) = 0;
    virtual typBaustein* AufBaustein    () { return NULL; };
    virtual Arbeitsplan* AufArbeitsplan () { return NULL; };
    virtual unsigned int getBetrifft () = 0;
    virtual unsigned int setBetrifft (unsigned nr) = 0;
    virtual Ustring      getProzess  (const unsigned art = 0) = 0;
    virtual void         setDefaultProzess (unsigned pnr) = 0;
    virtual Ustring      getAbstandVerteilung    ();
    virtual Ustring      setAbstandVerteilung    (Ustring str);
    virtual Ustring      setAbstandVerteilung    (unsigned vnr, Ustring str);
    virtual Ustring      getMengeDauerVerteilung ();
    virtual Ustring      setMengeDauerVerteilung (Ustring str);
    virtual Ustring      setMengeDauerVerteilung (unsigned vnr, Ustring str);
    virtual ~Prozess ();

  protected:
    Prozess  ();
    Prozess  (const Prozess& copy);
    void operator = (const Prozess& copy);

    unsigned  ObjTyp;
    unsigned  ObjlfdNr;
    unsigned  ObjNr;
    Verteilung *ObjAbstand;
    Verteilung *ObjMengeDauer;
};  // ENDE Prozess

//==================================================================
//		Definition
//		for class LastProzess
//==================================================================

class LastProzess : public Prozess {
  public:
    LastProzess  ();
    LastProzess  (Arbeitsplan *zbetrifft);
    LastProzess  (const LastProzess& copy);
    Arbeitsplan* AufArbeitsplan () { return zablaufplan; };
   ~LastProzess ();

    void operator = (const LastProzess& copy);

    virtual void read  (InputFile& fin, unsigned nr);
    virtual void write (ostream& ostrm);
    virtual Ustring getProzess (const unsigned art = 0);
    virtual void setDefaultProzess (unsigned pnr);
    virtual unsigned int getBetrifft ();
    virtual unsigned int setBetrifft (unsigned nr);

  protected:
  int dummy;
  Arbeitsplan *zablaufplan;
    
};  // ENDE LastProzess

//==================================================================
//		Definition
//		for class StoerProzess
//==================================================================

class StoerProzess : public Prozess {
  public:
    StoerProzess  ();
    StoerProzess  (typBaustein *zbetrifft);
    StoerProzess  (const StoerProzess& copy);
    virtual typBaustein* AufBaustein () { return zbst; };
   ~StoerProzess ();

    void operator = (const StoerProzess& copy);

    virtual void read  (InputFile& fin, unsigned nr);
    virtual void write (ostream& ostrm);
    virtual Ustring getProzess  (const unsigned art = 0);
    virtual void  setDefaultProzess  (unsigned pnr);
    virtual unsigned int getBetrifft () { return zbst->i_BstNr(); };
    virtual unsigned int setBetrifft (unsigned nr);

  protected:
    typBaustein *zbst;
    
};  // ENDE StoerProzess

//==================================================================
//		Definition
//		for class PrgProzess
//==================================================================

class PrgProzess : public Prozess {
  public:
    PrgProzess  ();
    PrgProzess  (typBaustein *zbetrifft);
    PrgProzess  (const PrgProzess& copy);
//    virtual typBaustein* AufBaustein () { return zbst; };
   ~PrgProzess ();

    void operator = (const PrgProzess& copy);

    virtual void read  (InputFile& fin, unsigned nr);
    virtual void write (ostream& ostrm);
    virtual Ustring getProzess  (const unsigned art = 0);
    virtual void  setDefaultProzess  (unsigned pnr);
    virtual unsigned int getBetrifft () { return ObjBetrifft; };
    virtual unsigned int setBetrifft (unsigned nr);

  protected:
    unsigned ObjBetrifft;
};  // ENDE PrgProzess

//==================================================================
//		Definition
//		for class PorzessVerwaltung
//==================================================================

class ProzessVerwaltung {
 public:
    ProzessVerwaltung () : ProzessListe() { };
    void TLMmitBausteinLoeschen    (typBaustein* zbstein);
    void TLMmitArbeitsplanLoeschen (Arbeitsplan* zaplan);
    Prozess* suche   (typBaustein* zbst);
    Prozess* suche   (unsigned int enr);
    Prozess *Letztes () { return ProzessListe.Last(); };
    Ustring erzeugen (unsigned pnr, unsigned ptyp, unsigned betrifft);
    void loeschen    (unsigned pnr);
    void loeschen    ();
    bool read        (Ustring datname);
    void write       (Ustring datname) const;
    Ustring Info ();
    Ustring setProzessnr  (unsigned altnr, unsigned neunr);
    Ustring setBetrifft   (unsigned pnr, unsigned ptyp, unsigned betrifft);
    Ustring getAbstandVerteilung (unsigned pnr);
    Ustring setAbstandVerteilung (unsigned pnr, unsigned vnr, Ustring str);
    Ustring getMengeDauerVerteilung (unsigned pnr);
    Ustring setMengeDauerVerteilung (unsigned pnr, unsigned vnr, Ustring str);
    Ustring Select (int pnr);
   ~ProzessVerwaltung ();

  protected:
    List<Prozess> ProzessListe;
    
    void ausgliedern (Prozess* Z) { ProzessListe.remove(*Z); };
    void eingliedern (Prozess &zprozess);
    void ersetzen (Prozess &zalt, Prozess &zneu);
}; // EreignisVerwaltung

#endif /* _GTSTLM */
