// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtsbst.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: gtsbst.h,v $
// Revision 1.2  2001/11/29 15:18:10  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

#ifndef _GTSBST_H
#define _GTSBST_H     1

#include "List.h"
#include "Strings.h"
#include "Angle.h"
#include "XGraph/GeoObj.h"
#include "gtsio.h"
#include "gtsglob.h"
#include "gtstbv.h"
#include "gtstmw.h"

class typBTPBasis
{
  public:
    typBTPBasis ();
    virtual ~typBTPBasis  ();
  protected:
}; // typBTPBasis

class typBSPBasis
{
  public:
    typBSPBasis ();
    virtual ~typBSPBasis  ();
  protected:
}; // typBTPLayout

class typBSPVariante0 : public typBSPBasis
{
  public:
    typBSPVariante0 ();
    typBSPVariante0 (InputFile& fin);
    typBSPVariante0 (const typBSPVariante0 *zBSP);
    Ustring getBTPWerte  ();
    void    setBTPWerte  (const typBSPVariante0 *zBTP);
    void    setBTPWerte  (Ustring str);
    void    BTPLesen     (InputFile& fin);
    void    BTPSchreiben (ostream& ostrm, typBaustein* zbst, int satznr);
    virtual ~typBSPVariante0 ();
  protected:
}; // typBSPVariante0

class typBSPVariante1 : public typBSPBasis
{
  public:
    typBSPVariante1      ();
    typBSPVariante1      (InputFile& fin);
    typBSPVariante1      (const typBSPVariante1 &copy);
    void operator =      (const typBSPVariante1 &copy);
    typBSPVariante1      (const typBSPVariante1 *zBSP);
    void    BSPLesen     (InputFile& fin);
    void    BSPSchreiben (ostream& ostrm, typBaustein* zbstein, int satznr);
    Ustring getBSPWerte  ();
    void    setBSPWerte  (Ustring str);
    void    setBSPWerte  (const typBSPVariante1 *zBSP);
    virtual ~typBSPVariante1 ();
  protected:
    int   Strategie;
    int   Prioritaet;
    float WartezeitSchwelle;
}; // typBSPVariante1

class typBSPVariante2 : public typBSPBasis
{
  public:
    typBSPVariante2     ();
    typBSPVariante2     (InputFile& fin);
    typBSPVariante2     (const typBSPVariante2 &copy);
    void operator =     (const typBSPVariante2 &copy);
    typBSPVariante2     (const typBSPVariante2 *zBSP);
    void BSPLesen       (InputFile& fin);
    void BSPSchreiben   (ostream& ostrm, typBaustein* zbstein, int satznr);
    Ustring getBSPWerte ();
    void    setBSPWerte (Ustring str);
    void    setBSPWerte (const typBSPVariante2 *zBSP);
    virtual ~typBSPVariante2  ();
  protected:
    int   Strategie;
    int   Prioritaet;
    float WartezeitSchwelle;
    int   DirektAvis;
    int   IndirektAvis;
}; // typBSPVariante2

// ########################################################################
// ########################################################################

extern class BstVariante *zTGB;

class typBaustein : public typVerkettung
{
  public:
    BstVariante  *zTGB;
    GeoObject    *zBstGraphik;

    typBaustein  ();
    typBaustein  (BstVariante *zaufTGB, int nr);
    typBaustein  (const typBaustein &copy, int nr);
    typBaustein  (InputFile& fin);
    typBaustein  (InputFile& fin, int nr, int btyp, int vtyp);
    virtual void VarianteErsetzen  (BstVariante *zaufTGB);
    virtual void BTPLesen     (InputFile& fin);
    virtual void BTPSchreiben (ostream& ostrm, int satznr);
    virtual void BSPLesen     (InputFile& fin);
    virtual void BSPSchreiben (ostream& ostrm, int satznr);
    virtual bool BPVLesen     (InputFile& fin);
    virtual void BPVSchreiben (ostream& ostrm,
                               typBaustein* zbstein, int& satznr);
    virtual void mitPoolVerketten (typBaustein* zvon, int vonplatz,
                                   typBaustein* zmit, int mitplatz,
                                   int unterwinkel);
    virtual void verkette (int vonplatz, typBaustein* zmit, int mitplatz, int unterwinkel);
    virtual void loeseVerkettungmitPool (typBaustein* zvon, typBaustein* zmit);
    virtual void loeseVerkettung        (typBaustein* zmit);
    virtual void InfoVerkettung  ();
    virtual void TFKErzeugenVonPoolZuPool     (typBaustein* zanfang, typBaustein* zende);
    virtual void TFKErzeugenVonBausteinZuPool (typBaustein* zanfang, typBaustein* zende);
    virtual void TFKErzeugenVonPoolZuBaustein (typBaustein* zanfang, typBaustein* zende);
    virtual bool TFKSuchenVonPoolZuPool     (typBaustein* zanfang, typBaustein* zende);
    virtual bool TFKSuchenVonBausteinZuPool (typBaustein* zanfang, typBaustein* zende);
    virtual bool TFKSuchenVonPoolZuBaustein (typBaustein* zanfang, typBaustein* zende);
    virtual void TFKZeigenVonPoolZuPool     (typBaustein* zanfang, typBaustein* zende);
    virtual void TFKZeigenVonBausteinZuPool (typBaustein* zanfang, typBaustein* zende);
    virtual void TFKZeigenVonPoolZuBaustein (typBaustein* zanfang, typBaustein* zende);
    virtual Ustring getPoolListe ();
    virtual Ustring getBetreuteListe ();
    virtual void setPoolListe (int anzahl, Ustring str);
    virtual void setBetreuteListe (int anzahl, Ustring str);
    virtual bool inPoolListe (int bstnr);
    virtual bool inBetreuteListe (int bstnr);
    virtual void BPVmitBausteinLoeschen (typBaustein* zbst);
    virtual Ustring getBTPWerte ();
    virtual void    setBTPWerte (Ustring str);
    virtual Ustring getBSPWerte ();
    virtual void    setBSPWerte (Ustring str);
    virtual Ustring getVBRWerte ();
    virtual void    setVBRWerte (Ustring str);

