/************************************************************************
**
** FILE  : hakaio.c
**
** ZWECK : 
**
** AUTOR : Michael C. Ancutici
**	   Universitaet Stuttgart, Fakultaet Informatik
**
** DATUM : 14.03.93
**									
*************************************************************************/
#include	"hakaio.h"
#include	"ka.h"
#include	"ste.h"
#include	"tra.h"
#include	"hakadelta.h"
#include	"celltype.h"
#include 	"cellkadel.h"
#include	"harefreshx.h"
#include	"kaio.h"
#include	"hawin.h"
#include	"haka.H"
#include	"haka.h"
#include	"cellkaio.h"


void HaKaSTInsertX( SNr, TNr, k)
  int	SNr, TNr;
  KANTE	*k;
{
  HaKaDClearX( SNr, TNr);
  KaInsert( CE_ST_KANTE, SNr, TNr, k);
  CellSTKaInsert( SNr, TNr);

  HaKaSTDrawX( SNr, TNr, KaGC);
  HaKaDWriteX( SNr, TNr);
}


void HaKaTSInsertX( SNr, TNr, k)
  int	SNr, TNr;
  KANTE	*k;
{
  HaKaDClearX( SNr, TNr);
  KaInsert( CE_TS_KANTE, SNr, TNr, k);
  CellTSKaInsert( SNr, TNr);
  HaKaTSDrawX( SNr, TNr, KaGC);
  HaKaDWriteX( SNr, TNr);
}


/*************************************************************************
** FUNKTION:	HaKaSTRemoveX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaSTRemoveX( SNr, TNr)
  int	SNr, TNr;
{
  KANTE		*pST;
  
  if ( !(pST = KaKante[ SNr][ TNr].NachTrans) )
    return;
  HaKaDClearX( SNr, TNr);			/* DELTAS LOESCHEN	*/
  CellClearRL();
  CellSTKaRemove( SNr, TNr);
  HaKaSTDrawX( SNr, TNr, ClearGC);		/* AUS PIXMAP ENTFERNEN	*/
  HaRefreshXFromRL();

  KaSTRemove( SNr, TNr);
  HaKaDWriteX( SNr, TNr);			/* DELTA SCHREIBEN	*/
} 

/*************************************************************************
** FUNKTION:	HaKaTSRemoveX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaTSRemoveX( SNr, TNr)
  int	SNr, TNr;
{
  KANTE		*pTS;
  
  if ( !(pTS = KaKante[ SNr][ TNr].NachStelle) )
    return;

  HaKaDClearX( SNr, TNr);			/* DELTAS LOESCHEN	*/
  CellClearRL();
  CellTSKaRemove( SNr, TNr);  	
  HaKaTSDrawX( SNr, TNr, ClearGC);		/* AUS PIXMAP ENTFERNEN	*/
  HaRefreshXFromRL();

  KaTSRemove( SNr, TNr);
  HaKaDWriteX( SNr, TNr);			/* DELTA SCHREIBEN	*/
} 



/*************************************************************************
** FUNKTION:	HaKaTSRemove
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaTSRemove( SNr, TNr)
  int	SNr, TNr;
{
  HaKaTSRemoveX( SNr, TNr);
  HaKaRedraw();
} 


/*************************************************************************
** FUNKTION:	HaKaSTRemove
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaSTRemove( SNr, TNr)
  int	SNr, TNr;
{
  HaKaSTRemoveX( SNr, TNr);
  HaKaRedraw();
} 




/*************************************************************************
** FUNKTION:	HaKaRemoveAllToSteX
** ZWECK:	entfernt alle Kanten, die mit dieser Stelle verbunden
**		sind.
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaRemoveAllToSteX( SNr)
  int 	SNr;
{
  register int	i;
  
  for (i=0; i<TRAMAX; i++) {
    if ( (KaKante[ SNr][ i].NachTrans) )
      HaKaSTRemoveX( SNr, i);
    if ( (KaKante[ SNr][ i].NachStelle) )
      HaKaTSRemoveX( SNr, i);
  }
}  



/*************************************************************************
** FUNKTION:	HaKaRemoveAllToTraX
** ZWECK:	entfernt alle Kanten, die mit dieser Trans verbunden
**		sind.
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaRemoveAllToTraX( TNr)
  int 	TNr;
{
  register int	i;
  
  for (i=0; i<STEMAX; i++) {
    if ( (KaKante[ i][ TNr].NachTrans) )
      HaKaSTRemoveX( i, TNr);
    if ( (KaKante[ i][ TNr].NachStelle) )
      HaKaTSRemoveX( i, TNr);
  }
}  
  
  
  
  
/*************************************************************************
** FUNKTION:	HaKaSTInstallX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaSTInstallX( SNr, TNr)
  int	SNr, TNr;
{
  KANTE		*k;
  int		x, y;

  HaKaDClearX( SNr, TNr);
  CellSTKaInsert( SNr, TNr);
  HaKaSTDrawX( SNr, TNr, KaGC);
  /**************** DELTA NEU *************************/
  if (((k = KaKante[ SNr][ TNr].NachTrans)->Ecke)) {
    x = k->Ecke->x;
    y = k->Ecke->y;
  }
  else {
    x = SteStelle[ SNr]->PosStelle.x;
    y = SteStelle[ SNr]->PosStelle.y;
  }
  k->PosDelta.x = x + ( (TraTrans[ TNr]->PosTrans.x - x) >> 1 );
  k->PosDelta.y = y + ( (TraTrans[ TNr]->PosTrans.y - y) >> 1 );

  /**************** DELTA NEU *************************/


  HaKaDWriteX( SNr, TNr);
}


