gapgraph.c

/****************************************************************************
**
*W  gapgraph.c                  XGAP Source                      Frank Celler
**
**
*Y  Copyright 1995-1997,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
*Y  Copyright 1997,       Frank Celler,                 Huerth,       Germany
*/
#include    "utils.h"
#include    "gapgraph.h"


/****************************************************************************
**

*F  * * * * * * * * * * * * * * local variables * * * * * * * * * * * * * * *
*/

/****************************************************************************
**

*V  GcClear . . . . . . . . . . . . . . . . . . . . . . . used to clear areas
*/
static GC GcClear;


/****************************************************************************
**
*V  GcColormap  . . . . . . . . . . . . . . . . . . . . .  standard color map
*/
static Colormap GcColormap;


/****************************************************************************
**
*V  GcColors  . . . . . . . . . . . . . . . . . . . . . . . . . . color array
*/
static XColor GcColors[C_LAST+1];


/****************************************************************************
**

*F  * * * * * * * * * * * * *  gap graphic widget * * * * * * * * * * * * * *
*/


/****************************************************************************
**

*F  GapGraphInitialize( <request>, <new>, <args>, <nums> )  open a new window
*/
static void GapGraphInitialize ( Widget request, Widget new, ArgList args, Cardinal *nums )
{
    GapGraphicWidget	w = (GapGraphicWidget) new;
    XRectangle          rec[1];
    XGCValues           val;
    Display           * dis;
    static Boolean      first = True;

    /* store width and height of our new window */
    w->gap_graphic.width  = request->core.width;
    w->gap_graphic.height = request->core.height;
    w->gap_graphic.update = True;

    /* create a new list for the graphic objects */
    w->gap_graphic.objs = List(0);

    /* create a pixmap the picture */
    dis = XtDisplay(new);

    /* set display */
    w->gap_graphic.display = dis;

    /* create a graphic context for this window */
    val.function      = GXcopy; 
    val.plane_mask    = AllPlanes;
    val.foreground    = BlackPixel( dis, DefaultScreen(dis) );
    val.background    = WhitePixel( dis, DefaultScreen(dis) );
    val.line_width    = 0;
    val.line_style    = LineSolid;
    val.cap_style     = CapRound;
    val.fill_style    = FillSolid;
    w->gap_graphic.gc = XCreateGC(
		           dis, DefaultRootWindow(dis),
                           GCFunction     | GCPlaneMask | GCForeground
                           | GCBackground | GCLineWidth | GCLineStyle
                           | GCCapStyle   | GCFillStyle,  &val );

    /* if this is the first initialize the global <GcClear> */
    if ( first )
    {
	first = False;
	val.function   = GXcopy;
        val.plane_mask = AllPlanes;
	val.foreground = WhitePixel( dis, DefaultScreen(dis) );
	val.background = BlackPixel( dis, DefaultScreen(dis) );
	GcClear = XCreateGC(
		      dis, DefaultRootWindow(dis),
                      GCFunction|GCPlaneMask|GCForeground|GCBackground,
		      &val );
	GCColorModel(dis);
    }

    /* our viewport could be large then the window */
    rec->x = 0;
    rec->y = 0;
    rec->width  = w->gap_graphic.width;
    rec->height = w->gap_graphic.height;
    XSetClipRectangles( dis, w->gap_graphic.gc, 0, 0, rec, 1, YXSorted );
}


/****************************************************************************
**
*F  GapGraphDestroy( <w> )  . . . . . . . . . . . . . . . .  destroy a window
*/
static void GapGraphDestroy ( Widget w )
{
    GGFreeGapGraphicObjects(w);
}


/****************************************************************************
**
*F  GapGraphResize( <w> ) . . . . . . . . . . . . . .  ignore resize requests
*/
static void GapGraphResize ( Widget w )
{
    GapGraphicWidget	gap = (GapGraphicWidget) w;

    gap->core.width  = gap->gap_graphic.width;
    gap->core.height = gap->gap_graphic.height;
}


