// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtsb09.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:  $
// State assigned to revision
// $State: Exp $
//
//
// $Log: gtsb09.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 "gtsb09.h"

typBTPMehrfachLader::typBTPMehrfachLader ()
  :
  ObjUebernahmeZeit       (0.1), ObjXFahrGeschwindigkeit (10.0),
  ObjXFahrBeschleunigung  (10.0), ObjXFahrVerzoegerung    (10.0),
  ObjYFahrGeschwindigkeit (10.0), ObjYFahrBeschleunigung  (10.0),
  ObjYFahrVerzoegerung    (10.0), ObjHubGeschwindigkeit   (10.0),
  ObjHubBeschleunigung    (10.0), ObjHubVerzoegerung      (10.0),
  ObjQuerGesperrt         (1)
{ } // typBTPMehrfachLader

typBTPMehrfachLader::typBTPMehrfachLader (const typBTPMehrfachLader &copy)
{
  ObjUebernahmeZeit       = copy.ObjUebernahmeZeit;
  ObjXFahrGeschwindigkeit = copy.ObjXFahrGeschwindigkeit;
  ObjXFahrBeschleunigung  = copy.ObjXFahrBeschleunigung;
  ObjXFahrVerzoegerung    = copy.ObjXFahrVerzoegerung;
  ObjYFahrGeschwindigkeit = copy.ObjYFahrGeschwindigkeit;
  ObjYFahrBeschleunigung  = copy.ObjYFahrBeschleunigung;
  ObjYFahrVerzoegerung    = copy.ObjYFahrVerzoegerung;
  ObjHubGeschwindigkeit   = copy.ObjHubGeschwindigkeit;
  ObjHubBeschleunigung    = copy.ObjHubBeschleunigung;
  ObjHubVerzoegerung      = copy.ObjHubVerzoegerung;
  ObjQuerGesperrt         = copy.ObjQuerGesperrt;
} // typBTPMehrfachLader

typBTPMehrfachLader::typBTPMehrfachLader (const typBTPMehrfachLader *zBTP)
{
  ObjUebernahmeZeit       = zBTP->ObjUebernahmeZeit;
  ObjXFahrGeschwindigkeit = zBTP->ObjXFahrGeschwindigkeit;
  ObjXFahrBeschleunigung  = zBTP->ObjXFahrBeschleunigung;
  ObjXFahrVerzoegerung    = zBTP->ObjXFahrVerzoegerung;
  ObjYFahrGeschwindigkeit = zBTP->ObjYFahrGeschwindigkeit;
  ObjYFahrBeschleunigung  = zBTP->ObjYFahrBeschleunigung;
  ObjYFahrVerzoegerung    = zBTP->ObjYFahrVerzoegerung;
  ObjHubGeschwindigkeit   = zBTP->ObjHubGeschwindigkeit;
  ObjHubBeschleunigung    = zBTP->ObjHubBeschleunigung;
  ObjHubVerzoegerung      = zBTP->ObjHubVerzoegerung;
  ObjQuerGesperrt         = zBTP->ObjQuerGesperrt;
} // typBTPMehrfachLader

typBTPMehrfachLader::typBTPMehrfachLader (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin); tok.EndOfLine (fin);  // Zeile überlesen
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjUebernahmeZeit = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjXFahrGeschwindigkeit = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjXFahrBeschleunigung = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjXFahrVerzoegerung = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjYFahrGeschwindigkeit = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjYFahrBeschleunigung = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjYFahrVerzoegerung = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjHubGeschwindigkeit = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjHubBeschleunigung = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjHubVerzoegerung = atof(tok());
  tok.EndOfLine (fin);
  tok.nextToken (fin); // Nr ueberlesen
  tok.nextToken (fin);  ObjQuerGesperrt = atof(tok());
  tok.EndOfLine (fin);
}; // typBTPMehrfachLader


void typBTPMehrfachLader::BTPLesen (InputFile& fin)
{
  SFXToken tok;
  tok.nextToken (fin);  ObjUebernahmeZeit       = atof(tok());
  tok.nextToken (fin);  ObjXFahrGeschwindigkeit = atof(tok());
  tok.nextToken (fin);  ObjXFahrBeschleunigung  = atof(tok());
  tok.nextToken (fin);  ObjXFahrVerzoegerung    = atof(tok());
  tok.nextToken (fin);  ObjYFahrGeschwindigkeit = atof(tok());
  tok.nextToken (fin);  ObjYFahrBeschleunigung  = atof(tok());
  tok.nextToken (fin);  ObjYFahrVerzoegerung    = atof(tok());
  tok.nextToken (fin);  ObjHubGeschwindigkeit   = atof(tok());
  tok.nextToken (fin);  ObjHubBeschleunigung    = atof(tok());
  tok.nextToken (fin);  ObjHubVerzoegerung      = atof(tok());
  tok.nextToken (fin);  ObjQuerGesperrt         = atof(tok());
  tok.EndOfLine (fin);
}  // ENDE BTPLesen

