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

/*** Windows headers ***/
#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef WIN32_LEAN_AND_MEAN
//#include <winnt.h>
#endif /*WIN32*/

#include "gtsglob.h"
#include "gtsio.h"
#include "gtsgui.h"
#include "gtstgb.h"
#include "gtstas.h"
#include "gtstzt.h"
#include "gtstfk.h"
#include "gtsbst.h"
#include "gtsb00.h"
#include "gtsb01.h"
#include "gtsb02.h"
#include "gtsb03.h"
#include "gtsb04.h"
#include "gtsb05.h"
#include "gtsb06.h"
#include "gtsb07.h"
#include "gtsb08.h"
#include "gtsb09.h"
#include "gtsb10.h"
#include "gtsb12.h"
#include "gtsb14.h"
#include "gtsb15.h"
#include "gtsb16.h"
#include "gtsb17.h"
#include "gtsb18.h"
#include "gtsb19.h"
#include "gtsb20.h"
#include "gtsb23.h"
#include "gtsb24.h"
#include "gtsb25.h"
#include "gtsb26.h"
#include "gtsb28.h"
#include "gtsb29.h"
#include "gtsb30.h"
#include "gtsb31.h"
#include "gtsb32.h"
#include "gtsb33.h"
#include "gtsb34.h"
#include "gtsb35.h"
#include "gtsb36.h"
#include "gtsb37.h"
#include "gtsb38.h"
#include "gtsb39.h"

#include <time.h>

typBTPBasis::typBTPBasis ()
{ } // typBTPBasis

typBTPBasis::~typBTPBasis ()
{ } // ~typBTPBasis

typBSPBasis::typBSPBasis ()
{ } // typBSPBasis

typBSPBasis::~typBSPBasis ()
{ } // ~typBSPBasis

typBSPVariante0::typBSPVariante0 ()
{ } // typBSPVariante0

typBSPVariante0::typBSPVariante0 (InputFile& /*fin*/)
{ } // typBSPVariante0

typBSPVariante0::typBSPVariante0 (const typBSPVariante0* /*zBSP*/)
{ } // typBSPVariante0

typBSPVariante0::~typBSPVariante0 ()
 { } // ~typBSPVariante0

typBSPVariante1::typBSPVariante1 ()
 : Strategie (0), Prioritaet (0), WartezeitSchwelle (0.0)
{ } // typBSPVariante1

typBSPVariante1::~typBSPVariante1 ()
{ } // ~typBSPVariante1

typBSPVariante1::typBSPVariante1 (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin); tok.EndOfLine (fin);  // Zeile überlesen
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  Strategie = atoi(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  Prioritaet = atoi(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  WartezeitSchwelle = atof(tok());
  tok.EndOfLine (fin);
}; // typBSPVariante1

typBSPVariante1::typBSPVariante1 (const typBSPVariante1 &copy)
{
  *this = copy;
} // typBSPVariante1

void typBSPVariante1::operator =(const typBSPVariante1 &copy)
 {
  if (this == &copy) return;
  Strategie         = copy.Strategie;
  Prioritaet        = copy.Prioritaet;
  WartezeitSchwelle = copy.WartezeitSchwelle;
 } // operator =

typBSPVariante1::typBSPVariante1 (const typBSPVariante1 *zBSP)
{
  Strategie         = zBSP->Strategie;
  Prioritaet        = zBSP->Prioritaet;
  WartezeitSchwelle = zBSP->WartezeitSchwelle;
} // typBSPVariante1

void typBSPVariante1::BSPLesen (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin);  Strategie         = atoi(tok());
  tok.nextToken (fin);  Prioritaet        = atoi(tok());
  tok.nextToken (fin);  WartezeitSchwelle = atof(tok());
  tok.EndOfLine (fin);
}  // ENDE BSPLesen

void typBSPVariante1::BSPSchreiben (ostream& ostrm, typBaustein* zbstein, int satznr)
{
  Write (ostrm, "%4d ", satznr);
  Write (ostrm, "%4d ", zbstein->i_BstNr());
  Write (ostrm, "%4d ", Strategie);
  Write (ostrm, "%4d ", Prioritaet);
  Write (ostrm, "%10.5f ", WartezeitSchwelle);
  Write (ostrm, "%4d ", -1);
  Write (ostrm, "%4d ", -1);
  Write (ostrm, "     %s\n", zbstein->getName().str());
}  // ENDE BSPSchreiben

Ustring typBSPVariante1::getBSPWerte ()
{
  char tmp [512];
  sprintf(tmp, "%d\t%d\t%9.5f", Strategie, Prioritaet, WartezeitSchwelle);
  Ustring buf(tmp);
  return buf;
}  // ENDE getBSPWerte

void typBSPVariante1::setBSPWerte (Ustring str)
{
  sscanf((char*)str.str(), "%d %d %f",
                    &Strategie, &Prioritaet, &WartezeitSchwelle);
}  // ENDE setBSPWerte

void typBSPVariante1::setBSPWerte (const typBSPVariante1 *zBSP)
{
  Strategie         = zBSP->Strategie;
  Prioritaet        = zBSP->Prioritaet;
  WartezeitSchwelle = zBSP->WartezeitSchwelle;
}  // ENDE setBSP

typBSPVariante2::typBSPVariante2 ()
 : Strategie  (0), Prioritaet   (0), WartezeitSchwelle (0.0),
   DirektAvis (2), IndirektAvis (10)
{ } // typBSPVariante2

typBSPVariante2::~typBSPVariante2 ()
{ } // ~typBSPVariante2

