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

#define _GTSMABL_CPP

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

#ifdef __GNUC__
#include <unistd.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "XGraph/Select.h"
#include "XGraph/Parent.h"
#include "XGraph/GeoObj.h"
#include "XGraph/Space.h"

#include <tcl.h>
#include <tk.h>
#include "IniFile.h"
#include "gtsglob.h"
#include "gtspal.h"
#include "gtsbst.h"
#include "gtstzt.h"

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ArbeitsplanNameAendern (int altNr, Ustring neuName )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(altNr);
  if (!zhilfe) 
  {
    Meld.Ausgabe (280, altNr);
    return Ustring();
  }  
  if (neuName != "") zhilfe->setName(neuName);
  return Ustring (zhilfe->getName());
} // ENDE ArbeitsplanNameAendern

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ArbeitsplanNummerAendern (int altNr, int neuNr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(neuNr);
  if (zhilfe)
  {
    Meld.Ausgabe (281, neuNr);
    return Ustring(altNr);
  }
  zhilfe = ArbeitsplanListe->sucheArbeitsplan(altNr);
  if (!zhilfe)
  {
    Meld.Ausgabe (280, altNr);
    return Ustring(altNr);
  }  
  zhilfe->setNr(neuNr);
  return Ustring (zhilfe->getNr());
} // ENDE ArbeitsplanNummerAendern

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring SelectArbeitsplan (const int nr)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(nr);
  if (!zhilfe) 
  {
    Meld.Ausgabe (280, nr);
    return Ustring();
  }  
  return zhilfe->getInfoArbeitsplan();
} // ENDE SelectArbeitsplan

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ErzeugeArbeitsplan (int nr, Ustring afname)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(nr);
  if (zhilfe)
  {
    Meld.Ausgabe (281, nr);
    return Ustring();
  }
  ArbeitsplanListe->Erzeugen(nr, afname);
  return Ustring(nr);
} // ENDE ErzeugeArbeitsplan

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ErzeugeDefaultProzess ( unsigned afnr)
{
  const unsigned lastprozess = 1;
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe)
  {
    Meld.Ausgabe (280, afnr);
    return;
  }
  int pnr = 9000;
  Prozess *zprozess = ProzessListe->suche (pnr);
  while (zprozess)
  {
    zprozess = ProzessListe->suche (++pnr);
  }
  Ustring erg = Ustring(ProzessListe->erzeugen(pnr, lastprozess, afnr));
  if (erg == "1")
  {
    Meld.Ausgabe (95, pnr, afnr);
    char buf[255];
    sprintf (buf, "0: 0 0 0 0 0 64 %d", pnr);
    EreignisListe->Erzeugen (Ustring (buf));
  }
  else
    Meld.Ausgabe (96, afnr);

} // ENDE ErzeugeDefaultProzess

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AuftragsVerwaltung (const char *argv2, const char *argv3, const char *argv4)
{
  if (!strcmp("INFO", argv2))
  {
    sprintf (DlgBuffer, "%s",
             (char*)ArbeitsplanListe->AlleArbeitsplaene().str());
  }
  else
  if (!strcmp("SELECT", argv2))
       sprintf (DlgBuffer, "%s",
        (char*)SelectArbeitsplan(ArgInt(argv3)).str());
  else
  if (!strcmp("AFNRAENDERN", argv2))
       sprintf (DlgBuffer, "%s",
       (char*)ArbeitsplanNummerAendern(ArgInt(argv3), ArgInt(argv4)).str());
  else
  if (!strcmp("AFNAMEAENDERN", argv2))
       sprintf (DlgBuffer, "%s",
       (char*)ArbeitsplanNameAendern(ArgInt(argv3), argv4).str());
  else
  if (!strcmp("ERZEUGEN", argv2)) 
       sprintf (DlgBuffer, "%s",
       (char*)ErzeugeArbeitsplan (ArgInt(argv3), argv4).str());
  else
  if (!strcmp("DEFAULTPROZESS", argv2))
       ErzeugeDefaultProzess (ArgInt(argv3));
  else
  if (!strcmp("LOESCHEN", argv2)) ArbeitsplanListe->Loeschen (ArgInt(argv3));
}  // ENDE AuftragsVerwaltung

