// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtsb28.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: gtsb28.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 "gtstgb.h"
#include "gtsb28.h"

typBTPFtsLadepool::typBTPFtsLadepool ()
  : Ladestaerke (20.0)
{ } // typBTPFtsLadepool

typBTPFtsLadepool::typBTPFtsLadepool (const typBTPFtsLadepool &copy)
{
  Ladestaerke = copy.Ladestaerke;
} // typBTPFtsLadepool

typBTPFtsLadepool::typBTPFtsLadepool (const typBTPFtsLadepool *zBTP)
{
  Ladestaerke = zBTP->Ladestaerke;
} // typBTPFtsLadepool

typBTPFtsLadepool::typBTPFtsLadepool (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin); tok.EndOfLine (fin);  // Zeile überlesen
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  Ladestaerke = atof(tok());
  tok.EndOfLine (fin);
}; // typBTPFtsLadepool

void typBTPFtsLadepool::BTPLesen (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin);  Ladestaerke = atof(tok());
  tok.EndOfLine (fin);
}  // ENDE BTPLesen

void typBTPFtsLadepool::BTPSchreiben (ostream& ostrm, typBaustein *zbst, int satznr)
{
  Write (ostrm, "%4d ",    satznr);
  Write (ostrm, "%4d ",    zbst->i_BstNr());
  Write (ostrm, "%4d ",    zbst->i_BstTyp());
  Write (ostrm, "%11.5f\n", Ladestaerke);
}  // ENDE BTPSchreiben

Ustring typBTPFtsLadepool::getBTPWerte ()
{
  char tmp [512];
  sprintf (tmp, "%9.5f", Ladestaerke);
  Ustring buf(tmp);
  return buf;
}  // ENDE getBTPWerte

void typBTPFtsLadepool::setBTPWerte (Ustring str)
{
  sscanf((char*)str.str(), "%f", &Ladestaerke);
}  // ENDE setBTPWerte

void typBTPFtsLadepool::setBTPWerte (const typBTPFtsLadepool *zBTP)
{
  Ladestaerke = zBTP->Ladestaerke;
}  // ENDE setBTPWerte

typBTPFtsLadepool::~typBTPFtsLadepool ()
{ } // ~typBTPFtsLadepool

typBSTFtsLadepool::typBSTFtsLadepool (const typBSTFtsLadepool &copy, int nr)
                  :typBaustein(copy, nr),
                   typBTPFtsLadepool(copy),
                   typBSPVariante1(copy),
                   typPoolVerwaltung()
{
} // typBSTFtsLadepool

typBSTFtsLadepool::typBSTFtsLadepool (BstVariante *zaufTGB, int nr)
                  :typBaustein(zaufTGB, nr),
                   typBTPFtsLadepool((typBTPFtsLadepool*)zTGB->BTP ()),
                   typBSPVariante1((typBSPVariante1*)zTGB->BSP ()),
                   typPoolVerwaltung()
{
} // typBSTFtsLadepool

typBSTFtsLadepool::typBSTFtsLadepool (InputFile& fin, int nr, int btyp, int vtyp)
                  :typBaustein (fin, nr, btyp, vtyp),
                   typBTPFtsLadepool((typBTPFtsLadepool*)zTGB->BTP ()),
                   typBSPVariante1((typBSPVariante1*)zTGB->BSP ()),
                   typPoolVerwaltung()
{
} // typBSTFtsLadepool

typBSTFtsLadepool::~typBSTFtsLadepool ()
{ } // ~typBSTFtsLadepool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBSTFtsLadepool::mitPoolVerketten (typBaustein* zvon, int vonplatz,
                                          typBaustein* zmit, int mitplatz,
                                          int unterwinkel)
{
  typPoolVerwaltung::mitPoolVerketten (zvon, vonplatz, zmit, mitplatz, unterwinkel);
}  // ENDE mitPoolVerketten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBSTFtsLadepool::verkette (int vonplatz, typBaustein* zmit, int mitplatz, int unterwinkel)
{
  typPoolVerwaltung::vonPoolVerketten (this, vonplatz, zmit, mitplatz, unterwinkel);
} // ENDE verkette

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBSTFtsLadepool::loeseVerkettungmitPool (typBaustein* zvon,
                                                typBaustein* zmit)
{
  typPoolVerwaltung::loeseVerkettungmitPool (zvon, zmit);
}  // ENDE loeseVerkettungmitPool

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBSTFtsLadepool::loeseVerkettung (typBaustein* zmit)
{
  typPoolVerwaltung::loeseVerkettungvonPool (this, zmit);
} // ENDE loeseVerkettung

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void typBSTFtsLadepool::InfoVerkettung ()
{
  typPoolVerwaltung::InfoPoolVerkettung(this);
} // ENDE InfoVerkettung

