Windows Develop

Development Platform:
Unix_Linux

xwindow.c：Code Content
							/****************************************************************************
 File Name  : xwindow.c
 Purpose    : provides x-window interface routines
 Release    : Version 1.0
 Date	    : Aug 31,1995
GSNAKE API is jointly developed by the Information Technology Institute (ITI), Singapore, and the School of Applied Science, Nanyang Technological
University (NTU), Singapore. 
These software programs are available to the user without any license or royalty fees. Permission is hereby granted to use, copy, modify, and distribute this software and its documentation for any purpose. ITI and NTU gives no warranty, express, implied, or statuary for the software and/or documentation provided, including, without limitation, waranty of merchantibility and warranty of fitness for a particular purpose. The software provided hereunder is on an "as is"  basis, and ITI and NTU has no obligation to provide maintenance, support, updates, enhancements, or modifications.
GSNAKE API is available for any UNIX compatible system. User feedback, bugs, or software and manual suggestions should be sent via electronic mail to one of the following, who may or may not act on them as he/she desires :
		asschan@ntu.ac.sg
		kflai@iti.gov.sg
***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "gsnake.h"
/* ---- internal constants and variables used by x window manager ---- */
#define COLORMAPSIZE	256
#define ALLOC_COLOR	1		/* allocate color for snaxel */
#define TITLE		"gsnake"
#define VERBOSE		1
#define INCH            72      	/* one inch = 72 points */
#define BORDERWIDTH	5		/* border width = 5 pixels */
static int		FirstTime = 1 ;		/* to raise X window */
static Display         *gDisplay=NULL;		/* display and others */
static int		gScreen;
static Window		gWindow;
static Visual		*gVisual;
static GC       	imageGC;		/* graphic contexts */
static GC		pointGC ;
static GC		rectGC;
static unsigned long 	pixels[COLORMAPSIZE];	/* pixel values */
static int		c_map_size;		/* colormap size */
static XEvent		any_event;
static char 		*Title = NULL;
/* expand ratio for higher level snaxels */
static int              ci_expand = 1;
static int              POINT_DIM = 3;  /* dimension of point in plotting */
static int              POINT_OFF = 0; /* offset in plotting point */
/* ----- internal function prototypes ------ */
int 	xwin_init(short width, short height, char *title, char alloc_color, 
		char verbose);
void 	xwin_close(void);
Display *xwin_setupXWindow(char *DisplayName, char *title, short width, 
		short height, int *screen, Window *window, Visual **visual, 
		int verbose);
void 	xwin_setupGC(unsigned long *pixels, int *c_map_size, char alloc_color);
void xwin_setTitle(char *title)
{
	Title = strdup(title);
}
void xwin_raiseWindow(short width, short height)
{
	if( FirstTime ) {
		xwin_init(width, height, ((Title) ? Title : TITLE), 1, VERBOSE);
		FirstTime = 0 ;		
	}
	
	else
	 	XResizeWindow(gDisplay, gWindow, width, height);
}
/* create an x window of specified dimensions and initialize the graphics
   context to display gray level images and drawing snake points and lines */
