/************************************************************************
**
** FILE  : hatramisc.c
**
** ZWECK : 
**
** AUTOR : Michael C. Ancutici
**	   Universitaet Stuttgart, Fakultaet Informatik
**
** DATUM : 14.03.93
**									
*************************************************************************/
#include	"hatramisc.h"
#include	"hawin.h"
#include	"netsize.h"
#include 	"tra.h"
#include 	"hatra.h"
#include	"trawin.h"
#include	"hagraph.h"
#include	"hamess.h"
#include	"celltra.h"
#include	"cell.h"
#include	"colors"

#include <stdio.h>


#define LineWidth( gc, i)   XSetLineAttributes( MyDisplay, gc, 	\
				i, LineSolid, CapRound, JoinMiter)


#define HaCopyTraFromX( x, y)  XCopyArea( MyDisplay,		\
				HaGraphPixmap,			\
				XtWindow( HaGraphPlane),	\
  				TraGC,				\
			  	x-HA_TRA_RAD,y-HA_TRA_RAD,	\
			  	HA_TRA_DM,HA_TRA_DM,		\
			  	x - HA_TRA_RAD, y - HA_TRA_RAD)

#define HaClearTraPixmap()  XFillRectangle( MyDisplay,		\
			  	HaTraPixmap,			\
			  	InvClearGC,			\
			  	0,0,				\
			  	HA_TRA_DM, HA_TRA_DM);		\





/*************************************************************************
** FUNKTION:	
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
static void HaTraDrawIntern( hPixmap, hGC, mx, my)  
  Pixmap	hPixmap;
  GC		hGC;
  int		mx, my; 		
{  
  switch (HaTraDarst) {
    case TRA_0:
      LineWidth( hGC, 3);
      XDrawLine( MyDisplay, hPixmap, hGC, 
	mx, my-HA_TRA_RAD+2, mx, my+HA_TRA_RAD-2);
      LineWidth( hGC, 0);
    break;
    
    case TRA_1:
      LineWidth( hGC, 3);
      XDrawLine( MyDisplay, hPixmap, hGC, 
	mx+HA_TRA_DIA, my-HA_TRA_DIA,
	mx-HA_TRA_DIA, my+HA_TRA_DIA);
      LineWidth( hGC, 0);
    break;

    case TRA_3:
      LineWidth( hGC, 3);
      XDrawLine( MyDisplay, hPixmap, hGC, 
	mx-HA_TRA_RAD, my, 
	mx+HA_TRA_RAD, my);
      LineWidth( hGC, 0);
    break;

    case TRA_5:
      LineWidth( hGC, 3);
      XDrawLine( MyDisplay, hPixmap, hGC, 
	mx-HA_TRA_DIA, my-HA_TRA_DIA,
	mx+HA_TRA_DIA, my+HA_TRA_DIA);
      LineWidth( hGC, 0);
    break;
    
    case TRA_QUAD:
      LineWidth( hGC, 1);
      XDrawRectangle( MyDisplay, hPixmap, hGC,
	mx-HA_TRA_DIA, my-HA_TRA_DIA,
	2*HA_TRA_DIA, 2*HA_TRA_DIA);
      LineWidth( hGC, 0);
    break;
  }
}



/*************************************************************************
** FUNKTION:	HaTraDrawX
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaTraDrawX( TNr, ActualGC)
  int	TNr;
  GC	ActualGC;
{
  HaTraDarst = TraTrans[ TNr]->Darstellung;
  HaTraDrawIntern( HaGraphPixmap, ActualGC,
  	TraTrans[ TNr]->PosTrans.x,
  	TraTrans[ TNr]->PosTrans.y);
}  




/*************************************************************************
** FUNKTION:	HaTraDraw
** ZWECK:	
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaTraDraw( TNr, ActualGC)
  int	TNr;
  GC	ActualGC;
{
  int x, y;
  
  HaTraDarst = TraTrans[ TNr]->Darstellung;
  HaTraDrawIntern( HaGraphPixmap, ActualGC,
  	(x = TraTrans[ TNr]->PosTrans.x),
  	(y =TraTrans[ TNr]->PosTrans.y) );

  HaCopyTraFromX( x, y);
}  


void HaTraSetDarst( d)
  char	d;
{  
  HaTraDarst = d;

  HaClearTraPixmap();
  HaTraDrawIntern( HaTraPixmap, InversGC, HA_TRA_RAD, HA_TRA_RAD);
}


/*************************************************************************
** FUNKTION:	HaTraInit
*************************************************************************/
void HaTraInit()
{
  HaTraPixmap = XCreatePixmap( MyDisplay,
        RootWindowOfScreen( XtScreen( HaShell)),
	HA_TRA_DM, HA_TRA_DM,
 	MyDepth); 	
   	
  HaTraColor = HaGetPixel( TRANSITION_COLOR);
  HaCreateGC( &TraGC, HaTraColor, HaBackColor, GXcopy);

  HaTraSetDarst( TRA_0);
}



