/************************************************************************
**
** FILE  : kaio.c
**
** ZWECK : 
**
** AUTOR : Michael C. Ancutici
**	   Universitaet Stuttgart, Fakultaet Informatik
**
** DATUM : 14.03.93
**									
*************************************************************************/
#include	"kaio.h"
#include	"ka.h"
#include	"netsize.h"
#include	"celltype.h"
#include	"ste.h"
#include	"tra.h"



/*************************************************************************
** FUNKTION:	KaInsert
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void KaInsert( Typ, SNr, TNr, k)
  char		Typ;
  int		SNr;
  int		TNr;
  KANTE		*k;
{  
  OBJECT	*O;
  
  O = (OBJECT *)malloc( sizeof( OBJECT));
  O->typ 	= Typ;
  O->Nr1 	= SNr;
  O->Nr2 	= TNr;
  O->next 	= NULL;
  k->OrgKa	= O;

  O = (OBJECT *)malloc( sizeof( OBJECT));
  O->Nr1 	= SNr;
  O->Nr2 	= TNr;
  O->next 	= NULL;
  
  if (Typ == CE_ST_KANTE) {
    O->typ 	= CE_ST_KANTE_DELTA;
    k->OrgKaD	= O;
    KaKante[ SNr][ TNr].NachTrans = k; 
  }  
  else {
    O->typ 	= CE_TS_KANTE_DELTA;
    k->OrgKaD	= O;
    KaKante[ SNr][ TNr].NachStelle = k; 
  }
}




/*************************************************************************
** FUNKTION:	
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void KaInit()
{
  register int		i;
  register KANTE	**k;
  int			max = 2*STEMAX*TRAMAX;
  
  k = &(KaKante[ 0][ 0].NachTrans);
  
  KaSDisp = 2*STEMAX;
  KaTDisp = 2*TRAMAX;
  for (i = 0; i < max; i++, k++)
    *k = NULL;
}


#ifdef HALLO

/*************************************************************************
** FUNKTION:	KaNeu
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
int KaNeu( delta, SNr, TNr, ENeuNr, Ecke)
  int		delta;
  int		SNr;
  int		TNr;
  int		ENeuNr;
  ECKE		*Ecke;
{
  KANTE		*k, *h;
  OBJECT	*O, *OD;
  int		x, y;
  
  O = (OBJECT *)malloc( sizeof( OBJECT));
  OD = (OBJECT *)malloc( sizeof( OBJECT));
  O->Nr1 = OD->Nr1 = SNr;
  O->Nr2 = OD->Nr2 = TNr;
  O->next = OD->next = NULL;
  
  k = (KANTE *)malloc( sizeof( KANTE));
  
  k->NegativKante = FALSE;
  k->delta = delta;
  k->ENeuNr = ENeuNr;
  k->Ecke = Ecke;

  if (delta < 0) {				/* ST-KANTE		*/
    O->typ = CE_ST_KANTE;
    OD->typ = CE_ST_KANTE_DELTA;
    k->OrgKa = O;
    k->OrgKaD = OD;
    if ( (Ecke == NULL) &&			/* falls Kante und Gegen*/
    	 (h = KaKante[ SNr][ TNr].NachStelle) &&  
    	 (h->Ecke == NULL) ) {			/* kante uebereinander-	*/
      k->PosDelta.x = h->PosDelta.x;		/* liegen, werden die 	*/
      k->PosDelta.y = h->PosDelta.y;		/* Koord von dort uebern.*/
    }
    else {
      if (Ecke) {
        x = Ecke->x;
        y = 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 );
    }
    KaKante[ SNr][ TNr].NachTrans = k; 
  }
  else {					/* TS-KANTE		*/
    O->typ = CE_TS_KANTE;
    OD->typ = CE_TS_KANTE_DELTA;
    k->OrgKa = O;
    k->OrgKaD = OD;
    if ( (Ecke == NULL) &&			/* falls Kante und Gegen*/
    	 (h = KaKante[ SNr][ TNr].NachTrans) &&  
    	 (h->Ecke == NULL) ) {			/* kante uebereinander-	*/
      k->PosDelta.x = h->PosDelta.x;		/* liegen, werden die 	*/
      k->PosDelta.y = h->PosDelta.y;		/* Koord von dort uebern.*/
    }
    else {
      if (Ecke) {
        x = Ecke->x;
        y = 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 );
    }
    KaKante[ SNr][ TNr].NachStelle = k; 
  }
}

