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

typBTPNcPoolverwalter::typBTPNcPoolverwalter ()
{ } // typBTPNcPoolverwalter

typBTPNcPoolverwalter::typBTPNcPoolverwalter (const typBTPNcPoolverwalter& /*copy*/)
{
} // typBTPNcPoolverwalter

typBTPNcPoolverwalter::typBTPNcPoolverwalter (const typBTPNcPoolverwalter* /*zBTP*/)
{
} // typBTPNcPoolverwalter

typBTPNcPoolverwalter::typBTPNcPoolverwalter (InputFile& /*fin*/)
{
}; // typBTPNcPoolverwalter

typBTPNcPoolverwalter::~typBTPNcPoolverwalter ()
{ } // ~typBTPNcPoolverwalter

typBSTNcPoolverwalter::typBSTNcPoolverwalter (const typBSTNcPoolverwalter &copy, int nr)
                      :typBaustein(copy, nr),
                       typBSPVariante2(copy),
                       typPoolVerwaltung(copy)
{
} // typBSTNcPoolverwalter

typBSTNcPoolverwalter::typBSTNcPoolverwalter (BstVariante *zaufTGB, int nr)
                      :typBaustein(zaufTGB, nr),
                       typBSPVariante2((typBSPVariante2*)zaufTGB->BSP ()),
                       typPoolVerwaltung()
{
} // typBSTNcPoolverwalter

typBSTNcPoolverwalter::typBSTNcPoolverwalter (InputFile& fin, int nr, int btyp, int vtyp)
                      :typBaustein (fin, nr, btyp, vtyp),
                       typBSPVariante2((typBSPVariante2*)zTGB->BSP ()),
                       typPoolVerwaltung()
{
} // typBSTNcPoolverwalter

typBSTNcPoolverwalter::~typBSTNcPoolverwalter ()
{ } // ~typBSTNcPoolverwalter

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

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

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

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

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

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

void typBSTNcPoolverwalter::BSPLesen (InputFile& fin)
{
  typBSPVariante2::BSPLesen (fin);
}  // ENDE BSPLesen

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

Ustring typBSTNcPoolverwalter::getBSPWerte ()
{
  return typBSPVariante2::getBSPWerte ();
}  // ENDE getBSPWerte

void typBSTNcPoolverwalter::setBSPWerte (Ustring str)
{
  typBSPVariante2::setBSPWerte (str);
}  // ENDE setBSPWerte

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

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

void typBSTNcPoolverwalter::TFKErzeugenVonPoolZuPool (typBaustein* zanfang,
                                                      typBaustein* zende)
{
  typPoolVerwaltung::TFKErzeugenVonPoolZuPool (zanfang, zende);
}  // ENDE TFKErzeugenVonPoolZuPool

void typBSTNcPoolverwalter::TFKErzeugenVonBausteinZuPool (typBaustein* zanfang,
                                                          typBaustein* zende)
{
  typPoolVerwaltung::TFKErzeugenVonBausteinZuPool (zanfang, zende);
}  // ENDE TFKErzeugenVonBausteinZuPool

void typBSTNcPoolverwalter::TFKErzeugenVonPoolZuBaustein (typBaustein* zanfang,
                                                          typBaustein* zende)
{
  typPoolVerwaltung::TFKErzeugenVonPoolZuBaustein (zanfang, zende);
}  // ENDE TFKErzeugenVonPoolZuBaustein

bool typBSTNcPoolverwalter::TFKSuchenVonPoolZuPool (typBaustein* zanfang,
                                                    typBaustein* zende)
{
  return typPoolVerwaltung::TFKSuchenVonPoolZuPool (zanfang, zende);
}  // ENDE TFKSuchenVonPoolZuPool

bool typBSTNcPoolverwalter::TFKSuchenVonBausteinZuPool (typBaustein* zanfang,
                                                        typBaustein* zende)
{
  return typPoolVerwaltung::TFKSuchenVonBausteinZuPool (zanfang, zende);
}  // ENDE TFKSuchenVonBausteinZuPool

bool typBSTNcPoolverwalter::TFKSuchenVonPoolZuBaustein (typBaustein* zanfang,
                                                        typBaustein* zende)
{
  return typPoolVerwaltung::TFKSuchenVonPoolZuBaustein (zanfang, zende);
}  // ENDE TFKSuchenVonPoolZuBaustein

void typBSTNcPoolverwalter::TFKZeigenVonPoolZuPool (typBaustein* zanfang,
                                                    typBaustein* zende)
{
  typPoolVerwaltung::TFKZeigenVonPoolZuPool (zanfang, zende);
}  // ENDE TFKZeigenVonPoolZuPool

void typBSTNcPoolverwalter::TFKZeigenVonBausteinZuPool (typBaustein* zanfang,
                                                        typBaustein* zende)
{
  typPoolVerwaltung::TFKZeigenVonBausteinZuPool (zanfang, zende);
}  // ENDE TFKZeigenVonBausteinZuPool

void typBSTNcPoolverwalter::TFKZeigenVonPoolZuBaustein (typBaustein* zanfang,
                                                        typBaustein* zende)
{
  typPoolVerwaltung::TFKZeigenVonPoolZuBaustein (zanfang, zende);
}  // ENDE TFKZeigenVonPoolZuBaustein

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

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

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

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