/*************************************************************************
** FUNKTION:	HaKaTSInstallX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaTSInstallX( SNr, TNr)
  int	SNr, TNr;
{
  KANTE		*k;
  int		x, y;

  HaKaDClearX( SNr, TNr);
  CellTSKaInsert( SNr, TNr);
  HaKaTSDrawX( SNr, TNr, KaGC);


  /**************** DELTA NEU *************************/
  if (((k = KaKante[ SNr][ TNr].NachStelle)->Ecke)) {
    x = k->Ecke->x;
    y = k->Ecke->y;
  }
  else {
    x = TraTrans[ TNr]->PosTrans.x;
    y = TraTrans[ TNr]->PosTrans.y;
  }
  k->PosDelta.x = x + ( (SteStelle[ SNr]->PosStelle.x - x) >> 1 );
  k->PosDelta.y = y + ( (SteStelle[ SNr]->PosStelle.y - y) >> 1 );

  /**************** DELTA NEU *************************/


  HaKaDWriteX( SNr, TNr);
}


/*************************************************************************
** FUNKTION:	HaKaSTDeInstallX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaSTDeInstallX( SNr, TNr)
  int	SNr, TNr;
{
  HaKaDClearX( SNr, TNr);			/* DELTAS LOESCHEN	*/
  CellClearRL();
  CellSTKaRemove( SNr, TNr);
  HaKaSTDrawX( SNr, TNr, ClearGC);		/* AUS PIXMAP ENTFERNEN	*/
  HaRefreshXFromRL();

  /*HaKaDWriteX( SNr, TNr);*/			/* DELTA SCHREIBEN	*/
} 

/*************************************************************************
** FUNKTION:	HaKaTSDeInstallX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaTSDeInstallX( SNr, TNr)
  int	SNr, TNr;
{
  HaKaDClearX( SNr, TNr);			/* DELTAS LOESCHEN	*/
  CellClearRL();
  CellTSKaRemove( SNr, TNr);  	
  HaKaTSDrawX( SNr, TNr, ClearGC);		/* AUS PIXMAP ENTFERNEN	*/
  HaRefreshXFromRL();

  /*HaKaDWriteX( SNr, TNr);*/			/* DELTA SCHREIBEN	*/
} 

  
/*************************************************************************
** FUNKTION:	HaKaDeInstallAllToSteX
** ZWECK:	entfernt alle Kanten, die mit dieser Stelle verbunden
**		sind.
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaDeInstallAllToSteX( SNr)
  int 	SNr;
{
  register int	i;
  
  for (i=0; i<TRAMAX; i++) {
    if ( (KaKante[ SNr][ i].NachTrans) )
      HaKaSTDeInstallX( SNr, i);
    if ( (KaKante[ SNr][ i].NachStelle) )
      HaKaTSDeInstallX( SNr, i);
  }
}  


/*************************************************************************
** FUNKTION:	HaKaInstallAllToSteX
** ZWECK:	entfernt alle Kanten, die mit dieser Stelle verbunden
**		sind.
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaInstallAllToSteX( SNr)
  int 	SNr;
{
  register int	i;
  
  for (i=0; i<TRAMAX; i++) {
    if ( (KaKante[ SNr][ i].NachTrans) )
      HaKaSTInstallX( SNr, i);
    if ( (KaKante[ SNr][ i].NachStelle) )
      HaKaTSInstallX( SNr, i);
  }
}  

  
  
/*************************************************************************
** FUNKTION:	HaKaDeInstallAllToTraX
** ZWECK:	entfernt alle Kanten, die mit dieser Trans verbunden
**		sind.
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaDeInstallAllToTraX( TNr)
  int 	TNr;
{
  register int	i;
  
  for (i=0; i<STEMAX; i++) {
    if ( (KaKante[ i][ TNr].NachTrans) )
      HaKaSTDeInstallX( i, TNr);
    if ( (KaKante[ i][ TNr].NachStelle) )
      HaKaTSDeInstallX( i, TNr);
  }
}  
  
  
/*************************************************************************
** FUNKTION:	HaKaInstallAllToTraX
** ZWECK:	entfernt alle Kanten, die mit dieser Trans verbunden
**		sind.
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaKaInstallAllToTraX( TNr)
  int 	TNr;
{
  register int	i;
  
  for (i=0; i<STEMAX; i++) {
    if ( (KaKante[ i][ TNr].NachTrans) )
      HaKaSTInstallX( i, TNr);
    if ( (KaKante[ i][ TNr].NachStelle) )
      HaKaTSInstallX( i, TNr);
  }
}