void typBTPMehrfachLader::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 ", ObjUebernahmeZeit);
  Write   (ostrm, "%11.5f ", ObjXFahrGeschwindigkeit);
  Write   (ostrm, "%11.5f ", ObjXFahrBeschleunigung);
  Write   (ostrm, "%11.5f ", ObjXFahrVerzoegerung);
  Write   (ostrm, "%11.5f ", ObjYFahrGeschwindigkeit);
  Write   (ostrm, "%11.5f ", ObjYFahrBeschleunigung);
  Write   (ostrm, "%11.5f ", ObjYFahrVerzoegerung);
  Write   (ostrm, "%11.5f ", ObjHubGeschwindigkeit);
  Write   (ostrm, "%11.5f ", ObjHubBeschleunigung);
  Write   (ostrm, "%11.5f ", ObjHubVerzoegerung);
  Write   (ostrm, "%11.5f ", ObjQuerGesperrt);
  Writeln (ostrm);
}  // ENDE BTPSchreiben

Ustring typBTPMehrfachLader::getBTPWerte ()
{
  char tmp [512];
  sprintf (tmp,
    "%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f\t%9.5f",
           ObjUebernahmeZeit,        ObjXFahrGeschwindigkeit,
           ObjXFahrBeschleunigung,   ObjXFahrVerzoegerung,
           ObjYFahrGeschwindigkeit,  ObjYFahrBeschleunigung,
           ObjYFahrVerzoegerung,     ObjHubGeschwindigkeit,
           ObjHubBeschleunigung,     ObjHubVerzoegerung,
           ObjQuerGesperrt);
  Ustring buf(tmp);
  return buf;
}  // ENDE getBTPWerte

void typBTPMehrfachLader::setBTPWerte (Ustring str)
{
  sscanf ((char*)str.str(), "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
          &ObjUebernahmeZeit,       &ObjXFahrGeschwindigkeit,
          &ObjXFahrBeschleunigung,  &ObjXFahrVerzoegerung,
          &ObjYFahrGeschwindigkeit, &ObjYFahrBeschleunigung,
          &ObjYFahrVerzoegerung,     &ObjHubGeschwindigkeit,
          &ObjHubBeschleunigung,    &ObjHubVerzoegerung,
          &ObjQuerGesperrt);
}  // ENDE setBTPWerte

void typBTPMehrfachLader::setBTPWerte (const typBTPMehrfachLader *zBTP)
{
  ObjUebernahmeZeit       = zBTP->ObjUebernahmeZeit;
  ObjXFahrGeschwindigkeit = zBTP->ObjXFahrGeschwindigkeit;
  ObjXFahrBeschleunigung  = zBTP->ObjXFahrBeschleunigung;
  ObjXFahrVerzoegerung    = zBTP->ObjXFahrVerzoegerung;
  ObjYFahrGeschwindigkeit = zBTP->ObjYFahrGeschwindigkeit;
  ObjYFahrBeschleunigung  = zBTP->ObjYFahrBeschleunigung;
  ObjYFahrVerzoegerung    = zBTP->ObjYFahrVerzoegerung;
  ObjHubGeschwindigkeit   = zBTP->ObjHubGeschwindigkeit;
  ObjHubBeschleunigung    = zBTP->ObjHubBeschleunigung;
  ObjHubVerzoegerung      = zBTP->ObjHubVerzoegerung;
  ObjQuerGesperrt         = zBTP->ObjQuerGesperrt;
}  // ENDE setBTPWerte

typBTPMehrfachLader::~typBTPMehrfachLader ()
{ } // ~typBTPMehrfachLader

typBSTMehrfachLader::typBSTMehrfachLader (const typBSTMehrfachLader &copy, int nr)
             :typBaustein     (copy, nr),
              typBTPMehrfachLader  (copy),
              typBSPVariante1 (copy),
              ObjHakenKontur  (NULL),
              ObjHakenGeo     (NULL)
{
  const DynArray<GeoObject> (&go) (copy.zTGB->AllGeometries ());
  go.First ();
  if (go.Next ()) {
    ObjHakenKontur = new GeoObject ();
    ObjHakenKontur->copyContents (*(go ()));
    ObjHakenKontur->setParent (*zBstGraphik);
    ObjHakenKontur->setSelectionToMum ();
    Vec3D v (*(copy.zTGB->PalPositions ().First ()));
    ObjHakenKontur->setPos (Vec3D(v.X(), v.Y(), 0.0), 0);
    if (go.Next ()) {
      ObjHakenGeo = new GeoObject ();
      ObjHakenGeo->copyContents (*(go ()));
      ObjHakenGeo->setParent (*ObjHakenKontur);
      ObjHakenGeo->setSelectionToMum ();
      v = (*(copy.zTGB->PalPositions ().First ()));
      ObjHakenGeo->setPos (Vec3D (0.0, 0.0, v.Z()), 0);
    }
  }
} // typBSTMehrfachLader

typBSTMehrfachLader::typBSTMehrfachLader (BstVariante *zaufTGB, int nr)
               :typBaustein(zaufTGB, nr),
                typBTPMehrfachLader((typBTPMehrfachLader*)zTGB->BTP ()),
                typBSPVariante1((typBSPVariante1*)zTGB->BSP ()),
                ObjHakenKontur  (NULL), ObjHakenGeo (NULL)