xwin_init(
	short 	width, 
	short 	height,		/* size of x window to be raised */
	char 	*title,		/* title of the window */
	char 	alloc_color,	/* 1 : alloc color for points */
	char 	verbose		/* 1 : turns verbose on */
) {	
	/* create and raise X window */
	gDisplay = xwin_setupXWindow((char *) NULL, title, width, height, 
				&gScreen, &gWindow, &gVisual, verbose) ;
	/* create gray level GC */
	xwin_setupGC(pixels, &c_map_size, alloc_color);	
	return (gDisplay) ? 1 : 0 ;
} 
/* close the x window */
void xwin_close(void)
{
	if(gDisplay) XCloseDisplay(gDisplay) ;
}
/* create a raise a simple X window */
Display *xwin_setupXWindow(
	char 	*DisplayName,		/* name of display */
	char	*title,			/* title of window */
	short	width, 
	short	height,			/* width and height of window */
	int	*screen,		/* RETURN : default screen */
	Window  *window,		/* RETURN : created window */
	Visual  **visual,		/* RETURN : POINTER to vidual found */
	int	verbose			/* 1 : set verbose on */
){
	Display *display ;	/* graphic display */
	Window rootWindow ;	/* the root window */
	XSizeHints gHint ;	/* hints to X Server on window raising */
	unsigned long gForegrnd, gBackgrnd ;
	int status, depth ;
	
	/* connect to default X Server */
	display = XOpenDisplay(DisplayName) ;
	if( display == NULL ) { 
      		fprintf(stderr, "nERROR: Cannot connect to X server [%s]n", 
			  XDisplayName(DisplayName) );
      		return NULL ;
   	}
 
   	*screen = DefaultScreen( display);
  	rootWindow = RootWindow( display, *screen);
   	gBackgrnd = WhitePixel( display, *screen);
   	gForegrnd = BlackPixel( display, *screen);
   	
   	*visual = DefaultVisual(display, *screen) ;
   	depth = DefaultDepth(display, *screen) ;
	/* provide hints on where to raise the window */
	gHint.x = 100 ;
	gHint.y = 200 ;
   	gHint.width = width ;	
   	gHint.height =  height ; 
	gHint.flags = PPosition | PSize;
	/* actually create the window */
	*window = XCreateSimpleWindow( display, rootWindow, 
			gHint.x, gHint.y, gHint.width, gHint.height,
			(unsigned int) BORDERWIDTH, gForegrnd, gBackgrnd);
	XSetWMNormalHints(display, *window, &gHint) ;
   	XSelectInput( display, *window, 
			ButtonPressMask | KeyPressMask | ExposureMask |
			ButtonReleaseMask | Button1MotionMask );
	
  	XMapRaised(display, *window);
	XStoreName(display, *window, title);
	XFlush(display) ;
	/* print out information on x window if required */
	if( verbose == 1 ) {
		
			
		fprintf(stdout, "n%s version %d of the %sn",
				ServerVendor(display),
				VendorRelease(display),
				"X Window System") ;
		
		fprintf(stdout, "Color plane depth : %d %snn", depth,
				( (depth == 1) ? "(mono)": "") ) ;
	}
	return display ;
}
/* set-up graphics context */
void xwin_setupGC(
	unsigned long *pixels,
	int *c_map_size,
	char alloc_color
) {
   	XGCValues gc_values;
   	unsigned long mask;
   	XColor xcolor, rgb_color, hw_color;
   	int i, j, status ;
	Colormap color_map;
	
	*c_map_size = 0 ;
	color_map = DefaultColormap(gDisplay, gScreen) ;
		
      	while (XAllocColorCells(gDisplay, color_map, False, NULL, 0,
	     &(pixels[*c_map_size]), 1))
		(*c_map_size)++;
      	xcolor.flags = DoRed | DoGreen | DoBlue;
      	for (i = 0; i < *c_map_size; ++i)
      	{
		xcolor.pixel = pixels[i];
	 	xcolor.red = (unsigned short) (i << 8);
	 	xcolor.green = (unsigned short) (i << 8); 
	 	xcolor.blue = (unsigned short) (i << 8); 
	 	XStoreColor(gDisplay, color_map, &xcolor);
      	}
	/* this is the GC for handling the image */
      	mask = GCForeground | GCBackground | GCLineWidth | GCFunction;
      	gc_values.function = GXcopy;
      	gc_values.foreground = pixels[*c_map_size - 1];
      	gc_values.background = pixels[0];
      	gc_values.line_width = 2 ;
      	imageGC = XCreateGC(gDisplay, gWindow, mask, &gc_values);
	/* this is the GC for handling the points */
	if( alloc_color ) {
		hw_color.pixel = gc_values.foreground ;
		status = XAllocNamedColor(gDisplay, color_map, "red", 
				&hw_color, &rgb_color) ;
		gc_values.foreground = hw_color.pixel ;
	}
		
	pointGC = XCreateGC(gDisplay, gWindow, mask, &gc_values) ;
	XSetForeground(gDisplay, pointGC, (unsigned long) gc_values.foreground);
   
	/* this is the GC for handling the line */
	if( alloc_color ) {
		hw_color.pixel = gc_values.foreground ;
		status = XAllocNamedColor(gDisplay, color_map, "green", 
				&hw_color, &rgb_color) ;
		gc_values.foreground = hw_color.pixel ;
	}
		
	rectGC = XCreateGC(gDisplay, gWindow, mask, &gc_values) ;
	XSetForeground(gDisplay, rectGC, (unsigned long) gc_values.foreground);
}
XImage *xwin_creatXimage(float *data, short height, short width, unsigned char magnify)		
{
	register short i, j, m, n ;
	unsigned char *box ;
	float *dptr ;
	float maxmag, minmag;
	double range ;
	int index ;
	
  	/*  Set up an image data structure for handling the image. */
	box = (unsigned char *) _iMemAlloc(sizeof(unsigned char) * 
			height * width * magnify * magnify) ;
					
	for(i=0, dptr=data, maxmag = minmag = *dptr ; i<height; i++)
	   for(j=0; j<width; j++, dptr++) {
	   	maxmag = MAX(maxmag, *dptr);
	   	minmag = MIN(minmag, *dptr);
	   }
	range = (maxmag - minmag)/0.9 ;	/* use 90% of the range */
	
	/* put values in ximage data pointer */
	for (i = 0, dptr=data; i < height; ++i)
            for (j = 0; j < width; ++j, ++dptr)  {
            	
		index = (int) ((double) c_map_size * (*dptr-minmag)/range);
		
	    	for(m=0; m<magnify; m++)
	    	  for(n=0; n<magnify; n++) 
	    	  	box[(i*magnify+m)*magnify*width + 
	    	  	     j*magnify + n] = pixels[index] ;
	}
	return XCreateImage(gDisplay, DefaultVisual(gDisplay, gScreen), 
			    (unsigned int) 8, ZPixmap, 0, (char *) box, 
			    width*magnify, magnify*height, 8,  
			    width*magnify);   
}
void xwin_drawImg(XImage *ximg, int xoffset, int yoffset)
{
	XPutImage(gDisplay, gWindow, imageGC, ximg, 
		0, 0, xoffset, yoffset, ximg->width, ximg->height) ;
	XFlush(gDisplay) ; 
}
void xwin_DrawLine( short x1, short y1, 
		    short x2, short y2, 
		    unsigned char blowup )
{
	XDrawLine(gDisplay, gWindow, pointGC,
		blowup*x1, blowup*y1, blowup*x2, blowup*y2 );
	XFlush(gDisplay);
}
void xwin_DrawRect(int x1,int y1,int x2,int y2,int mag)
{
	x1 = x1 * mag;
	y1 = y1 * mag;
	x2 = x2 * mag; 
	y2 = y2 * mag;
	
        XDrawLine(gDisplay,gWindow,rectGC,x1,y1,x2,y1);
        XDrawLine(gDisplay,gWindow,rectGC,x1,y1,x1,y2);
	XDrawLine(gDisplay,gWindow,rectGC,x2,y1,x2,y2);
	XDrawLine(gDisplay,gWindow,rectGC,x1,y2,x2,y2);
	XFlush(gDisplay);
}
void xwin_SelRegion( int *sx, int  *sy, int *length, int *height)
{
	
   	int done =_FALSE;
	XEvent event;
	int x=0,y=0 ;
	*sx = *sy = *length = *height = 0;
	fprintf(stdout,"nn Left Button:click and Drag n");
	
	while (!done){
		
		XNextEvent(gDisplay, &event);
		switch (event.type){
			case ButtonPress:
				*sx = x = event.xbutton.x;
				*sy = y = event.xbutton.y;
				XSetFunction(gDisplay,rectGC,GXxor);
				break;
			case ButtonRelease:
				done = _TRUE;
				xwin_DrawRect(*sx,*sy,x,y,1);
				break;
			case MotionNotify:
				if (*sx)
				{
				   xwin_DrawRect(*sx,*sy,x,y,1); 
				   x = event.xbutton.x;
				   y = event.xbutton.y;
				   *length = abs(x-*sx);
				   *height = abs(y-*sy);
				   xwin_DrawRect(*sx,*sy,x,y,1);
				}
				break;
		}
	}
	if (x<*sx) *sx = x;
	if (y<*sy) *sy = y;
}
				