    void BausteinErsetzen (BstVariante *zaufTGB);
    void BMWLesen     (InputFile& fin);
    void BMWSchreiben (ostream& ostrm, int& satznr);
    Ustring getTMWWerte ();
    void    setTMWWerte (Ustring str);
    Ustring getALGWerte ();
    void    setALGWerte (Ustring str);

    void drehen (const Vec3D& rotPunkt, const Angle& diffwinkel);
    void BstnrNeuZeichnen();

    void GTS_CB (GeoObject *who, int button, int state, int x, int y);
    int  i_BstNr   ();
    void s_BstNr   (int bstnr);
    int  i_BstTyp  ();
    void s_BstTyp  (int btyp);
    int  i_VarTyp  ();
    void s_VarTyp  (int vtyp);
    double i_xKoor ();
    double i_yKoor ();
    double i_zKoor ();
    unsigned getPickbar();
    void     setPickbar (unsigned pickbar);
    Ustring getName();
    
    int  i_xWinkel  ();
    int  i_yWinkel  ();
    int  i_zWinkel  ();
    
    virtual ~typBaustein ();
  protected:
    Ustring  Name;
    unsigned Nr;
    unsigned BTyp;
    unsigned VTyp;
    //---Rudi---08.03.03---
    //Angle    Winkel;
    /**< Es folgen die Drehwinkel der Bausteine. Der erste Buchstabe gibt die Achse an.*/
    Angle xWinkel;
    Angle yWinkel;
    Angle zWinkel;
    
    //---Rudi---08.03.03---
    unsigned Pickbar;
    class BstTextInfo *zBstNr;
    class BstMesswert *zObjAuslGeschichte;
    class BstMesswert *zObjBelGeschichte;
    class BstMesswert *zObjStoerGeschichte;
  private:
}; // typBaustein

class typBausteinListe
{
  public:
     typBausteinListe     ();
     typBaustein *Letztes () { return BstListe.Last(); };
     int   Leer           ();
     void  EndeGliedern   (typBaustein &bst);
     int   FreieBstNummer ();
     typBaustein* Suche   (int nr);
     void  BstInListe     (typBaustein &zbst);
     void  BstAusListe    (typBaustein* zbst);
     unsigned BstAnzahl ();
     int   Sortieren      ();
     void  Loeschen       ();
     void  AllesAuswaehlen();
     bool  TGSLesen       (Ustring datname);
     void  TGSSchreiben   (Ustring datname);
     bool  TTPLesen       (Ustring datname);
     void  TTPSchreiben   (Ustring datname);
     bool  TMWLesen       (Ustring datname);
     void  TMWSchreiben   (Ustring datname);
     bool  TSTLesen       (Ustring datname);
     void  TSTSchreiben   (Ustring datname);
     bool  TBVLesen       (Ustring datname);
     void  TBVSchreiben   (Ustring datname);
     bool  TPVLesen       (Ustring datname);
     void  TPVSchreiben   (Ustring datname);
     Ustring getPoolBausteine     (typBaustein* zbst);
     Ustring getBetreuteBausteine (typBaustein* zbst);
     void BausteinImPoolLoeschen  (typBaustein* zbst);
     WrapBox getFlaeche ();
     void selectBausteine (WrapBox box, const unsigned art = 0, const bool shift = false);
    ~typBausteinListe  ();
  protected:
    List<typBaustein> BstListe;
  private:
    void BstSortieren (typBaustein* zende);
}; // typBausteinListe

class TMPBenoetigteBausteine
{
  public:
     TMPBenoetigteBausteine (Ustring datname);
     void TGSLesen ();
     void BstInListe    (typBaustein &zbst);
     bool BstAusTGBLesen();
    ~TMPBenoetigteBausteine  ();
  protected:
    List<typBaustein> BstListe;
    InputFile *file;
    SFXToken tok;
}; // TMPBenoetigteBausteine

#endif /* _GTSBST */