/****************************************************************************
**
*F  GapGraphExpose( <w>, <evt> )  . . . . . . . . . . . .  handle an exposure
**
**  The following is defined in "Xlib.h":
**
**    typedef struct {
**      int type;
**      unsigned long serial;
**      Bool send_event;
**      Display *display;
**      Window window;
**      int x, y;
**      int width, height;
**      int count;
**    } XExposeEvent;
**
**/
static void GapGraphExpose ( Widget w, XExposeEvent *evt, Region region )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    TypeList                objs = gap->gap_graphic.objs;
    TypeGapGraphicObject  * obj;
    Int 	            x1,  y1,  x2,  y2;
    UInt                    i;

    /* get the rectangle to be exposed */
    x1 = evt->x;           y1 = evt->y;
    x2 = x1+evt->width-1;  y2 = y1+evt->height-1;

    /* clear it */
    XFillRectangle( gap->gap_graphic.display, XtWindow(gap), GcClear,
		    x1, y1, x2-x1+1, y2-y1+1 );

    /* make a sanity check for the values */
    if ( x1 < 0 )  x1 = 0;
    if ( x2 < 0 )  return;
    if ( y1 < 0 )  y1 = 0;
    if ( y2 < 0 )  return;
    if ( gap->gap_graphic.width  <= x1 )  return;
    if ( gap->gap_graphic.width  <= x2 )  x2 = gap->gap_graphic.width-1;
    if ( gap->gap_graphic.height <= y1 )  return;
    if ( gap->gap_graphic.height <= y2 )  y2 = gap->gap_graphic.height-1;

    /* redraw only objects inside the rectangle */
    for ( i = 0;  i < LEN(objs);  i++ )
	if ( ELM(objs,i) != 0 )
	{
	    obj = (TypeGapGraphicObject*) ELM(objs,i);
	    if (    obj->x+obj->w < x1
		 || obj->y+obj->h < y1
		 || x2 < obj->x
		 || y2 < obj->y )
		continue;
	    GGDrawObject( w, (TypeGapGraphicObject*)ELM(objs,i), True );
	}

    /* flush X11 queue (WHY?) */
    XFlush( gap->gap_graphic.display );
}


/****************************************************************************
**
*V  gapGraphicWidgetClass . . . . . . . . . . . . . . . . widget class record
*/
GapGraphicClassRec gapGraphicClassRec =
{
  { 
    /* core fields              */
    /* superclass		*/	(WidgetClass) &widgetClassRec,
    /* class_name		*/	"GapGraphic",
    /* widget_size		*/	sizeof(GapGraphicRec),
    /* class_initialize		*/	NULL,
    /* class_part_initialize	*/	NULL,
    /* class_inited		*/	FALSE,
    /* initialize		*/	GapGraphInitialize,
    /* initialize_hook		*/	NULL,
    /* realize			*/	XtInheritRealize,
    /* actions			*/	NULL,
    /* num_actions		*/	0,
    /* resources		*/	NULL,
    /* num_resources		*/	0,
    /* xrm_class		*/	NULLQUARK,
    /* compress_motion		*/	TRUE,
    /* compress_exposure	*/	TRUE,
    /* compress_enterleave	*/	TRUE,
    /* visible_interest		*/	FALSE,
    /* destroy			*/	GapGraphDestroy,
    /* resize			*/	XtInheritResize,
        /* FIXME: Dirty Hack by Max, replaced: GapGraphResize,
           I absolutely do *not* know what that means! */
    /* expose			*/	(XtExposeProc)GapGraphExpose,
    /* set_values		*/	NULL,
    /* set_values_hook		*/	NULL,
    /* set_values_almost	*/	XtInheritSetValuesAlmost,
    /* get_values_hook		*/	NULL,
    /* accept_focus		*/	NULL,
    /* version			*/	XtVersion,
    /* callback_private		*/	NULL,
    /* tm_table			*/	NULL,
    /* query_geometry		*/	XtInheritQueryGeometry,
    /* display_accelerator	*/	XtInheritDisplayAccelerator,
    /* extension		*/	NULL
  },

  {
    /* template fields          */
    /* dummy                    */      0
  }
};