/* initialize the object by specifying significant points (drag) */
void xwin_InitSnakeDrag( short *row, short *col,
                        short *numpts, int spacing)
{
        int done = _FALSE ;
        XEvent event ;
        int x, y;
        fprintf(stdout, "nn  Left Button : Drag, Right Button : Donenn");
        while( !done ) {
            XNextEvent(gDisplay, &event) ;
            switch (event.type) {
                case ButtonPress :      /* initialize first point */
                        *numpts = 0 ;
                        *(col + *numpts) = event.xbutton.x ;
                        *(row + *numpts) = event.xbutton.y ;
                        XFillRectangle(gDisplay, gWindow, pointGC,
                                        *(col + *numpts)+POINT_OFF,
                                        *(row + *numpts)+POINT_OFF,
                                        POINT_DIM, POINT_DIM) ;
                        break ;
                case ButtonRelease :    /* done */
                        done = _TRUE ;
                        break ;
                case MotionNotify :    /* fill points at appropriate distance */                        x = event.xbutton.x ;
                        y = event.xbutton.y ;
                        if( MAX( abs(x-*(col+*numpts)), abs(y-*(row+*numpts)) )
                                >= spacing ) {
                                XFillRectangle(gDisplay, gWindow, pointGC,
                                        x+POINT_OFF, y+POINT_OFF, 
					POINT_DIM, POINT_DIM) ;
                                *numpts += 1 ;
                                *(col + *numpts) = x ;
                                *(row + *numpts) = y ;
                                if( *numpts >= MAX_SNAKEPTS - 1 )
                                        done = _TRUE ;
                        }
                        break ;
                }
        }
}
/* ShapeContour allows manual adjustment of snaxel locations. Requires 
   start of row and column data */
short XgetVicinity(int x,int y, double *row, double *col,short numpts)
{
    short count=0;
    
	while (count< numpts)
	{
		if ((y < *(row+count)+3) && (y > *(row+count)-3))
			if ((x < *(col+count)+3) && (x > *(col+count)-3))
				return count;
		count++;
	}
	return -1;     /* Chosen point is not near any snaxel */
}
	
				
   