typBSPVariante2::typBSPVariante2 (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin); tok.EndOfLine (fin);  // Zeile überlesen
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  Strategie = atoi(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  Prioritaet = atoi(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  WartezeitSchwelle = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  DirektAvis = atoi(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  IndirektAvis = atoi(tok());
  tok.EndOfLine (fin);
}; // typBSPVariante2

typBSPVariante2::typBSPVariante2 (const typBSPVariante2 *zBSP)
{
  Strategie         = zBSP->Strategie;
  Prioritaet        = zBSP->Prioritaet;
  WartezeitSchwelle = zBSP->WartezeitSchwelle;
  DirektAvis        = zBSP->DirektAvis;
  IndirektAvis      = zBSP->IndirektAvis;
} // typBSPVariante2

typBSPVariante2::typBSPVariante2 (const typBSPVariante2 &copy)
{
  *this = copy;
} // typBSPVariante2

 void typBSPVariante2::operator =(const typBSPVariante2 &copy)
 {
  if (this == &copy) return;
  Strategie         = copy.Strategie;
  Prioritaet        = copy.Prioritaet;
  WartezeitSchwelle = copy.WartezeitSchwelle;
  DirektAvis        = copy.DirektAvis;
  IndirektAvis      = copy.IndirektAvis;
 } // operator =

void typBSPVariante2::BSPLesen (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin);  Strategie         = atoi(tok());
  tok.nextToken (fin);  Prioritaet        = atoi(tok());
  tok.nextToken (fin);  WartezeitSchwelle = atof(tok());
  tok.nextToken (fin);  DirektAvis        = atoi(tok());
  tok.nextToken (fin);  IndirektAvis      = atoi(tok());
  tok.EndOfLine (fin);
}  // ENDE BSPLesen

void typBSPVariante2::BSPSchreiben (ostream& ostrm, typBaustein* zbstein, int satznr)
{
  Write (ostrm, "%4d ", satznr);
  Write (ostrm, "%4d ", zbstein->i_BstNr());
  Write (ostrm, "%4d ", Strategie);
  Write (ostrm, "%4d ", Prioritaet);
  Write (ostrm, "%10.5f ", WartezeitSchwelle);
  Write (ostrm, "%4d ", DirektAvis);
  Write (ostrm, "%4d ", IndirektAvis);
  Write (ostrm, "     %s\n", zbstein->getName().str());
}  // ENDE BSPSchreiben

Ustring typBSPVariante2::getBSPWerte ()
{
  char tmp [512];
  sprintf (tmp, "%d\t%d\t%9.5f\t%d\t%d",
          Strategie, Prioritaet, WartezeitSchwelle, DirektAvis, IndirektAvis);
  Ustring buf(tmp);
  return buf;
}  // ENDE getBSPWerte

void typBSPVariante2::setBSPWerte (Ustring str)
{
  sscanf ((char*)str.str(), "%d %d %f %d %d",
    &Strategie, &Prioritaet, &WartezeitSchwelle, &DirektAvis, &IndirektAvis);
}  // ENDE setBSPWerte

void typBSPVariante2::setBSPWerte (const typBSPVariante2 *zBSP)
{
  Strategie         = zBSP->Strategie;
  Prioritaet        = zBSP->Prioritaet;
  WartezeitSchwelle = zBSP->WartezeitSchwelle;
  DirektAvis        = zBSP->DirektAvis;
  IndirektAvis      = zBSP->IndirektAvis;
}  // ENDE setBSP

void typBaustein::GTS_CB (GeoObject* /*who*/, int /*button*/, int /*state*/, int /*x*/, int /*y*/)
{
   Msg.Warning ("typBaustein::GTS_CB()", "Callback: Baustein==>%s<", Name.str());
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBaustein::typBaustein ()
 : typVerkettung       (),
   zTGB                (NULL),   zBstGraphik         (NULL),
   Name                (),       Nr                  (0),
   BTyp                (0),      VTyp                (0),
   xWinkel             (0),      yWinkel             (0),
   zWinkel             (0),      Pickbar             (1),
   zBstNr              (NULL),   zObjAuslGeschichte  (NULL),
   zObjBelGeschichte   (NULL),   zObjStoerGeschichte (NULL)
{ }  // typBaustein

typBaustein::typBaustein (BstVariante *zaufTGB, int nr)
 : typVerkettung       (),
   zTGB                (zaufTGB),
   zBstGraphik         (new GeoObject()),
   Name                (zaufTGB->getName()),
   Nr                  (nr),
   BTyp                (zaufTGB->getTyp ()),
   VTyp                (zaufTGB->getVariante ()),
   xWinkel             (0),
   yWinkel             (0),
   zWinkel             (0),
   Pickbar             (1),
   zBstNr              (new BstTextInfo (zaufTGB->BstNrInfo ())),
   zObjAuslGeschichte  (new BstMesswert (1)),
   zObjBelGeschichte   (new BstMesswert (2)),
   zObjStoerGeschichte (new BstMesswert (5))
{
  GeoObject* geo = new GeoObject ();
  geo->copyContents (*(zTGB->MyGeometry ()));
  geo->setParent (*zBstGraphik);
  geo->setSelectionToMum ();

  zBstGraphik->setParent (*GTSSpace);

  zBstNr->setText (Ustring(Nr));
  zBstNr->show (*zBstGraphik);
  GTSMAP.insert (*this, *zBstGraphik);
}  // typBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBaustein::typBaustein (const typBaustein &copy, int nr)
 : typVerkettung       (),
   zTGB                (copy.zTGB),
   zBstGraphik         (new GeoObject()),
   Name                (copy.Name),
   Nr                  (nr),
   BTyp                (copy.BTyp),
   VTyp                (copy.VTyp),
   xWinkel             (copy.xWinkel),
   yWinkel             (copy.yWinkel),
   zWinkel             (copy.zWinkel),
   Pickbar             (1),
   zBstNr              (new BstTextInfo (*copy.zBstNr)),
   zObjAuslGeschichte  (new BstMesswert (*copy.zObjAuslGeschichte)),
   zObjBelGeschichte   (new BstMesswert (*copy.zObjBelGeschichte)),
   zObjStoerGeschichte (new BstMesswert (*copy.zObjStoerGeschichte))
{
  GeoObject* geo = new GeoObject ();
  geo->copyContents (*(zTGB->MyGeometry ()));
  geo->setParent (*zBstGraphik);
  geo->setSelectionToMum ();
  Vec3D AktPos = copy.zBstGraphik->Pos();
  int x = (int) ((AktPos.X() + GTSCB.getMoveStep()) / GTSCB.getMoveStep()) + 1;
  int y = (int) ((AktPos.Y() + GTSCB.getMoveStep()) / GTSCB.getMoveStep()) + 1;
  AktPos = Vec3D(x * GTSCB.getMoveStep(), y * GTSCB.getMoveStep(), 0.0);
  zBstGraphik->setPos (AktPos);
  zBstGraphik->move (geo->Pos ());
  zBstGraphik->rotate (EX, xWinkel);
  zBstGraphik->rotate (EY, yWinkel);
  zBstGraphik->rotate (EZ, zWinkel);
  zBstGraphik->setParent (*GTSSpace);

  zBstNr->setText (Ustring(Nr));
  zBstNr->show    (*zBstGraphik);
  GTSMAP.insert   (*this, *zBstGraphik);

  GTSSpace->flushAllViews();
}  // typBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// wo wird dieser constructor gebraucht und warum???????

typBaustein::typBaustein (InputFile& fin) : typVerkettung       (),
   zTGB                (NULL),
   zBstGraphik         (NULL),
   Name                (),
   Nr                  (0),
   BTyp                (0),
   VTyp                (0),
   xWinkel             (0),
   yWinkel             (0),
   zWinkel             (0),
   Pickbar             (1),
   zBstNr              (NULL),
   zObjAuslGeschichte  (NULL),
   zObjBelGeschichte   (NULL),
   zObjStoerGeschichte (NULL)
{
  SFXToken tok;
  unsigned AnzInfos;

  if ( ModellRelease == 0) {
     tok.nextToken (fin);     Nr   = atoi (tok ());
     tok.nextToken (fin);     BTyp = atoi (tok ());
     tok.nextToken (fin);     VTyp = atoi (tok ());
     tok.nextToken (fin);
     tok.nextToken (fin);
     tok.nextToken (fin);
     tok.nextToken (fin);     zWinkel = atoi (tok ());
     tok.nextToken (fin);     AnzInfos = atoi (tok ());
     tok.nextToken (fin);
     Name = tok();
     tok.EndOfLine (fin);
  } else {
     tok.nextToken (fin);     Nr   = atoi (tok ());
     tok.nextToken (fin);     BTyp = atoi (tok ());
     tok.nextToken (fin);     VTyp = atoi (tok ());
     tok.nextToken (fin);
     tok.nextToken (fin);
     tok.nextToken (fin);
     tok.nextToken (fin);     xWinkel = atoi (tok ());
     tok.nextToken (fin);     yWinkel = atoi (tok ());
     tok.nextToken (fin);     zWinkel = atoi (tok ());
     tok.nextToken (fin);     AnzInfos = atoi (tok ());
     tok.nextToken (fin);
     Name = tok();
     tok.EndOfLine (fin);
  }

  for (unsigned i = 0; i < AnzInfos; i++) {
    tok.nextToken (fin);
    tok.EndOfLine (fin);
  }
}  // typBaustein

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/**
 * Dieser Methode dient zusaetzlich zum Einlesen der Parameter im 2GS.
 *
 * @param fin Dateiname als InputFile
 * @param nr Bausteinnummer
 * @param btyp Bausteintypnummer
 * @param vtyp Variantennummer des Bausteintyps
 *
 */
typBaustein::typBaustein (InputFile& fin, int nr, int btyp, int vtyp) : typVerkettung       (),
   zTGB                (NULL),
   zBstGraphik         (NULL),
   Name                (),
   Nr                  (nr),
   BTyp                (btyp),
   VTyp                (vtyp),
   xWinkel             (0),
   yWinkel             (0),
   zWinkel             (0),
   Pickbar             (1),
   zBstNr              (NULL),
   zObjAuslGeschichte  (new BstMesswert (1)),
   zObjBelGeschichte   (new BstMesswert (2)),
   zObjStoerGeschichte (new BstMesswert (5)) {

/**< An diese Stelle muss abgefangen werden, ob die Revisionnr. des Modells
	vorhanden ist. Wenn vorhanden, dann sind die Spalten anders aufgeteilt.*/

  SFXToken tok;
  unsigned AnzInfos;
  Vec3D Pos;
  if ( ModellRelease == 0) {
    tok.nextToken (fin);       double x = atof(tok());
    tok.nextToken (fin);       double y = atof(tok());
    tok.nextToken (fin);       double z = atof(tok());
  	Pos = Vec3D (x,y,z);
  	tok.nextToken (fin);       zWinkel   = atoi(tok());
  	tok.nextToken (fin);       AnzInfos = atoi(tok());
    tok.nextToken (fin);       Name = tok();
    tok.EndOfLine (fin);
  } else {
  	tok.nextToken (fin);       double x = atof(tok());
    tok.nextToken (fin);       double y = atof(tok());
  	tok.nextToken (fin);       double z = atof(tok());
  	Pos = Vec3D (x,y,z);
  	tok.nextToken (fin);       xWinkel   = atoi(tok());
  	tok.nextToken (fin);       yWinkel   = atoi(tok());
  	tok.nextToken (fin);       zWinkel   = atoi(tok());
  	tok.nextToken (fin);       AnzInfos = atoi(tok());
  	tok.nextToken (fin);       Name = tok();
  	tok.EndOfLine (fin);
  }
  for (unsigned i = 0; i < AnzInfos; i++) {
    tok.nextToken (fin);
    tok.EndOfLine (fin);
  }
  zTGB = TgbBibliothek->SucheBaustein (BTyp, VTyp);
  if (zTGB) {
    zBstGraphik = new GeoObject();
    zBstGraphik->setPos (Pos);
    if (ModellRelease > 0) {
      zBstGraphik->rotate (EX, xWinkel);
      zBstGraphik->rotate (EY, yWinkel);
    }
    zBstGraphik->rotate (EZ, zWinkel);
    GeoObject* geo = new GeoObject ();
    geo->copyContents (*(zTGB->MyGeometry ()));
    geo->setParent (*zBstGraphik);
    geo->setSelectionToMum ();
    zBstGraphik->setParent (*GTSSpace);
    GTSMAP.insert (*this, *zBstGraphik);

    zBstNr = new BstTextInfo (zTGB->BstNrInfo ());
    zBstNr->setText (Ustring(Nr));
    zBstNr->show (*zBstGraphik);
  }
}  // typBaustein

void typBaustein::BausteinErsetzen (BstVariante *zaufTGB)
{
   zTGB = zaufTGB;
   Name = zaufTGB->getName();
   VTyp = zaufTGB->getVariante ();
   Vec3D Pos = zBstGraphik->Pos();
   GTSMAP.remove (*this);
   if (zBstGraphik != NULL) {
     zBstGraphik->deleteContents ();
     delete zBstGraphik;
   }

   zBstGraphik = new GeoObject();
   zBstGraphik->setPos (Pos);
   zBstGraphik->rotate (EX, xWinkel);
   zBstGraphik->rotate (EY, yWinkel);
   zBstGraphik->rotate (EZ, zWinkel);
   GeoObject* geo = new GeoObject ();
   geo->copyContents (*(zTGB->MyGeometry ()));
   geo->setParent (*zBstGraphik);
   geo->setSelectionToMum ();

   zBstGraphik->setParent (*GTSSpace);
   GTSMAP.insert (*this, *zBstGraphik);
   zBstNr = new BstTextInfo (zTGB->BstNrInfo ());
   zBstNr->setText (Ustring(Nr));
   zBstNr->show (*zBstGraphik);
   GTSSpace->MySelection()->removeAll();
   GTSSpace->flushAllViews();
}  // BausteinErsetzen

void typBaustein::VarianteErsetzen (BstVariante* /*zaufTGB*/)
{ }
void typBaustein::BTPLesen         (InputFile& /*fin*/)
{ }
void typBaustein::BTPSchreiben     (ostream& /*ostrm*/, int /*satznr*/)
{ }
void typBaustein::BSPLesen         (InputFile& /*fin*/)
{ }
void typBaustein::BSPSchreiben     (ostream& /*ostrm*/, int /*satznr*/)
{ }
bool typBaustein::BPVLesen         (InputFile& /*fin*/)
{ return false; }
void typBaustein::BPVSchreiben     (ostream& /*ostrm*/,
                                    typBaustein* /*zbstein*/, int& /*satznr*/)
{ }
void typBaustein::mitPoolVerketten (typBaustein* /*zvon*/, int /*vonplatz*/,
                                    typBaustein* /*zmit*/, int /*mitplatz*/,
                                    int /*unterwinkel*/)
{ }
void typBaustein::loeseVerkettungmitPool       (typBaustein* /*zvon*/,
                                                typBaustein* /*zmit*/)
{ }
void typBaustein::TFKErzeugenVonPoolZuPool     (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{ }
void typBaustein::TFKErzeugenVonBausteinZuPool (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{ }
void typBaustein::TFKErzeugenVonPoolZuBaustein (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{ }
bool typBaustein::TFKSuchenVonPoolZuPool       (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{return false;}
bool typBaustein::TFKSuchenVonBausteinZuPool   (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{return false;}
bool typBaustein::TFKSuchenVonPoolZuBaustein   (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{return false;}
void typBaustein::TFKZeigenVonPoolZuPool       (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{ }
void typBaustein::TFKZeigenVonBausteinZuPool   (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{ }
void typBaustein::TFKZeigenVonPoolZuBaustein   (typBaustein* /*zanfang*/,
                                                typBaustein* /*zende*/)
{ }
Ustring typBaustein::getPoolListe              ()
{ Ustring ret; return ret; }
Ustring typBaustein::getBetreuteListe          ()
{ Ustring ret; return ret; }
void typBaustein::setPoolListe                 (int /*anzahl*/, Ustring /*str*/)
{ }
void typBaustein::setBetreuteListe             (int /*anzahl*/, Ustring /*str*/)
{ }
bool typBaustein::inPoolListe                  (int /*bstnr*/)
{ return false; }
bool typBaustein::inBetreuteListe              (int /*bstnr*/)
{ return false; }
void typBaustein::BPVmitBausteinLoeschen       (typBaustein* /*zbst*/)
{ }
Ustring typBaustein::getBTPWerte ()
{ Ustring ret; return ret; }
void    typBaustein::setBTPWerte (Ustring str)
{ }
Ustring typBaustein::getBSPWerte ()
{ Ustring ret; return ret; }
void    typBaustein::setBSPWerte (Ustring str)
{ }
Ustring typBaustein::getVBRWerte ()
{ Ustring ret; return ret; }
void    typBaustein::setVBRWerte (Ustring str)
{ }
int      typBaustein::i_BstNr  ()          { return Nr;   }
void     typBaustein::s_BstNr  (int bstnr) { Nr = bstnr;  }
int      typBaustein::i_BstTyp ()          { return BTyp; }
void     typBaustein::s_BstTyp (int btyp)  { BTyp = btyp; }
int      typBaustein::i_VarTyp ()          { return VTyp; }
void     typBaustein::s_VarTyp (int vtyp)  { VTyp = vtyp; }
double   typBaustein::i_xKoor ()           { return (zBstGraphik->Pos()).X(); }
double   typBaustein::i_yKoor ()           { return (zBstGraphik->Pos()).Y(); }
double   typBaustein::i_zKoor ()           { return (zBstGraphik->Pos()).Z(); }
Ustring  typBaustein::getName()            { return Name; }
int      typBaustein::i_xWinkel ()          { return (int) xWinkel.deg (); }
int      typBaustein::i_yWinkel ()          { return (int) yWinkel.deg (); }
int      typBaustein::i_zWinkel ()          { return (int) zWinkel.deg (); }
unsigned typBaustein::getPickbar()         { return Pickbar; };
void     typBaustein::setPickbar(unsigned pickbar) { Pickbar = pickbar; };
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::drehen (const Vec3D& rotPunkt, const Angle& diffwinkel)
{
  Vec3D v (zBstGraphik->Pos()- rotPunkt);
  v *= ZrotHMatrx3D (diffwinkel);
  zBstGraphik->rotate (EZ, diffwinkel, 0);
  zBstGraphik->setPos (rotPunkt + v, 0);
  zWinkel += diffwinkel;
  zWinkel += diffwinkel;
  zWinkel += diffwinkel;
  if (zWinkel == Angle (360)) zWinkel = Angle (0);
  else
    if (zWinkel < Angle (0)) zWinkel += Angle (360);
}  // ENDE drehen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::verkette (int vonplatz, typBaustein* zmit, int mitplatz, int unterwinkel)
{
  int btyp = zmit->i_BstTyp();
  if ((btyp == tFtsVerwalter)    || (btyp == tRegalverwalter) ||
      (btyp == tNcPoolverwalter) || (btyp == tKomVerwalter))
    zmit->mitPoolVerketten (this, vonplatz, zmit, mitplatz, unterwinkel);
    else
    typVerkettung::BstVerketten (vonplatz, zmit, mitplatz, unterwinkel);
} // ENDE verkette

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::loeseVerkettung (typBaustein* zmit)
{
  int btyp = zmit->i_BstTyp();
  if ((btyp == tFtsVerwalter)    || (btyp == tRegalverwalter) ||
      (btyp == tNcPoolverwalter) || (btyp == tKomVerwalter))
    zmit->loeseVerkettungmitPool (this, zmit);
    else
    typVerkettung::BstLoeseVerkettung (zmit);
} // ENDE loeseVerkettung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::InfoVerkettung ()
{
  typVerkettung::InfoVerkettung();
} // ENDE InfoVerkettung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::BstnrNeuZeichnen()
{
  zBstNr->setText (Ustring(Nr));
  zBstNr->show (*zBstGraphik);
}  // ENDE BstnrNeuZeichnen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::BMWLesen (InputFile& fin)
{
  BstMesswert* zmw = new (BstMesswert);
  zmw->readMW (fin);

  switch (zmw->getRegistrierung())
  {
    case 1 : zObjAuslGeschichte->operator  = (*zmw); break;
    case 2 : zObjBelGeschichte->operator   = (*zmw); break;
    case 5 : zObjStoerGeschichte->operator = (*zmw); break;
    default : if (zmw->getRegistrierung())
                  Msg.Warning ("BTWLesen",
                           "Messwerterfassungsart %d ist nicht implementiert",
                           zmw->getRegistrierung());
  }
  delete zmw;
}  // BMWLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::BMWSchreiben (ostream& ostrm, int& satznr)
{
  if (zObjAuslGeschichte->getMesswert())
  {
    satznr++;
    Write (ostrm, "%4d %4d %5d %5d ", satznr, 10, i_BstNr(), i_BstTyp());
    Write (ostrm, "               1 ");
    zObjAuslGeschichte->writeMW (ostrm);
  }
  if (zObjBelGeschichte->getMesswert())
  {
    satznr++;
    Write (ostrm, "%4d %4d %5d %5d ", satznr, 10, i_BstNr(), i_BstTyp());
    Write (ostrm, "               1 ");
    zObjBelGeschichte->writeMW (ostrm);
  }
  if (zObjStoerGeschichte->getMesswert())
  {
    satznr++;
    Write (ostrm, "%4d %4d %5d %5d ", satznr, 10, i_BstNr(), i_BstTyp());
    Write (ostrm, "               1 ");
    zObjStoerGeschichte->writeMW (ostrm);
  }
}  // BMWSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring typBaustein::getTMWWerte()
{
  char tmp [512];
  sprintf (tmp, "%d\t%d\t%d",
           zObjAuslGeschichte->getMesswert(),
           zObjBelGeschichte->getMesswert(),
           zObjStoerGeschichte->getMesswert());
  return Ustring(tmp);
}  // getTMWWerte

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::setTMWWerte (Ustring str)
{
  unsigned ausl, bel, stoer;
  sscanf ((char*)str.str(), "%d %d %d", &ausl, &bel, &stoer);
  zObjAuslGeschichte->setMesswert  (ausl);
  zObjBelGeschichte->setMesswert   (bel);
  zObjStoerGeschichte->setMesswert (stoer);
}  // setTMWWerte

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring typBaustein::getALGWerte()
{
  char tmp [512];
  Vec3D AktPos = zBstGraphik->Pos();
  sprintf (tmp, "{%s}\t%9.3f\t%9.3f\t%9.3f\t%d\t%d\t%d\t%d",
            (char*)Name.str(), AktPos.X(), AktPos.Y(),AktPos.Z(),
            this->i_xWinkel(), this->i_yWinkel(), this->i_zWinkel(), this->getPickbar());
  Ustring buf(tmp);
  return buf;
}  // getALGWerte

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBaustein::setALGWerte (Ustring str)
{
  float x, y, z;
  unsigned a = 9999;
  unsigned e = 9999;
  unsigned i;
  //int neuWinkel;
  int neuXWinkel;
  int neuYWinkel;
  int neuZWinkel;

  for (i=0; i<str.len(); i++)
  {
    if (str[i] == '{') a = i;
    if (str[i] == '}') e = i;
  }
  if (!(a == 9999) && !(e == 9999))
  {
    Name = str.getPart (a + 1, e - a - 1);
    str.delPart (a, e - a + 1);
    sscanf ((char*)str.str(), "%f %f %f %d %d %d %d",
                   &x, &y, &z, &neuXWinkel, &neuYWinkel, &neuZWinkel, &Pickbar);
  } else
  {
    char tmp [512];
    sscanf ((char*)str.str(), "%s %f %f %f %d %d %d %d",
                   tmp, &x, &y, &z, &neuXWinkel, &neuYWinkel, &neuZWinkel, &Pickbar);
    Name = tmp;
  }
  if (Pickbar)
    zBstGraphik->setSelectionToMe ();
  else
    zBstGraphik->setSelectionToNothing ();

  zBstGraphik->setPos (Vec3D(x, y, z));
  zBstGraphik->rotate (EX, Angle(neuXWinkel) - xWinkel);
  zBstGraphik->rotate (EY, Angle(neuYWinkel) - yWinkel);
  zBstGraphik->rotate (EZ, Angle(neuZWinkel) - zWinkel);
  xWinkel = Angle (neuXWinkel);
  yWinkel = Angle (neuYWinkel);
  zWinkel = Angle (neuZWinkel);
  GTSSpace->flushAllViews();
}  // setALGWerte

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBaustein::~typBaustein ()
{
    if (zTGB   != NULL) zTGB = NULL;
    if (zBstNr != NULL) delete zBstNr;
    if (zObjAuslGeschichte  != NULL) delete zObjAuslGeschichte;
    if (zObjBelGeschichte   != NULL) delete zObjBelGeschichte;
    if (zObjStoerGeschichte != NULL) delete zObjStoerGeschichte;
    GTSMAP.remove (*this);
    if (zBstGraphik != NULL) {
      zBstGraphik->deleteContents ();
      delete zBstGraphik;
    }
    FahrkursListe->TFKmitBausteinLoeschen    (this);
    EreignisListe->TZTmitBausteinLoeschen    (this);
    ProzessListe->TLMmitBausteinLoeschen     (this);
    ArbeitsplanListe->TASmitBausteinLoeschen (this);
    BausteinListe->BausteinImPoolLoeschen    (this);
}  // typBaustein



// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBausteinListe::typBausteinListe (): BstListe()
{ } // typBausteinListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int typBausteinListe::Leer()
{
  return BstListe.isEmpty();
} // Leer

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::EndeGliedern (typBaustein &bst)
{
  BstListe.append(bst);
} // EndeGliedern

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int typBausteinListe::FreieBstNummer ()
{
  int Nr = KLEINSTEBSTNR;
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
    if (zhilfe()->i_BstNr() >= KLEINSTEBSTNR) break;

  if (zhilfe != NULL)
  {
    if (zhilfe()->i_BstNr() > KLEINSTEBSTNR) return KLEINSTEBSTNR;

    for (; zhilfe; zhilfe++, Nr++)
      if (zhilfe()->i_BstNr() > Nr) break;
    return Nr;
  }
  else return KLEINSTEBSTNR;
}  // FreieBstNummer

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBaustein* typBausteinListe::Suche (int nr)
{
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
     if (zhilfe()->i_BstNr() == nr) return zhilfe();
  return NULL;
}  // ENDE Suche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::BstInListe (typBaustein &zbst)
{
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
     if (zhilfe()->i_BstNr() >= zbst.i_BstNr()) break;

   if (zhilfe != NULL)
   {
     if (zhilfe()->i_BstNr() > zbst.i_BstNr())
     BstListe.prepend (zbst, zhilfe);
     else
     BstListe.append (zbst, zhilfe);
   }
   else BstListe.append (zbst);
}  // BstInListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::BstAusListe (typBaustein* zbst)
{
   BstListe.remove (*zbst);
}  // BstAusListe

unsigned typBausteinListe::BstAnzahl () {
   return BstListe.Count();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::BstSortieren (typBaustein* zende)
{
  LCursor<typBaustein> zhilfe1, zhilfe2;
  zhilfe1 = BstListe;
  zhilfe2 = zhilfe1;

  for (zhilfe2++; (zhilfe2()!=zende); zhilfe2++)
  {
    if(zhilfe2()->i_yKoor() > zhilfe1()->i_yKoor())
      zhilfe1 = zhilfe2;
    else
      if(zhilfe2()->i_yKoor() == zhilfe1()->i_yKoor())
        if(zhilfe2()->i_xKoor() < zhilfe1()->i_xKoor())
          zhilfe1 = zhilfe2;
  }
  typBaustein* zhilfe = zhilfe1();
  BstListe.remove(*zhilfe);
  BstListe.append(*zhilfe);
}  // ENDE BstSortieren

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int typBausteinListe::Sortieren ()
{
  if (BstListe.isEmpty()) return 0;
  BstSortieren (NULL);
  typBaustein* zende = BstListe.Last();
  while (zende != BstListe.First()) BstSortieren (zende);

  int bstnr = 0;
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
  {
    bstnr++;
    zhilfe()->s_BstNr(bstnr);
    zhilfe()->BstnrNeuZeichnen();
  }

  Pattern::clean();
  GTSSpace->flushAllViews();
  return 1;

/* #################################################################
procedure sortiereBausteinListe;

. . . . .

        if not leer (fahrkursliste) then
           listesortieren (fahrkursliste, artzeiger);
        with messwertverwaltung do
        begin
          if not leer (mwBausteinListe) then
             listesortieren (mwBausteinListe, artmwerfassung);
          if not leer (mwavisliste) then
             listesortieren (mwavisliste, artmwerfassung);
        end;
        ffsgelesen := false;
      end else writeinfo (16, 0, 0, 0, 0, 0, 0, 0, 0, 'I');
end (* sortiereBausteinListe *);

*/
}  // Sortieren

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::AllesAuswaehlen ()
{
  GTSSpace->MySelection()->removeAll();
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
      GTSSpace->MySelection()->insert (*(GTSMAP.find (*(zhilfe()))));
  GTSSpace->flushAllViews();
}  // AllesAuswaehlen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::Loeschen ()
{
  while (!BstListe.isEmpty()) delete BstListe.removeFirst();
}  // Loeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typBausteinListe::TGSLesen (Ustring datname)
{
  int satznr = 2;
  unsigned nr, btyp, vtyp;
  InputFile *fin;
  SFXToken tok;

  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TGSLesen()",
               "Satznr.= %d in TGS-Datei nicht vorhanden", satznr);

  tok.nextToken (*fin);  // Anzahl Bausteine ueberlesen
  tok.nextToken (*fin);  // ObjPalRaster    = atoi (tok());
  tok.nextToken (*fin);  // ObjVersionsNr   = atof (tok());
  tok.EndOfLine (*fin);

  satznr = 3;
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TGSLesen()",
               "Satznr.= %d in TGS-Datei nicht vorhanden", satznr);
  tok.nextToken (*fin);  // ObjBstSkalierung = atoi (tok());
  tok.nextToken (*fin);  // ObjPalRaster     = atoi (tok());
  tok.EndOfLine (*fin);

  typBaustein *zbst;
  while(satznr != -999)
  {
    tok.nextToken (*fin);   satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);   nr   = atoi (tok());
      tok.nextToken (*fin);   btyp = atoi (tok());
      tok.nextToken (*fin);   vtyp = atoi (tok());
      nr  += LASTBSTNR;
      zbst = NULL;
      switch (btyp)
      {
        case tLayout               : zbst = new typBSTLayout               (*fin, nr, btyp, vtyp); break;
        case tQuelle               : zbst = new typBSTQuelle               (*fin, nr, btyp, vtyp); break;
        case tSenke                : zbst = new typBSTSenke                (*fin, nr, btyp, vtyp); break;
        case tLinearStaufoerderer  : zbst = new typBSTStaufoerderer        (*fin, nr, btyp, vtyp); break;
        case tWeiche               : zbst = new typBSTWeiche               (*fin, nr, btyp, vtyp); break;
        case tVWagen               : zbst = new typBSTVWagen               (*fin, nr, btyp, vtyp); break;
        case tGasse                : zbst = new typBSTGasse                (*fin, nr, btyp, vtyp); break;
        case tMaschine             : zbst = new typBSTMaschine             (*fin, nr, btyp, vtyp); break;
        case tDrehpuffer           : zbst = new typBSTDrehpuffer           (*fin, nr, btyp, vtyp); break;
        case tMehrfachLader        : zbst = new typBSTMehrfachLader        (*fin, nr, btyp, vtyp); break;
        case tLaufkran             : zbst = new typBSTLaufkran             (*fin, nr, btyp, vtyp); break;
        case tAbstrakteRegaleinheit: zbst = new typBSTAbstrakteRegaleinheit(*fin, nr, btyp, vtyp); break;
        case tRechtsKurveStaufoerderer : zbst = new typBSTRechtsKurveStaufoerderer(*fin, nr, btyp, vtyp); break;
        case tLinksKurveStaufoerderer  : zbst = new typBSTLinksKurveStaufoerderer (*fin, nr, btyp, vtyp); break;
        case tSammler              : zbst = new typBSTSammler              (*fin, nr, btyp, vtyp); break;
        case tVereinzeler          : zbst = new typBSTVereinzeler          (*fin, nr, btyp, vtyp); break;
        case tRegaleinheit         : zbst = new typBSTRegaleinheit         (*fin, nr, btyp, vtyp); break;
        case tRegalverwalter       : zbst = new typBSTRegalverwalter       (*fin, nr, btyp, vtyp); break;
        case tNcPoolverwalter      : zbst = new typBSTNcPoolverwalter      (*fin, nr, btyp, vtyp); break;
        case tKettenfoerderer      : zbst = new typBSTKettenfoerderer      (*fin, nr, btyp, vtyp); break;
        case tQuerfoerderer        : zbst = new typBSTQuerfoerderer        (*fin, nr, btyp, vtyp); break;
        case tKommissionierer      : zbst = new typBSTKommissionierer      (*fin, nr, btyp, vtyp); break;
        case tKomVerwalter         : zbst = new typBSTKomVerwalter         (*fin, nr, btyp, vtyp); break;
        case tFtsLadepool          : zbst = new typBSTFtsLadepool          (*fin, nr, btyp, vtyp); break;
        case tFtsLadeplatz         : zbst = new typBSTFtsLadeplatz         (*fin, nr, btyp, vtyp); break;
        case tFtsVerwalter         : zbst = new typBSTFtsVerwalter         (*fin, nr, btyp, vtyp); break;
        case tFtsWagen             : zbst = new typBSTFtsWagen             (*fin, nr, btyp, vtyp); break;
        case tFtsEinbahnstrecke    : zbst = new typBSTFtsEinbahnstrecke    (*fin, nr, btyp, vtyp); break;
        case tFtsZweibahnstrecke   : zbst = new typBSTFtsZweibahnstrecke   (*fin, nr, btyp, vtyp); break;
        case tFtsKurve             : zbst = new typBSTFtsKurve             (*fin, nr, btyp, vtyp); break;
        case tFtsAbzweigung        : zbst = new typBSTFtsAbzweigung        (*fin, nr, btyp, vtyp); break;
        case tFtsKreuzung          : zbst = new typBSTFtsKreuzung          (*fin, nr, btyp, vtyp); break;
        case tFtsEinbahnMitInhalt  : zbst = new typBSTFtsEinbahnMitInhalt  (*fin, nr, btyp, vtyp); break;
        case tFtsZweibahnMitInhalt : zbst = new typBSTFtsZweibahnMitInhalt (*fin, nr, btyp, vtyp); break;
        case tFtsEndstrecke        : zbst = new typBSTFtsEndstrecke        (*fin, nr, btyp, vtyp); break;
        default : tok.nextToken (*fin);
                  tok.nextToken (*fin);
                  tok.nextToken (*fin);
                  tok.nextToken (*fin);
                  tok.nextToken (*fin);
                  tok.nextToken (*fin);
                  tok.nextToken (*fin);  unsigned AnzInfos = atoi (tok ());
                  tok.nextToken (*fin);
                  tok.EndOfLine (*fin);
                  for (unsigned i = 0; i < AnzInfos; i++)
                  {
                    tok.nextToken (*fin);
                    tok.EndOfLine (*fin);
                  }
                  Msg.Error ("typBausteinListe::TGSLesen()",
                  "In Satz= %d: Bstnr.=%d, Typ=%d, Variante=%d nicht gefunden",
                   satznr, nr, btyp, vtyp);
                  break;
      } // ENDE switch
      if (zbst) EndeGliedern (*zbst);
    }
    else
    tok.EndOfLine (*fin);
  }
  MainViewHandler->poseView(); // reset the View!!!
  fin->close();
  delete fin;
  return true;
} // TGSLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::TGSSchreiben (Ustring datname)
{
   LCursor<typBaustein> zhilfe;
   ofstream fout (datname.str ());
   DateiKopfSchreiben (fout, "2GS");
   Write (fout, "%4d  %4u\n", 2, BstAnzahl());
   Write (fout, "%d\n", -1);
   Write (fout, "%s\n", "-1 SatzNr  BstSkal  TERaster");
   Write (fout, "%4d       7        50\n", 3);
   Write (fout, "%d\n", -1);
   Write (fout, "%s\n",
          "-1 SatzNr  BstTyp                                    Y-Winkel   AnzInfo");
   Write (fout, "%s\n",
          "-1    BstNr    BstVar   X         Y         Z    X-Winkel   Z-Winkel   BstBenennung");
   Write (fout, "%s\n",
          "-1     stat/dyn  Art   Groesse    X-Pos     Y-Pos   InfoText");
   Write (fout, "%d\n", -1);

   Vec3D AktPos;
   int satznr = 3;
   for (zhilfe = BstListe; zhilfe; zhilfe++)
   {
     satznr++;
     Write (fout, "%4d ", satznr);
     Write (fout, "%4d ", zhilfe()->i_BstNr());
     Write (fout, "%4d ", zhilfe()->i_BstTyp());
     Write (fout, "%4d ", zhilfe()->i_VarTyp());
     AktPos = zhilfe()->zBstGraphik->Pos();
     Write (fout, "%9.3f ", AktPos.X());
     Write (fout, "%9.3f ", AktPos.Y());
     Write (fout, "%9.3f ", AktPos.Z());
     Write (fout, "%4d ", zhilfe()->i_xWinkel());
     Write (fout, "%4d ", zhilfe()->i_yWinkel());
     Write (fout, "%4d ", zhilfe()->i_zWinkel());
     Write (fout, "   0");
     Write (fout, "  %s\n", zhilfe()->getName().str());
   }
   DateiFussSchreiben (fout, "2GS");
   fout.close ();
} // TGSSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typBausteinListe::TTPLesen (Ustring datname)
{
  int  satznr = 2;
  bool OK     = true;
  SFXToken tok;
  InputFile *fin;
  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TTPLesen()",
               "Satznr.= %d in TTP-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*fin);

  int bstnr;
  typBaustein *zbst;
  while((OK) && (satznr != -999))
  {
    tok.nextToken (*fin);   satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);   bstnr = atoi (tok());
      tok.nextToken (*fin);   // BstTyp ueberlesen
      zbst = BausteinListe->Suche (bstnr+LASTBSTNR);
      if (zbst)
        zbst->BTPLesen (*fin);
      else
      {
        OK = false;
        Meld.Ausgabe(9, bstnr+LASTBSTNR);
        tok.EndOfLine (*fin);
      }
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE TTPLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::TTPSchreiben (Ustring datname)
{
  int satznr = 2;
  LCursor<typBaustein> zhilfe;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TTP");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1 SatzNr");
  Write (fout, "%s\n", "-1     BstNr  BstTyp");
  Write (fout, "%d\n", -1);

  for (zhilfe = BstListe; zhilfe; zhilfe++)
  {
    satznr++;
    zhilfe()->BTPSchreiben (fout, satznr);
  }
  DateiFussSchreiben (fout, "TTP");
  fout.close ();
} // TTPSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typBausteinListe::TMWLesen (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  SFXToken tok;
  InputFile *fin;
  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TMWLesen()",
               "Satznr.= %d in TMW-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*fin);
  int nr, code;
  typBaustein *zbst;
  while((OK) && (satznr != -999))
  {
    tok.nextToken (*fin);   satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);   code = atoi (tok());
      if (code == 10)
      {
        tok.nextToken (*fin);   nr = atoi (tok());
        tok.nextToken (*fin);   // BstTyp ueberlesen
        zbst  = BausteinListe->Suche (nr+LASTBSTNR);
        if (zbst) zbst->BMWLesen (*fin);
        else
        {
          OK = false;
          Meld.Ausgabe(9, nr+LASTBSTNR);
          tok.EndOfLine (*fin);
        }
      }
      else
      if (code == 30)
      {
        tok.nextToken (*fin);   nr = atoi (tok());
        Arbeitsplan* zaf  = ArbeitsplanListe->sucheArbeitsplan(nr+LASTAFNR);
        if (zaf) zaf->readMW (*fin);
        else
        {
          OK = false;
          Meld.Ausgabe(280, nr+LASTAFNR);
          tok.EndOfLine (*fin);
        }
      }
      else tok.EndOfLine (*fin);
    }
    else tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE TMWLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::TMWSchreiben (Ustring datname)
{
  int satznr = 2;
  LCursor<typBaustein> zhilfe;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TMW");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1  Code:                         Art:");
  Write (fout, "%s\n", "-1  10 = Baustein                 1= Auslastung");
  Write (fout, "%s\n", "-1  20 = Fahrtroute               2= Belegung");
  Write (fout, "%s\n", "-1  30 = Arbeitsplaene            4= Durchlaufzeit");
  Write (fout, "%s\n", "-1                                5= Stoerung");
  Write (fout, "%s\n", "-1 SatzNr");
  Write (fout, "%s\n", "-1                        Arbeits-         Darst");
  Write (fout, "%s\n", "-1   Code  BstNr  BstTyp  planNr    Anz Art     Bereich");
  Write (fout, "%s\n", "-1                        RoutenNr");
  Write (fout, "%d\n",  -1);

  for (zhilfe = BstListe; zhilfe; zhilfe++)
     zhilfe()->BMWSchreiben (fout, satznr);
  Write (fout, "%d\n",  -1);
  ArbeitsplanListe->MWSchreiben (fout, satznr);
  DateiFussSchreiben (fout, "TMW");
  fout.close ();
} // TMWSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typBausteinListe::TSTLesen (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  int bstnr;
  typBaustein *zbst;
  SFXToken tok;
  InputFile *fin;
  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TTPLesen()",
               "Satznr.= %d in TTP-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*fin);

  while((OK) && (satznr != -999))
  {
    tok.nextToken (*fin);   satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);   bstnr = atoi (tok());
      zbst   = BausteinListe->Suche (bstnr+LASTBSTNR);
      if (zbst != NULL) zbst->BSPLesen (*fin);
      else
      {
        OK = false;
        Meld.Ausgabe(9, bstnr+LASTBSTNR);
        tok.EndOfLine (*fin);
      }
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE TSTLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::TSTSchreiben (Ustring datname)
{
  int satznr = 2;
  LCursor<typBaustein> zhilfe;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TST");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1 SatzNr   Strat      WZSchwelle      IndirektAvis");
  Write (fout, "%s\n", "-1     BstNr     Priori         DirektAvis");
  Write (fout, "%d\n", -1);

  for (zhilfe = BstListe; zhilfe; zhilfe++)
  {
    satznr++;
    zhilfe()->BSPSchreiben (fout, satznr);
  }
  DateiFussSchreiben (fout, "TST");
  fout.close ();
} // TSTSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typBausteinListe::TBVLesen (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  int  vonbst, vonplatz, mitbst, mitplatz, unterwinkel;
  InputFile *fin;
  SFXToken tok;

  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TBVLesen()",
               "Satznr.= %d in TBV-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*fin);

  typBaustein *zvonbst, *zmitbst;
  while((OK) && (satznr != -999) && (satznr != -3))
  {
    tok.nextToken (*fin);  satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);  vonbst      = atoi (tok());
      tok.nextToken (*fin);  vonplatz    = atoi (tok());
      tok.nextToken (*fin);  mitbst      = atoi (tok());
      tok.nextToken (*fin);  mitplatz    = atoi (tok());
      tok.nextToken (*fin);  unterwinkel = atoi (tok());
      tok.EndOfLine (*fin);
      zvonbst = BausteinListe->Suche (vonbst+LASTBSTNR);
      zmitbst = BausteinListe->Suche (mitbst+LASTBSTNR);
      if ((!zvonbst) || (!zmitbst)) OK = false;
      if (!zvonbst) Meld.Ausgabe(9, vonbst+LASTBSTNR);
      else
      if (!zmitbst) Meld.Ausgabe(9, mitbst+LASTBSTNR);
      else
      zvonbst->BstVerketten (vonplatz, zmitbst, mitplatz, unterwinkel);
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE TBVLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::TBVSchreiben (Ustring datname)
{
   int satznr = 3;
   LCursor<typBaustein> zhilfe;
   ofstream fout (datname.str ());
   DateiKopfSchreiben (fout, "TBV");
   Write (fout, "%4d  %4d\n", 2, 0);
   Write (fout, "%d\n", -1);
   Write (fout, "%s\n", "-1 SatzNr    vonPlatz    mitPlatz");
   Write (fout, "%s\n", "-1     vonBstNr    mitBstNr     Winkel");
   Write (fout, "%d\n", -1);

   satznr = 2;
   for (zhilfe = BstListe; zhilfe; zhilfe++)
        zhilfe()->TBVSchreiben (fout, zhilfe(), satznr);

   Write (fout, "%4d\n", -3);       // TBV-Trenner
   DateiFussSchreiben (fout, "TBV");
   fout.close ();
} // ENDE TBVSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool typBausteinListe::TPVLesen (Ustring datname)
{
  int  satznr = 2;
  bool OK = true;
  int  bstnr;
  InputFile *fin;
  SFXToken tok;

  fin = new InputFile (datname.str());
  if (!tok.findSentence (satznr, *fin))
    Msg.Error ("typBausteinListe::TPVLesen()",
               "Satznr.= %d in TPV-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*fin);

  typBaustein *zbst;
  while((OK) && (satznr != -999))
  {
   tok.nextToken (*fin);  satznr = atoi (tok());
    if (satznr > 0)
    {
      tok.nextToken (*fin);  bstnr = atoi (tok());
      tok.nextToken (*fin);  // BstTyp ueberlesen
      zbst = BausteinListe->Suche (bstnr+LASTBSTNR);
      if (zbst)
         OK = zbst->BPVLesen (*fin);
      else
      {
        Meld.Ausgabe(9, bstnr+LASTBSTNR);
        OK = false;
      }
    }
    else
    tok.EndOfLine (*fin);
  }
  fin->close();
  delete fin;
  return OK;
} // ENDE TPVLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::TPVSchreiben (Ustring datname)
{
  int satznr = 3;
  LCursor<typBaustein> zhilfe;
  ofstream fout (datname.str ());
  DateiKopfSchreiben (fout, "TPV");
  Write (fout, "%4d  %4d\n", 2, 0);
  Write (fout, "%d\n", -1);
  Write (fout, "%s\n", "-1 SatzNr");
  Write (fout, "%s\n", "-1    BstNr  BstTyp  Anzahl  Verwaltete Bausteine:");
  Write (fout, "%d\n",  -1);

  satznr = 2;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
       zhilfe()->BPVSchreiben (fout, zhilfe(), satznr);

  DateiFussSchreiben (fout, "TPV");
  fout.close ();
} // ENDE TPVSchreiben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring typBausteinListe::getPoolBausteine (typBaustein* zbst)
{
  LCursor<typBaustein> zhilfe;
  int bstnr;
  char tmp[128];
  Ustring str;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
  {
    bstnr = -1;
    switch (zbst->i_BstTyp())
    {
      case tRegalverwalter :
        if ((zhilfe()->i_BstTyp() == tRegaleinheit) ||
	    (zhilfe()->i_BstTyp() == tAbstrakteRegaleinheit))
            bstnr = zhilfe()->i_BstNr(); break;
      case tNcPoolverwalter :
/* Poolverwalter in Poolliste ist z. Zt. nicht möglich  --> evtl. Endlosschleife
        if ((zhilfe()->i_BstTyp() == tNcPoolverwalter) ||
            (zhilfe()->i_BstTyp() == tMaschine)) bstnr = zhilfe()->i_BstNr();
*/
        if (zhilfe()->i_BstTyp() == tMaschine) bstnr = zhilfe()->i_BstNr();
        break;
      case tKomVerwalter :
        if (zhilfe()->i_BstTyp() == tKommissionierer)
             bstnr = zhilfe()->i_BstNr();
        break;
      case tFtsLadepool :
        if (zhilfe()->i_BstTyp() == tFtsLadeplatz)
            bstnr = zhilfe()->i_BstNr();
        break;
      case tFtsVerwalter :
        if (zhilfe()->i_BstTyp() == tFtsWagen)
            bstnr = zhilfe()->i_BstNr();
        break;
      default : bstnr = -1;
    } // ENDE switch

    if (bstnr > 0)
      if (!(zbst->inPoolListe(bstnr)) && !(zbst == zhilfe()) )
      {
        sprintf (tmp, "{%d  (%s)}\t", bstnr,(char*)zhilfe()->getName().str());
        str += tmp;
      }
  }
  return str;
} // ENDE getPoolBausteine

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring typBausteinListe::getBetreuteBausteine (typBaustein* zbst)
{
  LCursor<typBaustein> zhilfe;
  int bstnr;
  char tmp[128];
  char buf [512];
  buf[0] = '\0';
  for (zhilfe = BstListe; zhilfe; zhilfe++)
  {
    bstnr = -1;
    switch (zbst->i_BstTyp())
    {
      case tRegalverwalter :
        if ((zhilfe()->i_BstTyp() == tSenke)           ||
            (zhilfe()->i_BstTyp() == tMaschine)        ||
            (zhilfe()->i_BstTyp() == tNcPoolverwalter) ||
            (zhilfe()->i_BstTyp() == tKommissionierer))
             bstnr = zhilfe()->i_BstNr();
        break;
      case tFtsLadepool :
        if (zhilfe()->i_BstTyp() == tFtsWagen) 
            bstnr = zhilfe()->i_BstNr();
        break;
      default : bstnr = -1;
    } // ENDE switch

    if (bstnr > 0)
      if (!(zbst->inBetreuteListe(bstnr)))
      {
        sprintf (tmp, "{%d  (%s)}\t", bstnr,(char*)zhilfe()->getName().str());
        strcat(buf, tmp);
      }
  }
  Ustring str(buf);
  return str;  
} // ENDE getBetreuteBausteine

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::BausteinImPoolLoeschen (typBaustein* zbst)
{
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
      zhilfe()->BPVmitBausteinLoeschen (zbst);
} // ENDE BausteinImPoolLoeschen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
WrapBox typBausteinListe::getFlaeche ()
{
  WrapBox GridWrap;
  GeoObject* geo;
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
  {
    geo = GTSMAP.find (*(zhilfe()));
    GridWrap.adjust (geo->WrapForParent ());
  }
  return GridWrap;
}  // ENDE getFlaeche

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBausteinListe::selectBausteine (WrapBox box, const unsigned art, const bool shift)
{
  GeoObject* zgeo;
  Vec3D      aktpos;
  WrapBox    bstbox;
  bool       selBst;
  for (LCursor<typBaustein> zhilfe = BstListe; zhilfe; zhilfe++)
  {
    selBst = false;
    aktpos = zhilfe()->zBstGraphik->Pos();
    if (art)
    {
      if ((aktpos.X() >= box.Min.X()) &&  (aktpos.X() <= box.Max.X()) &&
          (aktpos.Y() >= box.Min.Y()) &&  (aktpos.Y() <= box.Max.Y()))
      selBst = true;
    }
    else
    {
      bstbox = zhilfe()->zBstGraphik->WrapForParent();
      if ((bstbox.Min.X() >= box.Min.X()) &&  (bstbox.Max.X() <= box.Max.X()) &&
          (bstbox.Min.Y() >= box.Min.Y()) &&  (bstbox.Max.Y() <= box.Max.Y()))
      selBst = true;
    }
    if (selBst)
    {
      zgeo = GTSMAP.find (*(zhilfe()));
      if (GTSSpace->MySelection()->hasSelection (*zgeo))
      {
        if (shift)
           GTSSpace->MySelection()->remove (*zgeo);
      }
      else
        GTSSpace->MySelection()->insert (*zgeo);
    }
  }
  GTSSpace->flushAllViews();
}  // ENDE getFlaeche
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
typBausteinListe::~typBausteinListe ()
{
  while (!BstListe.isEmpty())
         delete BstListe.removeFirst();
}  // typBausteinListe


// ########################################################################
TMPBenoetigteBausteine::TMPBenoetigteBausteine (Ustring datname) : BstListe()
{
  file = new InputFile (datname.str ());
}  // TMPBenoetigteBausteine

void TMPBenoetigteBausteine::TGSLesen ()
{
  int satznr = 3;
  if (!tok.findSentence (satznr, *file))
    Msg.Error ("TMPBenoetigteBausteine::TGSLesen()",
               "Satznr.= %d in TGS-Datei nicht vorhanden", satznr);
  tok.EndOfLine (*file);

  typBaustein *zbstein;
  while(satznr != -999)
  {
    tok.nextToken (*file);
    satznr = atoi (tok ());
    if (satznr > 0)
    {
      zbstein = new typBaustein (*file);
      BstInListe (*zbstein);
    }
    else tok.EndOfLine (*file);
  }
  file->close();
  delete file;
} // TGSLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void TMPBenoetigteBausteine::BstInListe (typBaustein &zbst)
{
  LCursor<typBaustein> zhilfe;
  for (zhilfe = BstListe; zhilfe; zhilfe++)
     if (zhilfe()->i_BstTyp() >= zbst.i_BstTyp()) break;

   if (zhilfe != NULL) 
   {
     if (zhilfe()->i_BstTyp() > zbst.i_BstTyp())
       BstListe.prepend (zbst, zhilfe);
     else
     {
       for (; zhilfe; zhilfe++)
         if ((zhilfe()->i_BstTyp() != zbst.i_BstTyp()) ||
             (zhilfe()->i_VarTyp() >= zbst.i_VarTyp())) break;

         if (zhilfe != NULL)
         {
           if ((zhilfe()->i_BstTyp() == zbst.i_BstTyp()) &&
              (zhilfe()->i_VarTyp() == zbst.i_VarTyp()))
             delete &zbst;
           else
             BstListe.prepend (zbst, zhilfe);
         }
         else BstListe.append (zbst);
     }
   }
   else BstListe.append (zbst);
}  // BstInListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool TMPBenoetigteBausteine::BstAusTGBLesen ()
{
  LCursor<typBaustein> zhilfe;
  bool OK = true;

  TgbBibliothek->Oeffnen();
  for (zhilfe = BstListe; zhilfe && OK; zhilfe++)
  {
     if (initprog)
     {
       Write ("TGBLesen: Bst.Typ=%d ", zhilfe()->i_BstTyp());
       Write (" Var.Typ=%d wird gelesen\n", zhilfe()->i_VarTyp());
     }
     OK = TgbBibliothek->LeseBaustein (zhilfe()->i_BstTyp(), zhilfe()->i_VarTyp());
  }
  TgbBibliothek->Schliessen();
  return OK;
}  // BstAusTGBLesen

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
TMPBenoetigteBausteine::~TMPBenoetigteBausteine ()
{
  while (!BstListe.isEmpty())
         delete BstListe.removeFirst();
}  // TMPBenoetigteBausteine
