/************************************************************************
**
** FILE  : hastepmisc.c
**
** ZWECK : 
**
** AUTOR : Michael C. Ancutici
**	   Universitaet Stuttgart, Fakultaet Informatik
**
** DATUM : 14.03.93
**									
*************************************************************************/
#include	"hastepmisc.h"
#include	"simget.h"
#include	"habreakmisc.h"
#include	"misc.h"
#include	"sim.h"
#include	"netsize.h"
#include	"hatramisc.h"
#include	"hatra.h"
#include	"haka.H"
#include	"hawin.h"
#include	"ste.h"
#include	"hamess.h"
#include	"simfire.h"
#include	"hamem.h"
#include	"hasetmisc.h"

#include	<unistd.h>
#include 	<X11/Intrinsic.h>
#include 	<X11/StringDefs.h>

#include <stdio.h>



#define TestOnStop() XCheckTypedEvent( MyDisplay, ButtonPress, &ev)


static BOOLEAN		marked;
static char		TCType;
static int		HaStepCounter;
static BOOLEAN		KonfliktON = FALSE;

/*************************************************************************
** FUNKTION:	HaSimInit()
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaStepInit()
{
  SimGetInit();
  marked = FALSE;
}



/*************************************************************************
** FUNKTION:	HaStepMarkT
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
static void HaStepMarkT( Typ, MarkOn)
  char		Typ;
  BOOLEAN	MarkOn;
{
  register int	i;
  register char *c;
  
  if ( (MarkOn) ) {
    marked = TRUE;
    XSetForeground( MyDisplay, TraGC, HaModColor);
  }
  else if ( (marked) ) {
    marked = FALSE;
    XSetForeground( MyDisplay, TraGC, HaTraColor);
  }
  else 
    return;
    
  for (i=0, c=TransCond; i<TRAMAX; i++, c++)
    if (*c == Typ)
      HaTraDrawX( i, TraGC);
  HaKaRedraw();
}  


/*************************************************************************
** FUNKTION:	HaWinSayUnstep
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaWinSayUnstep()
{
  static String Off = 
  	"<Btn3Down>:	HaWinSayMove()	\n\
  	 <Btn1Up>: 	HaLook()	";

  if (HaToggleOn == HaStepToggle) {
    if ( (KonfliktON) ) {
      KonfliktON = FALSE;
      SimTouch();
    }
    HaToggleOn = FALSE;
    XtOverrideTranslations(
  	HaGraphPlane,
  	XtParseTranslationTable( Off));

    XtVaSetValues( HaStepToggle,		
    	XtNstate, FALSE,
    	NULL);
    HaStepMarkT( TCType, FALSE);
  }
}



/*************************************************************************
** FUNKTION:	HaSimReplSteMFromSim
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
static void HaSimReplSteMFromSim()
{
  register int		i;
  register STELLE	**s;
  register int		*m;
  
  if ( (HaSetAnzeigen) ) {
    HaStepMarkT( GEFEUERT, TRUE);
    XSync( MyDisplay, 0);
    usleep( 1500);
    HaStepMarkT( GEFEUERT, FALSE);
  }
  else
    XSync( MyDisplay, 0);

  for (i=0, s=SteStelle, m=Mark; i<STEMAX; i++, s++, m++)
    if ( (*s) && ((*s)->Marke != -*m) )
      HaSteMReplX( i, -*m);
  HaKaRedraw();

  HaMemChangeStepNr( 1);
  HaStepCounter--;
}


/*************************************************************************
** FUNKTION:	HaStepStartGetT
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
static void HaStepStartGetT()
{
  static String On = 
  	 "<Btn3Down>:			\n\
  	  <Btn1Up>: 	HaStepGetT()	";

  HaMessage( HA_SIM_NEED_T);
  
  XtOverrideTranslations(
  	HaGraphPlane,
  	XtParseTranslationTable( On));

  HaStepMarkT( TCType, TRUE);
}


/*************************************************************************
** FUNKTION:	AuswertungFireAgain
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
static void AuswertungFireAgain( erg)
  char	*erg;
{    
  switch (*erg) {

    case KONFLIKT:
      KonfliktON = TRUE;
      HaStepStartGetT();
    break;

    case BREAK_SET:
      HaSimReplSteMFromSim();
      HaWinSayUnstep();
      XtVaSetValues( HaUnbreakToggle,
        XtNsensitive, TRUE,
        NULL);
      HaWinSayBreak( (Widget)0, (XtPointer)0, (XtPointer)0 );
      XtVaSetValues( HaUnbreakToggle,		
      	XtNstate, TRUE,
      	NULL);
    break;

    default:
      HaSimReplSteMFromSim();
      *erg = NORMAL;
    break;
  }
}



/*************************************************************************
** FUNKTION:	AuswertungFire
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
static void AuswertungFire( erg)
  char	erg;
{    
  switch (erg) {

    case TOT:
      HaMessage( HA_SIM_SAY_DEAD);      
      HaWinSayUnstep();
    break;

    case NORMAL:
      HaSimReplSteMFromSim();
    break;

    case KONFLIKT:
      KonfliktON = TRUE;
      HaStepStartGetT();
    break;

    case BREAK_SET:
      HaSimReplSteMFromSim();
      HaWinSayUnstep();
      XtVaSetValues( HaUnbreakToggle,
        XtNsensitive, TRUE,
        NULL);
      HaWinSayBreak( (Widget)0, (XtPointer)0,(XtPointer)0);
      XtVaSetValues( HaUnbreakToggle,		
      	XtNstate, TRUE,
      	NULL);
    break;
  }
}

/*************************************************************************
** FUNKTION:	HaStepGetT
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaStepGetT( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;

{
  int 		TNr;
  char  	erg;
  XEvent	ev;
    
  if (!CellKaGetZiel( 
  	((XButtonEvent *)event)->x,
  	((XButtonEvent *)event)->y, CE_TRANSITION, &TNr)) 
    return;
 
  if (TransCond[ TNr] != TCType)
    return;

  HaMessage( HA_CLEAR);
  HaStepMarkT( TCType, FALSE);

  KonfliktON = FALSE;
  
  erg = SimFireAgain( TNr);
  AuswertungFireAgain( &erg);
  
  while ( (erg == NORMAL) && (HaStepCounter > 0) && !(TestOnStop()) ) {
    erg = SimFire();
    AuswertungFire( erg);
    XSync( MyDisplay, 0);
  }

  if (erg == NORMAL)
    HaWinSayUnstep();
}


/*************************************************************************
** FUNKTION:	HaWinSayStep
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaWinSayStep(  w, client_data, call_data)
  Widget	w;
  XtPointer	client_data, call_data;
{
  char 		erg;
  XEvent	ev;
  static String On = 
  	 "<Btn3Down>:	HaWinSayMove()";
  

  HaMessage( HA_CLEAR);

  if (HaToggleOn == HaStepToggle) {
    HaWinSayUnstep();
    return;    
  }

  XtOverrideTranslations(
  	HaGraphPlane,
  	XtParseTranslationTable( On));
  
  HaStepCounter = (int)client_data;
  HaToggleOn = HaStepToggle;
  HaMessage( HA_CLEAR);
  KonfliktON = FALSE;

  TCType = (HaSetSeriell) ? AKTIV : KONFLIKT;

  do {  
    erg = SimFire();
    AuswertungFire( erg);
  } while ( (erg == NORMAL) && (HaStepCounter > 0) && !(TestOnStop()));

  if (erg == NORMAL)
    HaWinSayUnstep();
}



/*************************************************************************
** FUNKTION:	HaWinSayRun
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaWinSayRun( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;

{

  HaMessage( HA_CLEAR);
  HaWinSayStep( w, (XtPointer)100000, (XtPointer)0);
}