WidgetClass gapGraphicWidgetClass = (WidgetClass)&gapGraphicClassRec;


/****************************************************************************
**

*F  * * * * * * * * * * * * * color model functions * * * * * * * * * * * * *
*/


/****************************************************************************
**

*F  GCColorModel( <dis> ) . . . . . . . . . . . . return the color model used
**
**  The following is defined in "Xlib.h":
**
**    typedef struct {
**	      XExtData *ext_data;
**	      VisualID visualid;
**    #if defined(__cplusplus) || defined(c_plusplus)
**	      int c_class;
**    #else
**	      int class;
**    #endif
**	      unsigned long red_mask, green_mask, blue_mask;
**	      int bits_per_rgb;
**	      int map_entries;
**    } Visual;
*/
static Short  gcColorModel = -1;

static String ColorName[C_LAST+1] = {
  "black", "white", "light grey", "dim grey", "red", "blue", "green"
};

Int GCColorModel ( Display *dis )
{
    Int         diff,  a;
    Short       i;
    XColor      c, d;
    int	        cm;		/* as defined in 'Visual' */

    if ( gcColorModel == -1 )
    {
	cm = DefaultVisual( dis, DefaultScreen(dis) )->class;
	GcColormap = DefaultColormap( dis, DefaultScreen(dis) );

	/* reset colors */
	XAllocNamedColor( dis, GcColormap, "black", &c, &d );
	for ( i = 0;  i <= C_LAST;  i++ )
	    GcColors[i] = c;

	/* allocate black and white */
	for ( i = 0;  i <= 1;  i++ )
	{
	    XAllocNamedColor( dis, GcColormap, ColorName[i], &c, &d );
	    GcColors[i] = c;
	}
	gcColorModel = CM_BW;

	/* allocate gray */
	diff = 0;
	for ( i = 2;  i <= C_LAST_GRAY;  i++ )
	{
	    XAllocNamedColor( dis, GcColormap, ColorName[i], &c, &d );
	    GcColors[i] = c;
	    a = (c.red+c.green+c.blue)-(d.red+c.green+c.blue);
	    if ( a < 0 )  diff -= a;  else diff += a;
	    if ( c.red+c.green+c.blue == 0 )
		diff = 65536;
	}
	if ( diff < 300 )
	    gcColorModel = CM_GRAY;

	/* allocate color */
	if ( cm != StaticGray && cm != GrayScale )
	{
	    diff = 0;
	    for ( i = C_LAST_GRAY+1;  i <= C_LAST;  i++ )
	    {
		XAllocNamedColor( dis, GcColormap, ColorName[i], &c, &d );
		a = (c.red+c.green+c.blue)-(d.red+c.green+c.blue);
		if ( a < 0 )  diff -= a;  else diff += a;
		GcColors[i] = c;
		if ( c.red+c.green+c.blue == 0 )
		    diff = 65536;
	    }
	    if ( diff < 300 )
		gcColorModel = (gcColorModel==CM_GRAY)?CM_COLOR5:CM_COLOR3;
	}
    }
    return gcColorModel;
}