/*************************************************************************
** FUNKTION:	HaMovTra
** ZWECK:	Zeichnet Trans an Mausposition und loescht alte Trans
**		Dadurch scheint es, als ob sich die Trans mit dem Mauszeiger
**		mitbewegt.
** INPUT:	Position Mauszeiger
** ANMERK:	Wird bei einem Motion-Event aufgerufen
*************************************************************************/
void HaMovTra( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;
{
  int x = ((XMotionEvent *)event)->x; 
  int y = ((XMotionEvent *)event)->y;		  
  
  HaInversTra( x, y);
  HaInversTra( HaAlt.x, HaAlt.y);

  HaAlt.x = x;
  HaAlt.y = y;
}




/*************************************************************************
** FUNKTION:	HaMovTraStart
** ZWECK:	Zeichnet eine Trans an Position Mauszeiger.
**		Als Vorbereitung fuer HaMoveTra.
** INPUT:	Position Mauszeiger
** ANMERK: 	Wird bei einem Enter-Event aufgerufen.
*************************************************************************/
void HaMovTraStart( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;
{
  HaAlt.x = ((XMotionEvent *)event)->x; 
  HaAlt.y = ((XMotionEvent *)event)->y;		  
  
  HaInversTra( HaAlt.x, HaAlt.y);
}




/*************************************************************************
** FUNKTION:	HaMovTraStop
** ZWECK:	Loescht gezeichnete Trans. Dient als Abschluss fuer 
**		HaTraMov.
** ANMERK: 	Wird bei einem Leave-Event aufgerufen.
*************************************************************************/
void HaMovTraStop( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;
{
  HaInversTra( HaAlt.x, HaAlt.y);
}




/*************************************************************************
** FUNKTION:	HaChangeTra
** ZWECK:	Wechselt die Form der Transition
** EINGABE:	
** AUSGABE:
** RETURN: 	
** ANMERK: 	
*************************************************************************/
void HaChangeTra( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;
{
  if (HaTraDarst < TRA_QUAD)			/* Neue Form bestimmen:	*/
    HaTraDarst++;				/* ACHTUNG:  		*/
  else						/* wohlgeordnet		*/
    HaTraDarst = TRA_0;  			
    
  HaInversTra( HaAlt.x, HaAlt.y);		/* Alte Form aus	*/
  HaClearTraPixmap();				/* Pixmap loeschen	*/    
  HaTraDrawIntern( HaTraPixmap, InversGC, 	/* Neue Form zeichnen	*/
  	HA_TRA_RAD, HA_TRA_RAD);
  HaAlt.x = ((XButtonEvent *)event)->x; 	/* akt. Plane Koord.	*/
  HaAlt.y = ((XButtonEvent *)event)->y;		  
  HaInversTra( HaAlt.x, HaAlt.y);		/* in Plane anzeigen	*/
}


void HaTraON()
{
  if (HaToggleOn == HaTraToggle) {
    HaToggleOn = FALSE;
    HaWinSayTra( (Widget)0, (XtPointer)0, (XtPointer)0);
  }
}

void HaTraOFF()
{
  HaWinSayTra( (Widget)0, (XtPointer)0, (XtPointer)0);
  HaToggleOn = HaTraToggle;
}


/*************************************************************************
** FUNKTION:	HaSetTra
** ZWECK:	Versucht eine Trans zu setzen
** INPUT:	Position Mauszeiger als Transnmittelpunkt
** OUTPUT: 	Trans oder Fehlermeldung
** ANMERK: 	wird bei einem Btn1Up-Event aufgerufen
*************************************************************************/
void HaSetTra( w, event, params, num_params)
  Widget 	w;
  XEvent 	*event;
  String 	*params;
  Cardinal 	*num_params;
{
  char		ergLook;
  int		TNr;
  XtPointer 	d;
  int		x = ((XButtonEvent *)event)->x;
  int		y = ((XButtonEvent *)event)->y;

  /**** ZU NAH AM RAND ? ************************************************/  
  if ( (x < HA_TRA_RAD) 		||
       (y < HA_TRA_RAD) 		||	
       (x > PLANE_WIDTH - HA_TRA_RAD) 	||
       (y > PLANE_HEIGHT - HA_TRA_RAD) ) {
    HaMessage( HA_OBJ_NEAR_BORDER);  	/* kann spaeter genauer sein :	*/
    return;				/* in Abh. von HaTraDarst	*/
  }   
       
  /**** OBJEKT IM WEG ? *************************************************/
  if ( (ergLook = CellTraLookFor( CE_NOTHING,x,y,HaTraDarst)) != CE_OK ) {
    HaMessage( HA_OBJ_NEAR_OBJ);	/* kann spaeter genauer sein :	*/
    return;				/* welches Objekt im Weg ist	*/
  }   
   
  /**** TRANSDATEN IN TraTrans EINTRAGEN *******************************/   
  if ( (TNr = TraNeu( x, y, HaTraDarst)) < 0 ) {
    HaMessage( HA_NO_FREE_TRA);
    return;
  }
  
  HaTraDraw( TNr, TraGC);
  CellTraEin( TNr, x, y, HaTraDarst); 	/* Trans in Cell eintragen	*/

  /**** ATTRIBUTE SETZEN ? **********************************************/
  if ( ((XButtonEvent *)event)->button == 2) {	
    HaTraOFF();
    TraWinPopup( HaGraphPlane, (XtPointer)TNr, d);
    }
  else  
    HaInversTra( HaAlt.x, HaAlt.y);	/* MovTrans wieder einschalten */
    
  HaMessage( HA_CLEAR);
}



/*************************************************************************
** FUNKTION:	HaWinSayTra
** ZWECK:	Ein-/Ausschalter fuer HaMovTra-Funktionen
*************************************************************************/
void HaWinSayTra( w, client_data, call_data)
  Widget	w;
  XtPointer	client_data, call_data;
{
  static String TraMovOn = 
  	"<Motion>: 	HaMovTra()	\n\
  	 <Btn1Up>:	HaSetTra()	\n\
	 <Btn2Up>: 	HaSetTra()	\n\
  	 <Btn3Down>:	HaChangeTra()	\n\
  	 <Enter>: 	HaMovTraStart()	\n\
  	 <Leave>: 	HaMovTraStop()";

  static String TraMovOff = 
  	"<Motion>:			\n\
  	 <Btn1Up>:	HaLook()	\n\
  	 <Btn2Up>:			\n\
  	 <Btn3Down>:	HaWinSayMove()	\n\
  	 <Enter>:			\n\
  	 <Leave>:";
  
  if (!HaToggleOn) {
    HaToggleOn = HaTraToggle;
    XtOverrideTranslations(
  	HaGraphPlane,
  	XtParseTranslationTable( TraMovOn));
  }
  else {
    HaToggleOn = FALSE;
    XtOverrideTranslations(
  	HaGraphPlane,
  	XtParseTranslationTable( TraMovOff));
  }
  HaMessage( HA_CLEAR);
}