#endif

int KaNeu( delta, SNr, TNr, ENeuNr, Ecke)
  int		delta;
  int		SNr;
  int		TNr;
  int		ENeuNr;
  ECKE		*Ecke;
{
  KANTE		*k, *h;
  int		x, y;
  
  if ( !(k = (KANTE *)malloc( sizeof( KANTE))) )
    return -1;
  
  k->NegativKante 	= FALSE;
  k->delta 		= delta;
  k->ENeuNr 		= ENeuNr;
  k->Ecke 		= Ecke;

  if (delta < 0) {				
    /**** ST-KANTE *******************************************************/
    if ( !(Ecke) && (h = KaKante[ SNr][ TNr].NachStelle) && !(h->Ecke) ) {	
      k->PosDelta.x = h->PosDelta.x;	
      k->PosDelta.y = h->PosDelta.y;	
    }
    else {
      if (Ecke) {
        x = Ecke->x; 
        y = 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 );
    }
    KaInsert( CE_ST_KANTE, SNr, TNr, k);
    return 1;
  }  
  else { 					
    /**** TS-KANTE *******************************************************/
    if ( !(Ecke) && (h = KaKante[ SNr][ TNr].NachTrans) && !(h->Ecke) ) {			
      k->PosDelta.x = h->PosDelta.x;	
      k->PosDelta.y = h->PosDelta.y;	
    }
    else {
      if (Ecke) {
        x = Ecke->x;
        y = 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 );
    }
    KaInsert( CE_TS_KANTE, SNr, TNr, k);
    return 1;
  }
}



/*************************************************************************
** FUNKTION:	KaSTInsert
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
KaSTInsert( SNr, TNr, k)
  int		SNr;
  int		TNr;
  KANTE		*k;
{  
  OBJECT	*O;
  
  O = (OBJECT *)malloc( sizeof( OBJECT));
  O->typ 	= CE_ST_KANTE;
  O->Nr1 	= SNr;
  O->Nr2 	= TNr;
  O->next 	= NULL;
  k->OrgKa	= O;

  O = (OBJECT *)malloc( sizeof( OBJECT));
  O->typ 	= CE_TS_KANTE;
  O->Nr1 	= SNr;
  O->Nr2 	= TNr;
  O->next 	= NULL;
  k->OrgKa	= O;
  
  KaKante[ SNr][ TNr].NachTrans = k; 
}




/*************************************************************************
** FUNKTION:	KaSTRemove
** ZWECK:	entfernt ST-Kante aus KaKante
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void KaSTRemove( SNr, TNr)
  int SNr, TNr;
{
  KANTE	*pST;
  ECKE 	*e, *d;

  pST = KaKante[ SNr][ TNr].NachTrans;
  if ( (e = pST->Ecke) ) 
    while ( (d = e) ) { 
      e = e->next;
      free( d);
    }  

  free( (OBJECT *)(pST->OrgKa) );
  free( (OBJECT *)(pST->OrgKaD) );
  free( pST);
  KaKante[ SNr][ TNr].NachTrans = NULL;
}


/*************************************************************************
** FUNKTION:	KaTSRemove
** ZWECK:	entfernt TS-Kante aus KaKante
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void KaTSRemove( SNr, TNr)
  int SNr, TNr;
{
  KANTE	*pTS;
  ECKE 	*e, *d;

  pTS = KaKante[ SNr][ TNr].NachStelle;
  if ( (e = pTS->Ecke) ) 
    while ( (d = e) ) { 
      e = e->next;
      free( d);
    }  

  free( (OBJECT *)(pTS->OrgKa) );
  free( (OBJECT *)(pTS->OrgKaD) );
  free( pTS);
  KaKante[ SNr][ TNr].NachStelle = NULL;
}