{
  const DynArray<GeoObject> (&go) (zaufTGB->AllGeometries ());
  go.First ();
  if (go.Next ()) {
    ObjHakenKontur = new GeoObject ();
    ObjHakenKontur->copyContents (*(go ()));
    ObjHakenKontur->setParent (*zBstGraphik);
    ObjHakenKontur->setSelectionToMum ();
    Vec3D v (*(zaufTGB->PalPositions ().First ()));
    ObjHakenKontur->setPos (Vec3D(v.X(), v.Y(), 0.0), 0);
    if (go.Next ()) {
      ObjHakenGeo = new GeoObject ();
      ObjHakenGeo->copyContents (*(go ()));
      ObjHakenGeo->setParent (*ObjHakenKontur);
      ObjHakenGeo->setSelectionToMum ();
      v = (*(zaufTGB->PalPositions ().First ()));
      ObjHakenGeo->setPos (Vec3D (0.0, 0.0, v.Z()), 0);
    }
  }
} // typBSTMehrfachLader

typBSTMehrfachLader::typBSTMehrfachLader (InputFile& fin, int nr, int btyp, int vtyp)
               :typBaustein (fin, nr, btyp, vtyp),
                typBTPMehrfachLader((typBTPMehrfachLader*)zTGB->BTP ()),
                typBSPVariante1((typBSPVariante1*)zTGB->BSP ()),
                ObjHakenKontur  (NULL), ObjHakenGeo (NULL)

{
  const DynArray<GeoObject> (&go) (zTGB->AllGeometries ());
  go.First ();
  if (go.Next ()) {
    ObjHakenKontur = new GeoObject ();
    ObjHakenKontur->copyContents (*(go ()));
    ObjHakenKontur->setParent (*zBstGraphik);
    ObjHakenKontur->setSelectionToMum ();
    Vec3D v (*(zTGB->PalPositions ().First ()));
    ObjHakenKontur->setPos (Vec3D(v.X(), v.Y(), 0.0), 0);
    if (go.Next ()) {
      ObjHakenGeo = new GeoObject ();
      ObjHakenGeo->copyContents (*(go ()));
      ObjHakenGeo->setParent (*ObjHakenKontur);
      ObjHakenGeo->setSelectionToMum ();
      v = (*(zTGB->PalPositions ().First ()));
      ObjHakenGeo->setPos (Vec3D (0.0, 0.0, v.Z()), 0);
    }
  }
} // typBSTMehrfachLader

/*virtual*/ typBSTMehrfachLader::~typBSTMehrfachLader () {
  if (ObjHakenKontur) delete ObjHakenKontur;
  if (ObjHakenGeo)    delete ObjHakenGeo;
};

void typBSTMehrfachLader::VarianteErsetzen  (BstVariante *zaufTGB)
{
  typBTPMehrfachLader::setBTPWerte ((typBTPMehrfachLader*)zaufTGB->BTP());
  typBSPVariante1::setBSPWerte((typBSPVariante1*)zaufTGB->BSP());
  delete ObjHakenKontur;
  delete ObjHakenGeo;
  BausteinErsetzen (zaufTGB);
  const DynArray<GeoObject> (&go) (zaufTGB->AllGeometries ());
  go.First ();
  if (go.Next ()) {
    ObjHakenKontur = new GeoObject ();
    ObjHakenKontur->copyContents (*(go ()));
    ObjHakenKontur->setParent (*zBstGraphik);
    ObjHakenKontur->setSelectionToMum ();
    Vec3D v (*(zaufTGB->PalPositions ().First ()));
    ObjHakenKontur->setPos (Vec3D(v.X(), v.Y(), 0.0), 0);
    if (go.Next ()) {
      ObjHakenGeo = new GeoObject ();
      ObjHakenGeo->copyContents (*(go ()));
      ObjHakenGeo->setParent (*ObjHakenKontur);
      ObjHakenGeo->setSelectionToMum ();
      v = (*(zaufTGB->PalPositions ().First ()));
      ObjHakenGeo->setPos (Vec3D (0.0, 0.0, v.Z()), 0);
    }
  }
} // ENDE  VarianteErsetzen

Ustring typBSTMehrfachLader::getBTPWerte ()
{
  return typBTPMehrfachLader::getBTPWerte();
}  // ENDE getBTPWerte

void typBSTMehrfachLader::setBTPWerte (Ustring str)
{
  typBTPMehrfachLader::setBTPWerte (str);
}  // ENDE setBTPWerte

void typBSTMehrfachLader::setBTPWerte (const typBTPMehrfachLader *zBTP)
{
  typBSTMehrfachLader::setBTPWerte (zBTP);
}  // ENDE setBTPWerte

void typBSTMehrfachLader::BTPLesen (InputFile& fin)
{
  typBTPMehrfachLader::BTPLesen (fin);
}  // ENDE BSPLesen

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

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

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

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

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