/****************************************************************************
**
*F  GCSetColorModel( <dis>, <mod> ) . . . . . . . . . . . . . set color model
*/
void GCSetColorModel ( Display *dis, Int mod, String colors )
{
    Int         e[10];
    Int         i,  j;		/* loop variables */
    Int         p;
    Int         s[10];
    String      ptr;		/* pointer into <tmp> */
    String      tmp;        	/* start of split <colors> */
    XColor      c, d;		/* allocated color */

    if ( gcColorModel != -1 )
	return;
    GcColormap = DefaultColormap( dis, DefaultScreen(dis) );

    /* reset colors */
    XAllocNamedColor( dis, GcColormap, "black", &c, &d );
    for ( i = 0;  i <= C_LAST;  i++ )
	GcColors[i] = c;

    /* set color names */
    if ( strcmp( colors, "default" ) )
    {
	tmp = XtMalloc(strlen(colors)+1);
	strcpy( tmp, colors );
	for ( i = 0, ptr = tmp;  i <= C_LAST && *ptr;  i++ )
	{
	    if ( *ptr == ',' )
		ptr++;
	    else
	    {
		ColorName[i] = ptr;
		while ( *ptr && *ptr != ',' )
		    ptr++;
		if ( *ptr )
		    *ptr++ = 0;
	    }
	}
    }

    /* find ranges for color names */
    p = 0;
    switch ( mod )
    {
	case CM_BW:
	    s[p] = 0;  e[p++] = 1;
	    break;
	case CM_GRAY:
	    s[p] = 0;  e[p++] = C_LAST_GRAY;
	    break;
	case CM_COLOR3:
	    s[p] = 0;  e[p++] = 1;
	    s[p] = C_LAST_GRAY+1;  e[p++] = C_LAST;
	    break;
	case CM_COLOR5:
	    s[p] = 0;  e[p++] = C_LAST;
	    break;
        default:
	    s[p] = 0;  e[p++] = 1;
	    mod = CM_BW;
	    break;
    }

    /* set color model */
    gcColorModel = mod;

    /* allocate colors */
    for ( i = 0;  i < p;  i++ )
	for ( j = s[i];  j <= e[i];  j++ )
	{
	    XAllocNamedColor( dis, GcColormap, ColorName[j], &c, &d );
	    GcColors[j] = c;
	}
}


/****************************************************************************
**

*F  * * * * * * * * * * * gap graphic widget functions  * * * * * * * * * * *
*/


/****************************************************************************
**

*F  GGDrawObject( <w>, <obj>, <flag> )  . . . . . . . . . . .  draw an object
*/
void GGDrawObject ( Widget w, TypeGapGraphicObject *obj, Boolean flag )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    GC                      gc;

    if ( flag )
    {
	gc = gap->gap_graphic.gc;
	XSetForeground( gap->gap_graphic.display, gc,
		        GcColors[obj->color].pixel );
    }
    else
	gc = GcClear;
    switch ( obj->type )
    {
	case T_LINE:
	    XSetLineAttributes( gap->gap_graphic.display, gc,
			        obj->desc.line.w, LineSolid,
			        CapButt, JoinRound );
	    XDrawLine( gap->gap_graphic.display, XtWindow(gap), gc,
		       obj->desc.line.x1, obj->desc.line.y1,
		       obj->desc.line.x2, obj->desc.line.y2 );
	    break;

	case T_CIRCLE:
	    XSetLineAttributes( gap->gap_graphic.display, gc,
			        obj->desc.circle.w, LineSolid,
			        CapButt, JoinRound );
	    XDrawArc( gap->gap_graphic.display, XtWindow(gap), gc,
		      obj->desc.circle.x, obj->desc.circle.y,
		      obj->desc.circle.r, obj->desc.circle.r,
		      0, 360*64 );
	    break;

	case T_DISC:
	    XFillArc( gap->gap_graphic.display, XtWindow(gap), gc,
		      obj->desc.disc.x, obj->desc.disc.y,
		      obj->desc.disc.r, obj->desc.disc.r,
		      0, 360*64 );
	    break;

	case T_RECT:
	    XSetLineAttributes( gap->gap_graphic.display, gc,
			        obj->desc.rect.w, LineSolid,
			        CapButt, JoinRound );
	    XDrawRectangle( gap->gap_graphic.display, XtWindow(gap), gc,
			    obj->desc.rect.x1,
			    obj->desc.rect.y1,
			    obj->desc.rect.x2-obj->desc.rect.x1,
			    obj->desc.rect.y2-obj->desc.rect.y1 );
	    break;

	case T_BOX:
	    XFillRectangle( gap->gap_graphic.display, XtWindow(gap), gc,
			    obj->desc.rect.x1,
			    obj->desc.rect.y1,
			    obj->desc.rect.x2-obj->desc.rect.x1+1,
			    obj->desc.rect.y2-obj->desc.rect.y1+1 );
	    break;

	case T_TEXT:
	    XSetFont( gap->gap_graphic.display, gc,
		      obj->desc.text.font );
	    XDrawString( gap->gap_graphic.display, XtWindow(gap), gc,
			 obj->desc.text.x, obj->desc.text.y,
			 obj->desc.text.str, obj->desc.text.len );
	    break;
    }
}