// =============================================================
Ustring InfoEingangListe (int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(nr);

  if (!zhilfe) return Ustring();
  return zhilfe->getInfoEingangListe();
}  // ENDE InfoEingangListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring InfoEingang (int afnr, int vnr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);

  if (!zhilfe) return Ustring();
  Eingang* zeingang = zhilfe->SucheEingang(vnr);
  if (!zeingang) return Ustring();
  return zeingang->getInfo(1);
}  // ENDE InfoEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring AendereEingang (int afnr, int enr, Ustring eingang)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  if (zhilfe->AendereEingang (enr, eingang)) return Ustring(1);
  else
  return Ustring(0);
} // ENDE AendereEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ErzeugeEingang (int afnr, int vnr, Ustring eingang)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  if (zhilfe->ErzeugeEingang(vnr, eingang)) return Ustring(1);
  else
  return Ustring(0);
} // ENDE ErzeugeEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void LoescheEingang (int afnr, int vnr)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return;
  zhilfe->LoescheEingang(vnr);
} // ENDE LoescheEingang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EingangnachOben (int afnr, int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);

  if (!zhilfe) return;
  zhilfe->EingangnachOben(nr);
}  // ENDE EingangnachOben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void EingangnachUnten (int afnr, int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);

  if (!zhilfe) return;
  zhilfe->EingangnachUnten(nr);
}  // ENDE EingangnachUnten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void BearbeiteEingang (const char *argv2, const char *argv3, const char *argv4, const char *argv5)
{
  if (!strcmp("INFOEINGANGSLISTE", argv2)) 
       sprintf (DlgBuffer, "%s", (char*)InfoEingangListe(ArgInt(argv3)).str());
  else
  if (!strcmp("INFOEINGANG", argv2))
       sprintf (DlgBuffer, "%s",
                (char*)InfoEingang(ArgInt(argv3), ArgInt(argv4)).str());
  else
  if (!strcmp("AENDEREEINGANG", argv2)) 
       sprintf (DlgBuffer, "%s", 
       (char*)AendereEingang(ArgInt(argv3), ArgInt(argv4), argv5).str());
  else
  if (!strcmp("ERZEUGEEINGANG", argv2)) 
       sprintf (DlgBuffer, "%s", 
       (char*)ErzeugeEingang(ArgInt(argv3), ArgInt(argv4), argv5).str());
  else
  if (!strcmp("LOESCHEEINGANG", argv2)) 
       LoescheEingang(ArgInt(argv3), ArgInt(argv4));
  else
  if (!strcmp("UPEINGANG", argv2)) 
       EingangnachOben (ArgInt(argv3), ArgInt(argv4));
  else
  if (!strcmp("DOWNEINGANG", argv2)) 
       EingangnachUnten (ArgInt(argv3), ArgInt(argv4));
}  // ENDE BearbeiteEingang