void xwin_ShapeContour(XImage *ximg,double *row, double *col,short numpts )
{
	int done = _FALSE, end = _FALSE ;
        XEvent event ;
        int x, y,i;
        int target= -1;
	
        fprintf(stdout, "nn  Left Button : Drag, Right Button : Donenn");
        while( !end ) {
            XNextEvent(gDisplay, &event) ;
            switch (event.type) {
                case ButtonPress :      /* initialize first point */
			if (event.xbutton.button !=Button1) 
			{		
				end = _TRUE;
				XSetFunction(gDisplay,pointGC,GXcopy);
			}
			else
			{
				done = _FALSE;
				x= event.xbutton.x;
				y= event.xbutton.y;
	         		target = XgetVicinity(x,y,row,col,numpts); 
        					
                 	}
                        break ;
                case ButtonRelease :    /* done */
                        done = _TRUE ;
                        if (target != -1)    
                           for (i=0;i<numpts;i++)
                        	XFillRectangle(gDisplay, gWindow, pointGC,
                                	ROUNDOFF(*(col + i)),ROUNDOFF(*(row + i)),
					POINT_DIM, POINT_DIM);
                        	
                        target = -1;
                        break ;
                case MotionNotify :    /* fill points at appropriate distance*/
                        if (target!=-1)
                        {
                                XPutImage(gDisplay, gWindow, imageGC, ximg,
                                	  x-3,y-3,x-3,y-3,POINT_DIM+5,POINT_DIM+5);
                                XFlush(gDisplay) ;	
                                                      
                                x = event.xbutton.x;
                                y = event.xbutton.y;
                                XFillRectangle(gDisplay, gWindow, pointGC,
                                        x, y, POINT_DIM, POINT_DIM) ;
                                *(col + target) = x ;
                                *(row + target) = y ;
			}
                        break;
                           	
               }
        }
}
/* initialize the object by specifying significant points (click) */
void xwin_InitSnakeClick( short *row, short *col,
                        short *numpts)
{
        BOOLEAN done = _FALSE;
        XEvent event;
        fprintf(stdout, "nn  Left Button : Click, Right Button : Donenn");
        *numpts = 0;
        while( !done ) {
                XNextEvent(gDisplay, &event) ;
                if(event.type != ButtonPress) /* only wait for button event */
                        continue ;
                if(event.xbutton.button != Button1)  /* exit button pressed */
                        done = _TRUE ;
                else {
                        *(col + *numpts) = event.xbutton.x ;
                        *(row + *numpts) = event.xbutton.y ;
                        XFillRectangle(gDisplay, gWindow, pointGC,
                                *(col + *numpts)+POINT_OFF,
                                *(row + *numpts)+POINT_OFF,
                                POINT_DIM, POINT_DIM);
                        *numpts += 1;
                }
        }
}
int xwin_MovePoint(XImage *ximg, short Xsrc, short Ysrc,
			short Xdest, short Ydest,
		   int pt_offx, int pt_offy)
{
        XPutImage(gDisplay, gWindow, imageGC, ximg,
                ci_expand*Xsrc, ci_expand*Ysrc, 
		ci_expand*(Xsrc+pt_offx)+POINT_OFF, 
		ci_expand*(Ysrc+pt_offy)+POINT_OFF, 
		POINT_DIM, POINT_DIM) ; 
        XFillRectangle(gDisplay, gWindow, pointGC,
		ci_expand*(Xdest+pt_offx)+POINT_OFF, 
		ci_expand*(Ydest+pt_offy)+POINT_OFF, 
		POINT_DIM, POINT_DIM) ;
        XFlush(gDisplay) ;
        return ( (XCheckTypedWindowEvent(gDisplay, gWindow, ButtonPress,
                        &any_event) == True) ? _FALSE : _TRUE ) ;
}
 
/* set expand ration */
void xwin_setexpandratio(short expand,
			 unsigned char blowup )
{
        ci_expand = (int)expand *(int)blowup;
	POINT_OFF = -(POINT_DIM/2 - (blowup+1)/2) ;
}
void xwin_DrawPoint( short row, short col )
{
	 XFillRectangle(gDisplay, gWindow, pointGC,
			ci_expand*col+POINT_OFF,
			ci_expand*row+POINT_OFF,
			POINT_DIM, POINT_DIM) ;
	 XFlush(gDisplay) ;
}
void xwin_clrpoint( XImage *ximg, short col, short row )
{
	XPutImage(gDisplay, gWindow, imageGC, ximg,
                ci_expand*col, ci_expand*row, 
		ci_expand*col, ci_expand*row, 
		POINT_DIM, POINT_DIM) ;
}

						