/****************************************************************************
**
*F  GGAddObject( <w>, <obj> )	. . . . . . . . . . add to widget and draw it
*/
Int GGAddObject ( Widget w, TypeGapGraphicObject *obj )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    TypeList                objs = gap->gap_graphic.objs;
    Int		    	    i;

    /* draw object */
    GGDrawObject( w, obj, True );

    /* find free position in object list */
    for ( i = 0;  i < LEN(objs);  i++ )
	if ( ELM(objs,i) == 0 )
	    break;

    /* add element to the next free position */
    if ( i < LEN(objs) )
	ELM(objs,i) = (Pointer) obj;
    else
	AddList( objs, (Pointer) obj );

    /* and return the position number as object id */
    return i;
}


/****************************************************************************
**
*F  GGFreeObject( <obj> )  . . . . . . . . . . . . free memory used by <obj>
*/
void GGFreeObject ( TypeGapGraphicObject *obj )
{
    switch ( obj->type )
    {
	case T_LINE:
	case T_CIRCLE:
	case T_DISC:
	    break;
	case T_TEXT:
	    XtFree(obj->desc.text.str);
	    break;
    }
    XtFree((char*)obj);
}
   

/****************************************************************************
**
*F  GGRemoveObject( <w>, <pos> ) . . . . . . . . . . remove and undraw <obj>
*/
Boolean GGRemoveObject ( Widget w, Int pos )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    TypeList                objs = gap->gap_graphic.objs;
    TypeGapGraphicObject  * obj;
    XExposeEvent            evt;

    /* find graphic object and clear entry */
    if ( ( obj = (TypeGapGraphicObject*) ELM(objs,pos) ) == 0 )
	return True;
    ELM(objs,pos) = 0;

    /* update this region */
    if ( gap->gap_graphic.fast_update )
    {
	if ( -1==gap->gap_graphic.lx || obj->x<gap->gap_graphic.lx )
	    gap->gap_graphic.lx = obj->x;
	if ( -1==gap->gap_graphic.ly || obj->y<gap->gap_graphic.ly )
	    gap->gap_graphic.ly = obj->y;
	if ( -1==gap->gap_graphic.hx || gap->gap_graphic.hx<=obj->x+obj->w )
	    gap->gap_graphic.hx = obj->x+obj->w+1;
	if ( -1==gap->gap_graphic.hy || gap->gap_graphic.hy<=obj->y+obj->h )
	    gap->gap_graphic.hy = obj->y+obj->h+1;
	GGDrawObject( w, obj, False );
    }
    else if ( gap->gap_graphic.update )
    {
	evt.x      = obj->x;
	evt.y      = obj->y;
	evt.width  = obj->w;
	evt.height = obj->h;
	GapGraphExpose( w, &evt, 0 );
    }
    else
    {
	if ( -1==gap->gap_graphic.lx || obj->x<gap->gap_graphic.lx )
	    gap->gap_graphic.lx = obj->x;
	if ( -1==gap->gap_graphic.ly || obj->y<gap->gap_graphic.ly )
	    gap->gap_graphic.ly = obj->y;
	if ( -1==gap->gap_graphic.hx || gap->gap_graphic.hx<=obj->x+obj->w )
	    gap->gap_graphic.hx = obj->x+obj->w+1;
	if ( -1==gap->gap_graphic.hy || gap->gap_graphic.hy<=obj->y+obj->h )
	    gap->gap_graphic.hy = obj->y+obj->h+1;
    }

    /* free memory and return that we did something */
    GGFreeObject(obj);
    return False;
}


/****************************************************************************
**
*F  GGStartRemove( <w> ) . . . . . . . . . . . . start a sequence of removes
*/
void GGStartRemove ( Widget w )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;

    gap->gap_graphic.update = False;
    gap->gap_graphic.lx     = -1;
    gap->gap_graphic.hx     = -1;
    gap->gap_graphic.ly     = -1;
    gap->gap_graphic.hy     = -1;
}