// =============================================================
Ustring InfoAusgangListe (int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(nr);

  if (!zhilfe) return Ustring();
  return zhilfe->getInfoAusgangListe();
}  // ENDE InfoAusgangListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring AendereAusgang (int afnr, int anr, Ustring str)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  zhilfe->AendereAusgang(anr, str);
  return Ustring(1);
}  // ENDE AendereAusgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void BearbeiteAusgang (const char *argv2, const char *argv3, const char *argv4, const char *argv5)
{
  if (!strcmp("INFOAUSGANGSLISTE", argv2)) 
       sprintf (DlgBuffer, "%s", (char*)InfoAusgangListe(ArgInt(argv3)).str());
  else
  if (!strcmp("AENDEREAUSGANG", argv2)) 
       sprintf (DlgBuffer, "%s", 
       (char*)AendereAusgang(ArgInt(argv3), ArgInt(argv4), argv5).str());
}  // ENDE BearbeiteAusgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring InfoVorgangListe (int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(nr);

  if (!zhilfe) return Ustring();
  return zhilfe->getInfoVorgangListe();
}  // ENDE InfoVorgangListe

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring InfoVorgang (int afnr, int vnr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);

  if (!zhilfe) return Ustring();
  Vorgang* zvorg = zhilfe->SucheVorgang(vnr);
  if (!zvorg) return Ustring();
  return zvorg->getInfo(1);
}  // ENDE InfoVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring AendereVorgang (int afnr, int vnr, Ustring vorgang)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  if (zhilfe->AendereVorgang (vnr, vorgang)) return Ustring(1);
  else
  return Ustring(0);
} // ENDE AendereVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring ErzeugeVorgang (int afnr, int vnr, Ustring vorgang)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  if (zhilfe->ErzeugeVorgang(vnr, vorgang)) return Ustring(1);
  else
  return Ustring(0);
} // ENDE ErzeugeVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void LoescheVorgang (int afnr, int vnr)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return;
  zhilfe->LoescheVorgang(vnr);
} // ENDE LoescheVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VorgangnachOben (int afnr, int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);

  if (!zhilfe) return;
  zhilfe->VorgangnachOben(nr);
}  // ENDE VorgangnachOben

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VorgangnachUnten (int afnr, int nr )
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);

  if (!zhilfe) return;
  zhilfe->VorgangnachUnten(nr);
}  // ENDE VorgangnachUnten

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void BearbeiteVorgang (const char *argv2, const char *argv3, const char *argv4, const char *argv5)
{
  if (!strcmp("INFOVORGANGSLISTE", argv2))
       sprintf (DlgBuffer, "%s", (char*)InfoVorgangListe(ArgInt(argv3)).str());
  else
  if (!strcmp("INFOVORGANG", argv2))
       sprintf (DlgBuffer, "%s", 
                (char*)InfoVorgang(ArgInt(argv3), ArgInt(argv4)).str());
  else
  if (!strcmp("AENDEREVORGANG", argv2))
       sprintf (DlgBuffer, "%s",
       (char*)AendereVorgang(ArgInt(argv3), ArgInt(argv4), argv5).str());
  else
  if (!strcmp("ERZEUGEVORGANG", argv2))
       sprintf (DlgBuffer, "%s",
       (char*)ErzeugeVorgang(ArgInt(argv3), ArgInt(argv4), argv5).str());
  else
  if (!strcmp("LOESCHEVORGANG", argv2))
       LoescheVorgang(ArgInt(argv3), ArgInt(argv4));
  else
  if (!strcmp("UPVORGANG", argv2))
       VorgangnachOben (ArgInt(argv3), ArgInt(argv4));
  else
  if (!strcmp("DOWNVORGANG", argv2))
       VorgangnachUnten (ArgInt(argv3), ArgInt(argv4));
}  // ENDE BearbeiteVorgang

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring getMessWerte (int afnr)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  return (Ustring(zhilfe->getMesswert()));
}  // ENDE getMessWerte

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ustring setMessWerte (int afnr, int messwert)
{
  Arbeitsplan* zhilfe = ArbeitsplanListe->sucheArbeitsplan(afnr);
  if (!zhilfe) return Ustring(0);
  zhilfe->setMesswert (messwert);
  return Ustring(1);
}  // ENDE setMessWerte

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void BearbeiteMesswert (const char *argv2, const char *argv3, const char*, const char *argv5)
{
  if (!strcmp("GETMESSWERT", argv2))
       sprintf (DlgBuffer, "%s", (char*)getMessWerte(ArgInt(argv3)).str());
  else
  if (!strcmp("SETMESSWERT", argv2))
       sprintf (DlgBuffer, "%s", 
                (char*)setMessWerte(ArgInt(argv3), ArgInt(argv5)).str());
}  // ENDE BearbeiteMesswert


int DlgAblaufplan (ClientData /*clientData*/,
                     Tcl_Interp *interp, int argc, const char *argv[] )
{
  GTSInterpreter = interp;
  if (testprog) {
    Write("DlgAblaufplan: Anfang >%s<", argv[1]);
    for (int i = 2; i <= argc; i++) Write(" >%s< ", argv[i]);
  }
  sprintf(DlgBuffer, "%s", "");


  if ( !strcmp("AUFTRAG", argv[1]) )
             AuftragsVerwaltung (argv[2], argv[3], argv[4]);
  else
  if ( !strcmp("EINGANG", argv[1]) )
             BearbeiteEingang (argv[2], argv[3], argv[4], argv[5]);
  else
  if ( !strcmp("AUSGANG", argv[1]) )
             BearbeiteAusgang (argv[2], argv[3], argv[4], argv[5]);
  else
  if ( !strcmp("VORGANG", argv[1]) )
             BearbeiteVorgang (argv[2], argv[3], argv[4], argv[5]);
  else
  if ( !strcmp("MESSWERT", argv[1]) )
             BearbeiteMesswert (argv[2], argv[3], argv[4], argv[5]);
  else
  {
    sprintf (DlgBuffer, "DlgAbl: Unbekannte Methode \"%.32s\"\n " , argv[1]);
    Tcl_SetResult( interp, DlgBuffer, TCL_STATIC );
    return TCL_ERROR;
  }

  if (testprog) Write("  -> Ende: DlgBuffer >%s<\n", DlgBuffer);
  Tcl_SetResult(interp, DlgBuffer, TCL_STATIC);
  return TCL_OK;
} //  ENDE DlgAblaufplan