Ustring typBSTFtsLadepool::getVBRWerte ()
{
  Ustring buf (Ladestaerke);
  return buf;
}  // ENDE getVBRWerte

void typBSTFtsLadepool::setVBRWerte (Ustring str)
{
  sscanf((char*)str.str(),"%f", &Ladestaerke);
}  // ENDE setVBRWerte

void typBSTFtsLadepool::VarianteErsetzen  (BstVariante *zaufTGB)
{
  typBSPVariante1::setBSPWerte((typBSPVariante1*)zaufTGB->BSP());
  BausteinErsetzen (zaufTGB);
} // ENDE  VarianteErsetzen

Ustring typBSTFtsLadepool::getBTPWerte ()
{
  return typBTPFtsLadepool::getBTPWerte();
}  // ENDE getBTPWerte

void typBSTFtsLadepool::setBTPWerte (Ustring str)
{
  typBTPFtsLadepool::setBTPWerte (str);
}  // ENDE setBTPWerte

void typBSTFtsLadepool::setBTPWerte (const typBTPFtsLadepool *zBTP)
{
  typBSTFtsLadepool::setBTPWerte (zBTP);
}  // ENDE setBTPWerte

void typBSTFtsLadepool::BTPLesen (InputFile& fin)
{
  typBTPFtsLadepool::BTPLesen (fin);
}  // ENDE BSPLesen

void typBSTFtsLadepool::BTPSchreiben (ostream& ostrm, int satznr)
{
  typBTPFtsLadepool::BTPSchreiben (ostrm, this, satznr);
}  // ENDE BTPSchreiben

void typBSTFtsLadepool::BSPLesen (InputFile& fin)
{
  typBSPVariante1::BSPLesen (fin);
}  // ENDE BSPLesen

void typBSTFtsLadepool::BSPSchreiben (ostream& ostrm, int satznr)
{
  typBSPVariante1::BSPSchreiben (ostrm, this, satznr);
}  // ENDE BSPSchreiben

Ustring typBSTFtsLadepool::getBSPWerte ()
{
  return typBSPVariante1::getBSPWerte ();
}  // ENDE getBSPWerte

void typBSTFtsLadepool::setBSPWerte (Ustring str)
{
  typBSPVariante1::setBSPWerte (str);
}  // ENDE setBSPWerte

bool typBSTFtsLadepool::BPVLesen (InputFile& fin)
{
   return typPoolVerwaltung::BPVLesen (fin, i_BstTyp());
}  // ENDE BPVLesen

void typBSTFtsLadepool::BPVSchreiben (ostream& ostrm,
                                         typBaustein* zbstein, int& satznr)
{
  typPoolVerwaltung::BPVSchreiben (ostrm, zbstein, satznr);
}  // ENDE BPVSchreiben

Ustring typBSTFtsLadepool::getPoolListe ()
{
  return typPoolVerwaltung::getPoolListe();
}  // ENDE getPoolListe

Ustring typBSTFtsLadepool::getBetreuteListe ()
{
  return typPoolVerwaltung::getBetreuteListe();
}  // ENDE getBetreuteListe

bool typBSTFtsLadepool::inPoolListe (int bstnr)
{
  return typPoolVerwaltung::inPoolListe(bstnr);
}  // ENDE inPoolListe

bool typBSTFtsLadepool::inBetreuteListe (int bstnr)
{
  return typPoolVerwaltung::inBetreuteListe(bstnr);
}  // ENDE inBetreuteListe

void typBSTFtsLadepool::setPoolListe (int anzahl, Ustring str)
{
  typPoolVerwaltung::setPoolListe(anzahl, str);
}  // ENDE setPoolListe

void typBSTFtsLadepool::setBetreuteListe (int anzahl, Ustring str)
{
  typPoolVerwaltung::setBetreuteListe(anzahl, str);
}  // ENDE setBetreuteListe

void typBSTFtsLadepool::BPVmitBausteinLoeschen (typBaustein* zbst)
{
  typPoolVerwaltung::BPVmitBausteinLoeschen (zbst);
}  // ENDE BPVmitBausteinLoeschen