/****************************************************************************
**
*F  GGStopRemove( <w> )  . . .  stop a sequence of removes and update window
*/
void GGStopRemove ( Widget w )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    XExposeEvent            evt;

    gap->gap_graphic.update = True;
    evt.x      = gap->gap_graphic.lx;
    evt.y      = gap->gap_graphic.ly;
    evt.width  = gap->gap_graphic.hx - gap->gap_graphic.lx + 1;
    evt.height = gap->gap_graphic.hy - gap->gap_graphic.ly + 1;
    GapGraphExpose( w, &evt, 0 );
}


/****************************************************************************
**
*F  GGFastUpdate( <w>, <flag> ) . . . . . . . . . . .  en/disable fast update
*/
void GGFastUpdate ( Widget w, Boolean flag )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    XExposeEvent            evt;

    if ( gap->gap_graphic.fast_update == flag || !gap->gap_graphic.update )
	return;
    gap->gap_graphic.fast_update = flag;
    if ( !flag )
    {
	evt.x      = gap->gap_graphic.lx;
	evt.y      = gap->gap_graphic.ly;
	evt.width  = gap->gap_graphic.hx - gap->gap_graphic.lx + 1;
	evt.height = gap->gap_graphic.hy - gap->gap_graphic.ly + 1;
	GapGraphExpose( w, &evt, 0 );
    }
    else
    {
	gap->gap_graphic.lx = -1;
	gap->gap_graphic.hx = -1;
	gap->gap_graphic.ly = -1;
	gap->gap_graphic.hy = -1;
    }

}


/****************************************************************************
**
*F  GGFreeAllObjects( <w> )  . . . . .  remove and undraw all window objects
*/
void GGFreeAllObjects ( Widget w )
{
    GapGraphicWidget    gap = (GapGraphicWidget) w;
    TypeList            objs = gap->gap_graphic.objs;
    Int                 i;

    for ( i = 0;  i < LEN(objs);  i++ )
	if ( ELM(objs,i) != 0 )
	    GGFreeObject(ELM(objs,i));
    XFillRectangle( gap->gap_graphic.display, XtWindow(gap), GcClear,
		    0, 0, gap->gap_graphic.width, gap->gap_graphic.height );
    LEN(objs) = 0;
}


/****************************************************************************
**
*F  GGFreeGapGraphicObjects( <w> ) free all objects/list associated with <w>
*/
void GGFreeGapGraphicObjects ( Widget w )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    TypeList                objs = gap->gap_graphic.objs;

    if ( objs == 0 )
	return;
    GGFreeAllObjects(w);
    XtFree((char*)(objs->ptr));
    XtFree((char*)(objs));
    gap->gap_graphic.objs = 0;
}


/****************************************************************************
**
*F  GGResize( <w> )  . . . . . . . . . . . . . . . . . . . . . .  resize <w>
*/
void GGResize ( Widget w, Int width, Int height )
{
    GapGraphicWidget        gap = (GapGraphicWidget) w;
    XtWidgetGeometry        req;
    XRectangle              rec[1];

    /* enter new dimensions */
    req.width  = gap->gap_graphic.width  = width;
    req.height = gap->gap_graphic.height = height;
    req.request_mode = CWWidth | CWHeight;

    /* and make request, ignore the result */
    XtMakeGeometryRequest( w, &req, 0 );
    XtResizeWidget( w, (Dimension) width, (Dimension) height, 0 );
    gap->gap_graphic.width  = gap->core.width  = width;
    gap->gap_graphic.height = gap->core.height = height;

    /* and set new clipping */
    rec->x = 0;
    rec->y = 0;
    rec->width  = gap->gap_graphic.width;
    rec->height = gap->gap_graphic.height;
    XSetClipRectangles(XtDisplay(w),gap->gap_graphic.gc,0,0,rec,1,YXSorted);
}


/****************************************************************************
**

*E  gapgraph.c  . . . . . . . . . . . . . . . . . . . . . . . . . . ends here
*/