Example #1
0
static void QInitColors( void )

{
	XColor color,exact;
	Status result;
	int i;

	if( MAXCOLOR < 16 ) 
		Error("xgraph: Error in dimension of color table");

	MyColormap = XDefaultColormap(MyDisplay,MyScreen);

	for(i=0;i<16;i++) {
		result=XAllocNamedColor(MyDisplay,MyColormap,MyColorNames[i]
			,&color,&exact);

		if(result)
			MyColors[i]=color;
		else {
			Error("QInitColors : Error allocating color");
		}
	}

	MaxColors = 16;
}
/*
 Assumes a Pseudo graphic display.
 */
void init_colormaps (Display *dpy)
{
   screen = XDefaultScreen (dpy);

   fprintf(stderr, "Number of display cells = %d\n",
	   XDisplayCells(dpy, screen));
   fprintf(stderr, "Number of display planes = %d\n",
	   XDisplayPlanes(dpy, screen));

   colormap = XDefaultColormap(dpy, screen);
   while (XAllocColorCells(display_, colormap, False, NULL, 0, 
			   &(pixels[cmapsize]), 1))
     cmapsize++;
   
   cmapsize = (cmapsize > 60) ? 60 : cmapsize;
   fprintf(stderr, "Number of colors available = %d\n", cmapsize);

   if (cmapsize<5)
     {
	fprintf(stderr, "Number of colors available = %d\n", cmapsize);
	fprintf(stderr, "This is too few to run the display software.\n");
	fprintf(stderr, "Shut down windows, or restart X server.\n");
	exit(-1);      
     }
  
   /* build a grey scale colormap as a default, so that other programs */
   /* can't grab the colors*/
   {
      XColor xcolor;
      int i;
      
      xcolor.flags= DoRed | DoGreen | DoBlue;
      for (i = 0 ; i < cmapsize; i++) {
	 xcolor.pixel = pixels[i];
	 xcolor.red = (unsigned short) (i<<8);
	 xcolor.green = (unsigned short) (i<<8);
	 xcolor.blue = (unsigned short) (i<<8);
	 XStoreColor (display_, colormap, &xcolor);
      }
   }
   
  /* Generate global gamma correction table for this display */
  {
    Pixel index;
    double gamma = 1.0/1.0;
    
    for(index =0; index < 255; index++) {
      GammaCorrect[index] = (Pixel)(0.5 + 255.0 * 
				     (double) pow((double)(index)/255.0, 
						  gamma));
    }
  }

  /* Set up the internal histogram tables*/
  translate_init();

  return;
}
Example #3
0
int
SetPixmapsBackground(Image * image, Drawable drawable, Pixel color)
{
  XpmImage xpmimage;
  XpmAttributes xpmattr;
  XpmColorSymbol xpmcolor[1];
  unsigned int i;

  xpmattr.valuemask = XpmCloseness;
  xpmattr.closeness = 32768;

  /*
   * By default, the XPM library assumes screen 0, so we have
   * to pass in the real values. Submitted by Caveh Frank Jalali
   */
  xpmattr.valuemask |= XpmVisual | XpmColormap | XpmDepth;
  xpmattr.visual = Scr->d_visual;
  xpmattr.colormap = XDefaultColormap(dpy, Scr->screen);
  xpmattr.depth = Scr->d_depth;

  if (XpmCreateXpmImageFromPixmap(dpy, image->pixmap, image->mask, &xpmimage, &xpmattr) != XpmSuccess)
  {
    fprintf(stderr, "Failed to XpmCreateImage\n");
    return (0);
  }

  for (i = 0; i < xpmimage.ncolors; i++)
    if (!strcmp(xpmimage.colorTable[i].c_color, "None"))
      break;

  if (i < xpmimage.ncolors)
  {
    XFreePixmap(dpy, image->pixmap);
    XFreePixmap(dpy, image->mask);

    xpmcolor[0].name = NULL;
    xpmcolor[0].value = "none";
    xpmcolor[0].pixel = color;

    xpmattr.colorsymbols = xpmcolor;
    xpmattr.numsymbols = 1;
    xpmattr.valuemask |= XpmColorSymbols;

    XpmCreatePixmapFromXpmImage(dpy, drawable, &xpmimage, &image->pixmap, &image->mask, &xpmattr);
  }

  i = xpmimage.ncolors;
  XpmFreeXpmImage(&xpmimage);

  return (i);
}
Example #4
0
///////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////
CXWindow::CXWindow(int SizeX, int SizeY)
{
 display = XOpenDisplay(0);
 FATAL(!display);
 win = XCreateSimpleWindow(display,
                           DefaultRootWindow(display),
                           0,
                           0,
                           SizeX,
                           SizeY,
                           0, // Border width
                           0,
                           0);
 {
  XGCValues gcv;
  gcv.graphics_exposures = False;
  gc = XCreateGC(display, win, GCGraphicsExposures, &gcv);
 }
 screen = XDefaultScreen(display);
 pvis = XDefaultVisual(display, screen);
 map = XDefaultColormap(display,DefaultScreen(display));
 XColor exact;
 XAllocNamedColor(display, map, "white", &White, &exact);
 XAllocNamedColor(display, map, "black", &Black, &exact);
 XAllocNamedColor(display, map, "grey41", &DimGrey, &exact);
 XAllocNamedColor(display, map, "grey82", &LightGrey, &exact);

 if (pvis->red_mask && pvis->green_mask && pvis->blue_mask)
 {
  RMult = MultValue(pvis->red_mask);
  RMax = MaxValue(pvis->red_mask);
  GMult = MultValue(pvis->green_mask);
  GMax = MaxValue(pvis->green_mask);
  BMult = MultValue(pvis->blue_mask);
  BMax = MaxValue(pvis->blue_mask);
 }
 else 
  RMult = RMax = GMult = GMax = BMult = BMax = 0;

 wm_delete_window = XInternAtom(display, "WM_DELETE_WINDOW", 0);
 XSetWMProtocols(display, win, &wm_delete_window, 1);

 XMapRaised(display, win);
}
Example #5
0
static void
LoadXPMImage(char *path, Image * img, Pixel color)
{
  XpmAttributes attributes;
  XpmColorSymbol xpmcolor[1];
  int ErrorStatus;

  attributes.valuemask = XpmReturnPixels;

  attributes.valuemask |= XpmCloseness;
  attributes.closeness = 32768;

  if (color)
  {
    xpmcolor[0].name = NULL;
    xpmcolor[0].value = "none";
    xpmcolor[0].pixel = color;

    attributes.colorsymbols = xpmcolor;
    attributes.numsymbols = 1;
    attributes.valuemask |= XpmColorSymbols;
  }

  /*
   * By default, the XPM library assumes screen 0, so we have
   * to pass in the real values. Submitted by Caveh Frank Jalali
   */
  attributes.valuemask |= XpmVisual | XpmColormap | XpmDepth;
  attributes.visual = Scr->d_visual;
  attributes.colormap = XDefaultColormap(dpy, Scr->screen);
  attributes.depth = Scr->d_depth;

  if ((ErrorStatus = XpmReadFileToPixmap(dpy, Scr->Root, path, &img->pixmap, &img->mask, &attributes)) != XpmSuccess)
  {
    img->pixmap = None;
  }
  else
  {
    img->height = attributes.height;
    img->width = attributes.width;
    img->type = IMAGE_TYPE_XPM;
  }

}
Example #6
0
/*
 *  Main program
 */
int main (int argc, char **argv)
{

    Arg arg[1] ;

    MrmInitialize ();

    /*
     *  Initialize the toolkit.  This call returns the id of a "shell,"
     *  whose only child should be the main window of the application.
     */

    CommonTestInit(argc, argv);

    XtSetArg (arg[0], XtNallowShellResize, TRUE) ;
    XtSetValues (Shell1, arg, 1) ;

    if(argc>1 && argv[1]){global_current_file=stringdup(argv[1]);}

    dpy = XtDisplay(Shell1);
    cmap = XDefaultColormap(dpy,0);

    XtGetApplicationResources(Shell1,
			      &data,
			      resources,
			      XtNumber(resources),
			      NULL,
			      0);

    /*
     *  Define the Mrm.hierarchy 
     */

    if (MrmOpenHierarchy (num_uid_files,	            /* number of files	    */
			uid_files, 	     	    /* files     	    */
			NULL,			    /* os_ext_list (null)   */
			&s_MrmHierarchy)	    /* ptr to returned id   */
			!= MrmSUCCESS) {
	printf ("Color: cannot open UID hierarchy.\n\
     Check UIDPATH environment variable\n\
     Goodbye.");
	return(0);
     }
int Visualiza(int largura, int altura, struct ponto2D * P) {
	Display * display;
	GC gc;
	Window win, root_window;
	unsigned long valuemask = 0;
	XGCValues values;
	XColor cor;
	int x = 0, y = 0, screennumber, espessura = 10, i;
	unsigned long white_pixel, black_pixel;
	display = XOpenDisplay(NULL);
	screennumber = DefaultScreen(display);
	root_window = RootWindow(display, screennumber);
	black_pixel = BlackPixel(display,screennumber);
	white_pixel = WhitePixel(display, screennumber);
	win = XCreateSimpleWindow(display,root_window,x,y,largura,altura,espessura,black_pixel,white_pixel);
	XMapWindow(display, win);
	gc = XCreateGC(display, win, valuemask, &values);
	XSync(display, False);
	XSetForeground(display, gc, white_pixel);
	XSetBackground(display, gc, black_pixel);
	XAllocNamedColor(display, XDefaultColormap(display, screennumber), "#FF7F00", &cor, &cor);
	XSetForeground(display, gc, cor.pixel);
	for (i=1;i<=8;++i) 
		XDrawPoint(display, win, gc, P[i].x, P[i].y);
	Desenha_reta(display, gc, win, P[1], P[2]);
	Desenha_reta(display, gc, win, P[3], P[1]); 
	Desenha_reta(display, gc, win, P[4], P[2]); 
	Desenha_reta(display, gc, win, P[3], P[4]);
	Desenha_reta(display, gc, win, P[5], P[6]);
	Desenha_reta(display, gc, win, P[8], P[6]); 
	Desenha_reta(display, gc, win, P[7], P[5]); 
	Desenha_reta(display, gc, win, P[7], P[8]);
	Desenha_reta(display, gc, win, P[3], P[7]);
	Desenha_reta(display, gc, win, P[4], P[8]);
	Desenha_reta(display, gc, win, P[1], P[5]);
	Desenha_reta(display, gc, win, P[2], P[6]);
	XFlush(display);
	getchar();
	XFreeGC(display,gc);
	XCloseDisplay(display);
	return 0;
}
Example #8
0
void FindPixel (char *windowName, int x, int y, Display *display, Window rootWindow)
{
	Window parent;
	Window *children;
	Window *child;
	XImage *image;
	XWindowAttributes winAttr;
	XColor color;
	XTextProperty wmName;

	unsigned int noOfChildren;
	unsigned long pixel;
	int status;
	int i, red, green, blue;
	char **list;

	status = XGetWMName (display, rootWindow, &wmName);

	if ((status) && (wmName.value) && (wmName.nitems)) {
		if (strcmp(windowName, wmName.value) == 0) {
			XGetWindowAttributes(display, rootWindow, &winAttr);
			image = XGetImage(display, rootWindow, 0, 0, winAttr.width, winAttr.height, XAllPlanes(), ZPixmap);
			color.pixel = XGetPixel(image, x, y);
			XQueryColor(display, XDefaultColormap(display, XDefaultScreen(display)), &color);
			red = floor(color.red * 0.003891051);
			green = floor(color.green * 0.003891051);
			blue = floor(color.blue * 0.003891051);

			printf("%i %i %i\n", red, green, blue);
		}
	}
	
	
	status = XQueryTree (display, rootWindow, &rootWindow, &parent, &children, &noOfChildren);
	
	for (i=0; i < noOfChildren; i++) {
		FindPixel (windowName, x, y, display, children[i]);
	}
	
	XFree ((char*) children);
}
Example #9
0
/* ------------------------------------------------------------------ */ 
int initGraphics() 
{
  theDisplay = XOpenDisplay(XDisplayName(NULL));
  if (theDisplay == NULL) {
    printf("You need to run the program under X-window.\n\n");
    exit(1);
  }
  theScreen  = XDefaultScreen(theDisplay);
  rootW      =  RootWindow(theDisplay, theScreen);
  theGC      = XDefaultGC(theDisplay, theScreen);
  theCmap    = XDefaultColormap(theDisplay, theScreen);
  theVisual  =  DefaultVisual(theDisplay, theScreen);
  theDepth   = XDefaultDepth(theDisplay, theScreen);
  // fprintf(stderr, "Visual %x Depth %d\n",  theVisual, theDepth);

  pScreen    = XDefaultScreenOfDisplay(theDisplay);
  sW         = XWidthOfScreen(pScreen);
  sH         = XHeightOfScreen(pScreen);
  theFont    = XLoadFont(theDisplay, FONT10 );
  XSetFont(theDisplay, theGC, theFont);

  return 0;
}
Example #10
0
void InitXGraphics(int argc, char **argv, int ny, int nx, int nd, 
		   MET_MAP_PIX *** MetMap)
{
  /* following is for the X11 libraries */

  int i, x, y, screen;		/* screen is an int. */
  int border_width;
  int c1, c2, c3;
  float re, best_re;
  long dy, dx;
  int best_e, best_ndx, best_ndy;
  int el, ndxl, ndyl;
  int buf = 50;

#ifdef HAVE_X11
  Colormap cmap;		/* map from pixel values to colors */
  char *window_name = "DHSVM Realtime Display", *display_name = NULL;
  XSizeHints size_hints;

  /* connect to Xserver */

  if ((display = XOpenDisplay(display_name)) == NULL) {
    fprintf(stderr, "InitXGraphics: cannot connect to X server %s\n",
	    XDisplayName(display_name));
    exit(-1);
  }

  /* get screen size */

  screen = DefaultScreen(display);

  dx = 0.95 * DisplayWidth(display, screen);
  dy = 0.95 * DisplayHeight(display, screen);

  border_width = 4;
  x = 0;
  y = 0;

  /* figure out the actual size of the window and stuff */

  /* now we need to figure out the expansion factor for the number of graphs */
  /* want to maximize the size of each graph while constrained by the
     number of graphs and the screen size */
  /* save top 20 pixels of the display for the date counter */
  /* save 40 pixels for the X11 window title bar- allocated by system */
  /* save left 10 pixels for border */
  dx = dx - 10;
  dy = dy - 60;

  best_e = -10;
  best_ndx = 1;

  for (ndxl = 1; ndxl <= nd; ndxl++) {
    for (el = -10; el <= 10; el++) {

      if (el != 0) {
	if (el < 0)
	  re = 1 / ((float) (-el));
	if (el > 0)
	  re = (float) el;
	ndyl = nd / (ndxl);
	if (ndxl * ndyl < nd)
	  ndyl = ndyl + 1;
	c1 = nd * (nx * re + buf) * (ny * re + buf);
	c2 = ndxl * (nx * re + buf);
	c3 = ndyl * (ny * re + buf);
	if (c1 <= dx * dy && c2 <= dx && c3 <= dy) {
	  /*      printf("ndx %d ndy %d e %d \n",ndxl,ndy,el);
	     printf("nx ny buf re %d %d %d %f\n",nx,ny,buf,re);
	     printf("c1 c2 c3 rh1 rh2 rh3 %d %d %d %d %d %d \n",c1,c2,c3,dx*dy,dx,dy); */
	  if (el > best_e) {
	    best_e = el;
	    best_ndx = ndxl;
	    best_re = re;
	  }
	}
      }
    }
  }

  printf("best use of display for %d images: \n", nd);
  printf("Expand images by factor %f with %d columns\n", best_re, best_ndx);

  e = best_e;
  ndx = best_ndx;

  best_ndy = nd / best_ndx;
  if (best_ndy * best_ndx < nd)
    best_ndy = best_ndy + 1;

  /* now create the window given the new size classes */

  dx = best_ndx * (nx * best_re + buf) + 10;
  dy = best_ndy * (ny * best_re + buf) + 60;

  window = XCreateSimpleWindow(display, RootWindow(display, screen),
			       0, 0, dx, dy, border_width,
			       WhitePixel(display, screen),
			       WhitePixel(display, screen));
  size_hints.flags = PPosition | PSize | PMinSize | PMaxSize;
  size_hints.x = 0;
  size_hints.y = 0;
  size_hints.width = dx;
  size_hints.height = dy;
  size_hints.min_width = 200;
  size_hints.min_height = 200;
  size_hints.max_width = DisplayWidth(display, screen);
  size_hints.max_height = DisplayHeight(display, screen);

  XSetStandardProperties(display, window, window_name,
			 window_name, None, NULL, 0, &size_hints);

  black = XBlackPixel(display, screen);
  white = XWhitePixel(display, screen);

  gc = XCreateGC(display, window, 0, 0);

  XMapWindow(display, window);

  cmap = XDefaultColormap(display, screen);
  /* black to blue */
  for (i = 0; i < 10; i++) {
    my_color[i].red = 0;
    my_color[i].green = 0;
    my_color[i].blue = 65535 * i / 9;
  }
  /* blue to cyan */
  for (i = 10; i < 20; i++) {
    my_color[i].red = 0;
    my_color[i].green = i * 65535 / 19;
    my_color[i].blue = 65535;
  }
  /*cyan to green */
  for (i = 20; i < 25; i++) {
    my_color[i].red = 0;
    my_color[i].green = 65535;
    my_color[i].blue = 65535 - (65535 * (i - 20) / 5);
  }
  /*green to yellow */
  for (i = 25; i < 30; i++) {
    my_color[i].red = (i - 25) * 65535 / 5;
    my_color[i].green = 65535;
    my_color[i].blue = 0;
  }
  /*yellow to magenta */
  for (i = 30; i < 40; i++) {
    my_color[i].red = 65535;
    my_color[i].green = 65535 - (65535 * (i - 30) / 9);
    my_color[i].blue = 65535 * (i - 30) / 9;
  }
  /*magenta to red */
  for (i = 40; i < 50; i++) {
    my_color[i].red = 65335;
    my_color[i].green = 0;
    my_color[i].blue = 65535 - (65535 * (i - 40) / 9);
  }

  for (i = 0; i < 50; i++) {
    if (XAllocColor(display, cmap, &my_color[i]) == 0) {
      printf("Can't do DHSVM colors\n");
      exit(3);
    }
  }

  /* done initializing the X11 Display, available for drawing */

  /* initialize the memory used solely by the drawing functions */

  if (!((*MetMap) = (MET_MAP_PIX **) calloc(ny, sizeof(MET_MAP_PIX *))))
    ReportError("InitXGraphics", 1);

  for (y = 0; y < ny; y++) {
    if (!((*MetMap)[y] = (MET_MAP_PIX *) calloc(nx, sizeof(MET_MAP_PIX))))
      ReportError("InitXGraphics", 1);
  }

  if ((temp_array = (float **) malloc(ny * sizeof(float *))) == NULL) {
    ReportError("draw.c", 1);
  }
  for (y = 0; y < ny; y++) {
    if ((temp_array[y] = (float *) malloc(nx * sizeof(float))) == NULL) {
      ReportError("draw.c", 1);
    }
  }

#endif
}
Example #11
0
void
Create_Window (char *geometry)
{
    short q;
    Visual *vid;
    XSetWindowAttributes xswa;
    XSizeHints sizehint;
    XWMHints wmhints;
    int depth;
    unsigned char wname[256];	/* Window Name */
    unsigned long vmask = CWEventMask | CWBackPixel | CWBackingStore;

    depth = DefaultDepth (display.dpy, display.screen);
    xswa.event_mask = 0;
    xswa.background_pixel = display.bg;
    xswa.backing_store = Always;
    printf ("DefaultVisual id=%d bp-rgb=%d map-entries=%d\n"
	    ,(int) (*DefaultVisual (display.dpy, display.screen)).visualid
	    ,(*DefaultVisual (display.dpy, display.screen)).bits_per_rgb
	    ,(*DefaultVisual (display.dpy, display.screen)).map_entries);
    vid = DefaultVisual (display.dpy, display.screen);
    display.cmap
	    = XDefaultColormap (display.dpy, display.screen);
    display.win = XCreateWindow (display.dpy, display.root,
				 winX, winY,
				 display.winW, display.winH, 0, depth,
				 InputOutput,	/* vid , */
				 DefaultVisual (display.dpy, display.screen),
				 /*      PseudoColor,  */
				 vmask, &xswa);

    sizehint.x = winX - 100;
    sizehint.y = winY;
    sizehint.width = display.winW;
    sizehint.height = display.winH;
    sizehint.min_width = display.winW;
    sizehint.min_height = display.winH;
    sizehint.max_width = display.winW;
    sizehint.max_height = display.winH;
    /* GCS FIX:  Be careful about resizing the opening screen */
    /* WCK: Fixed.  We lock it now, and unlock it after the opening screen.
       not gorgeous, but it works for now.  Still need to clean up.*/
#define NO_RESIZABLE_WINDOWS 1
    if (geometry != NULL) {
#if defined (NO_RESIZABLE_WINDOWS)
	sizehint.flags = USPosition | USSize | PMinSize | PMaxSize;
#else
	sizehint.flags = USPosition | USSize | PMinSize;
#endif
    } else {
#if defined (NO_RESIZABLE_WINDOWS)
	sizehint.flags = PPosition | PSize | PMinSize | PMaxSize;
#else
	sizehint.flags = PPosition | PSize | PMinSize;
#endif
    }
    XSetNormalHints (display.dpy, display.win, &sizehint);

    display.protocol_atom = XInternAtom (display.dpy, "WM_PROTOCOLS",
					 False);
    display.kill_atom = XInternAtom (display.dpy, "WM_DELETE_WINDOW",
				     False);

    /* Title */
    sprintf ((char *) wname,
	     _("xlincity, Version %s, "
	     "(Copyright) IJ Peters - copying policy GNU GPL"),
	     VERSION);
    XChangeProperty (display.dpy, display.win,
		     XA_WM_NAME, XA_STRING, 8, PropModeReplace, wname,
		     strlen ((char *) wname));

    /* Window Manager Hints (This is supposed to make input work.) */
    wmhints.flags = InputHint;
    wmhints.input = True;
    XSetWMHints (display.dpy, display.win, &wmhints);
    XMapWindow (display.dpy, display.win);
    XSelectInput (display.dpy, display.win,
		  KeyPressMask | ButtonPressMask | ButtonReleaseMask
		  | ExposureMask | StructureNotifyMask);
    for (q = 0; q < 256; q++)
    {
	display.pixcolour_gc[q] = XCreateGC (display.dpy
					     ,display.win, 0, NULL);
	XSetForeground (display.dpy, display.pixcolour_gc[q], q);
	XSetBackground (display.dpy, display.pixcolour_gc[q]
			,display.bg);
	XSetGraphicsExposures (display.dpy, display.pixcolour_gc[q]
			       ,False);
    }
}
Example #12
0
void
do_setcustompalette (XColor * inpal)
{
  int i, n, me = 0, flag[256], vid;
  int depth;
  long unsigned int plane_masks[3];
  XColor pal[256];
  int writeable_p;

  display.cmap = XDefaultColormap (display.dpy, display.screen);
  depth = DefaultDepth (display.dpy, display.screen);

  /* Decide, if the colormap is writable */
  {
    Visual *visual = DefaultVisual (display.dpy, display.screen);
#if defined(__cplusplus) || defined(c_plusplus)
    int visual_class = visual->c_class;
#else
    int visual_class = visual->class;
#endif
    writeable_p = (visual_class == PseudoColor || visual_class == GrayScale);
  }

  if (writeable_p)
    {
      if (XAllocColorCells (display.dpy, display.cmap, 0
			    ,plane_masks, 0, colour_table, 256) == 0)
	{
	  me = (*DefaultVisual (display.dpy, display.screen)).map_entries;
	  vid = (*DefaultVisual (display.dpy, display.screen)).visualid;
	  display.cmap = XCreateColormap (display.dpy, display.win
				,DefaultVisual (display.dpy, display.screen)
	  /*      ,PseudoColor */
					  ,AllocNone);
	  if (me == 256 && depth != 24)
	    {
	      if (XAllocColorCells (display.dpy, display.cmap, 0
				    ,plane_masks, 0, colour_table, 256) != 0) {
		  /* printf ("Allocated 256 cells\n"); */
	      }
	      else {
		  printf ("Couldn't allocate 256 cells\n");
	      }
	    }
	  else
	    for (i = 0; i < 256; i++)
	      colour_table[i] = i;
	}
      if (!display.cmap)
	HandleError ("No default colour map", FATAL);
    }

  for (i = 0; i < 256; i++)
    flag[i] = 0;

  for (n = 0; n < 256; n++)
    {
      pal[n].red = inpal[n].red << 10;
      pal[n].green = inpal[n].green << 10;
      pal[n].blue = inpal[n].blue << 10;
      pal[n].flags = DoRed | DoGreen | DoBlue;
      if (writeable_p)
	pal[n].pixel = colour_table[n];
      else
	{
	  if (XAllocColor (display.dpy
			   ,display.cmap, &(pal[n])) == 0)
	    HandleError ("alloc colour failed"
			 ,FATAL);
	  colour_table[n] = pal[n].pixel;
	  XSetForeground (display.dpy
			  ,display.pixcolour_gc[n]
			  ,colour_table[n]);
	}
      flag[n] = 1;
    }

  if (writeable_p)
    {
      XStoreColors (display.dpy, display.cmap, pal, 256);
      XFlush (display.dpy);
    }
  XSetWindowColormap (display.dpy, display.win, display.cmap);
}
Example #13
0
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   R e a d D P S I m a g e                                                   %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ReadDPSImage() reads a Adobe Postscript image file and returns it.  It
%  allocates the memory necessary for the new Image structure and returns a
%  pointer to the new image.
%
%  The format of the ReadDPSImage method is:
%
%      Image *ReadDPSImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadDPSImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
  const char
    *client_name;

  Display
    *display;

  float
    pixels_per_point;

  Image
    *image;

  int
    sans,
    status;

  Pixmap
    pixmap;

  register ssize_t
    i;

  register Quantum
    *q;

  register size_t
    pixel;

  Screen
    *screen;

  ssize_t
    x,
    y;

  XColor
    *colors;

  XImage
    *dps_image;

  XRectangle
    page,
    bits_per_pixel;

  XResourceInfo
    resource_info;

  XrmDatabase
    resource_database;

  XStandardColormap
    *map_info;

  XVisualInfo
    *visual_info;

  /*
    Open X server connection.
  */
  assert(image_info != (const ImageInfo *) NULL);
  assert(image_info->signature == MagickSignature);
  if (image_info->debug != MagickFalse)
    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
      image_info->filename);
  assert(exception != (ExceptionInfo *) NULL);
  assert(exception->signature == MagickSignature);
  display=XOpenDisplay(image_info->server_name);
  if (display == (Display *) NULL)
    return((Image *) NULL);
  /*
    Set our forgiving exception handler.
  */
  (void) XSetErrorHandler(XError);
  /*
    Open image file.
  */
  image=AcquireImage(image_info,exception);
  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
  if (status == MagickFalse)
    return((Image *) NULL);
  /*
    Get user defaults from X resource database.
  */
  client_name=GetClientName();
  resource_database=XGetResourceDatabase(display,client_name);
  XGetResourceInfo(image_info,resource_database,client_name,&resource_info);
  /*
    Allocate standard colormap.
  */
  map_info=XAllocStandardColormap();
  visual_info=(XVisualInfo *) NULL;
  if (map_info == (XStandardColormap *) NULL)
    ThrowReaderException(ResourceLimitError,"UnableToCreateStandardColormap")
  else
    {
      /*
        Initialize visual info.
      */
      (void) CloneString(&resource_info.visual_type,"default");
      visual_info=XBestVisualInfo(display,map_info,&resource_info);
      map_info->colormap=(Colormap) NULL;
    }
  if ((map_info == (XStandardColormap *) NULL) ||
      (visual_info == (XVisualInfo *) NULL))
    {
      image=DestroyImage(image);
      XFreeResources(display,visual_info,map_info,(XPixelInfo *) NULL,
        (XFontStruct *) NULL,&resource_info,(XWindowInfo *) NULL);
      return((Image *) NULL);
    }
  /*
    Create a pixmap the appropriate size for the image.
  */
  screen=ScreenOfDisplay(display,visual_info->screen);
  pixels_per_point=XDPSPixelsPerPoint(screen);
  if ((image->resolution.x != 0.0) && (image->resolution.y != 0.0))
    pixels_per_point=MagickMin(image->resolution.x,image->resolution.y)/
      DefaultResolution;
  status=XDPSCreatePixmapForEPSF((DPSContext) NULL,screen,
    GetBlobFileHandle(image),visual_info->depth,pixels_per_point,&pixmap,
    &bits_per_pixel,&page);
  if ((status == dps_status_failure) || (status == dps_status_no_extension))
    {
      image=DestroyImage(image);
      XFreeResources(display,visual_info,map_info,(XPixelInfo *) NULL,
        (XFontStruct *) NULL,&resource_info,(XWindowInfo *) NULL);
      return((Image *) NULL);
    }
  /*
    Rasterize the file into the pixmap.
  */
  status=XDPSImageFileIntoDrawable((DPSContext) NULL,screen,pixmap,
    GetBlobFileHandle(image),(int) bits_per_pixel.height,visual_info->depth,
    &page,-page.x,-page.y,pixels_per_point,MagickTrue,MagickFalse,MagickTrue,
    &sans);
  if (status != dps_status_success)
    {
      image=DestroyImage(image);
      XFreeResources(display,visual_info,map_info,(XPixelInfo *) NULL,
        (XFontStruct *) NULL,&resource_info,(XWindowInfo *) NULL);
      return((Image *) NULL);
    }
  /*
    Initialize DPS X image.
  */
  dps_image=XGetImage(display,pixmap,0,0,bits_per_pixel.width,
    bits_per_pixel.height,AllPlanes,ZPixmap);
  (void) XFreePixmap(display,pixmap);
  if (dps_image == (XImage *) NULL)
    {
      image=DestroyImage(image);
      XFreeResources(display,visual_info,map_info,(XPixelInfo *) NULL,
        (XFontStruct *) NULL,&resource_info,(XWindowInfo *) NULL);
      return((Image *) NULL);
    }
  /*
    Get the colormap colors.
  */
  colors=(XColor *) AcquireQuantumMemory(visual_info->colormap_size,
    sizeof(*colors));
  if (colors == (XColor *) NULL)
    {
      image=DestroyImage(image);
      XDestroyImage(dps_image);
      XFreeResources(display,visual_info,map_info,(XPixelInfo *) NULL,
        (XFontStruct *) NULL,&resource_info,(XWindowInfo *) NULL);
      return((Image *) NULL);
    }
  if ((visual_info->klass != DirectColor) && (visual_info->klass != TrueColor))
    for (i=0; i < visual_info->colormap_size; i++)
    {
      colors[i].pixel=(size_t) i;
      colors[i].pad=0;
    }
  else
    {
      size_t
        blue,
        blue_bit,
        green,
        green_bit,
        red,
        red_bit;

      /*
        DirectColor or TrueColor visual.
      */
      red=0;
      green=0;
      blue=0;
      red_bit=visual_info->red_mask & (~(visual_info->red_mask)+1);
      green_bit=visual_info->green_mask & (~(visual_info->green_mask)+1);
      blue_bit=visual_info->blue_mask & (~(visual_info->blue_mask)+1);
      for (i=0; i < visual_info->colormap_size; i++)
      {
        colors[i].pixel=red | green | blue;
        colors[i].pad=0;
        red+=red_bit;
        if (red > visual_info->red_mask)
          red=0;
        green+=green_bit;
        if (green > visual_info->green_mask)
          green=0;
        blue+=blue_bit;
        if (blue > visual_info->blue_mask)
          blue=0;
      }
    }
  (void) XQueryColors(display,XDefaultColormap(display,visual_info->screen),
    colors,visual_info->colormap_size);
  /*
    Convert X image to MIFF format.
  */
  if ((visual_info->klass != TrueColor) && (visual_info->klass != DirectColor))
    image->storage_class=PseudoClass;
  image->columns=(size_t) dps_image->width;
  image->rows=(size_t) dps_image->height;
  if (image_info->ping != MagickFalse)
    {
      (void) CloseBlob(image);
      return(GetFirstImageInList(image));
    }
  status=SetImageExtent(image,image->columns,image->rows,exception);
  if (status == MagickFalse)
    return(DestroyImageList(image));
  switch (image->storage_class)
  {
    case DirectClass:
    default:
    {
      register size_t
        color,
        index;

      size_t
        blue_mask,
        blue_shift,
        green_mask,
        green_shift,
        red_mask,
        red_shift;

      /*
        Determine shift and mask for red, green, and blue.
      */
      red_mask=visual_info->red_mask;
      red_shift=0;
      while ((red_mask != 0) && ((red_mask & 0x01) == 0))
      {
        red_mask>>=1;
        red_shift++;
      }
      green_mask=visual_info->green_mask;
      green_shift=0;
      while ((green_mask != 0) && ((green_mask & 0x01) == 0))
      {
        green_mask>>=1;
        green_shift++;
      }
      blue_mask=visual_info->blue_mask;
      blue_shift=0;
      while ((blue_mask != 0) && ((blue_mask & 0x01) == 0))
      {
        blue_mask>>=1;
        blue_shift++;
      }
      /*
        Convert X image to DirectClass packets.
      */
      if ((visual_info->colormap_size > 0) &&
          (visual_info->klass == DirectColor))
        for (y=0; y < (ssize_t) image->rows; y++)
        {
          q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
          if (q == (Quantum *) NULL)
            break;
          for (x=0; x < (ssize_t) image->columns; x++)
          {
            pixel=XGetPixel(dps_image,x,y);
            index=(pixel >> red_shift) & red_mask;
            SetPixelRed(image,ScaleShortToQuantum(colors[index].red),q);
            index=(pixel >> green_shift) & green_mask;
            SetPixelGreen(image,ScaleShortToQuantum(colors[index].green),q);
            index=(pixel >> blue_shift) & blue_mask;
            SetPixelBlue(image,ScaleShortToQuantum(colors[index].blue),q);
            q+=GetPixelChannels(image);
          }
          if (SyncAuthenticPixels(image,exception) == MagickFalse)
            break;
          if (SetImageProgress(image,LoadImageTag,y,image->rows) == MagickFalse)
            break;
        }
      else
        for (y=0; y < (ssize_t) image->rows; y++)
        {
          q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
          if (q == (Quantum *) NULL)
            break;
          for (x=0; x < (ssize_t) image->columns; x++)
          {
            pixel=XGetPixel(dps_image,x,y);
            color=(pixel >> red_shift) & red_mask;
            color=(color*65535L)/red_mask;
            SetPixelRed(image,ScaleShortToQuantum((unsigned short) color),q);
            color=(pixel >> green_shift) & green_mask;
            color=(color*65535L)/green_mask;
            SetPixelGreen(image,ScaleShortToQuantum((unsigned short) color),q);
            color=(pixel >> blue_shift) & blue_mask;
            color=(color*65535L)/blue_mask;
            SetPixelBlue(image,ScaleShortToQuantum((unsigned short) color),q);
            q+=GetPixelChannels(image);
          }
          if (SyncAuthenticPixels(image,exception) == MagickFalse)
            break;
          if (SetImageProgress(image,LoadImageTag,y,image->rows) == MagickFalse)
            break;
        }
      break;
    }
    case PseudoClass:
    {
      /*
        Create colormap.
      */
      if (AcquireImageColormap(image,(size_t) visual_info->colormap_size,exception) == MagickFalse)
        {
          image=DestroyImage(image);
          colors=(XColor *) RelinquishMagickMemory(colors);
          XDestroyImage(dps_image);
          XFreeResources(display,visual_info,map_info,(XPixelInfo *) NULL,
            (XFontStruct *) NULL,&resource_info,(XWindowInfo *) NULL);
          return((Image *) NULL);
        }
      for (i=0; i < (ssize_t) image->colors; i++)
      {
        image->colormap[colors[i].pixel].red=ScaleShortToQuantum(colors[i].red);
        image->colormap[colors[i].pixel].green=
          ScaleShortToQuantum(colors[i].green);
        image->colormap[colors[i].pixel].blue=
          ScaleShortToQuantum(colors[i].blue);
      }
      /*
        Convert X image to PseudoClass packets.
      */
      for (y=0; y < (ssize_t) image->rows; y++)
      {
        q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
        if (q == (Quantum *) NULL)
          break;
        for (x=0; x < (ssize_t) image->columns; x++)
        {
          SetPixelIndex(image,(unsigned short) XGetPixel(dps_image,x,y),q);
          q+=GetPixelChannels(image);
        }
        if (SyncAuthenticPixels(image,exception) == MagickFalse)
          break;
        if (SetImageProgress(image,LoadImageTag,y,image->rows) == MagickFalse)
          break;
      }
      break;
    }
  }
Example #14
0
static BOOL CreateDeviceColormap(Display *display, int screen,
	int minplanes, int maxplanes)
{
	int i, j;
	unsigned long *pixels, planes[32];

	/* pass 1: allocate colors from default colormap
	 * pass 2: create colormap & allocate colors from new colormap
	 */
	DeviceColormapSize = (XDefaultVisual(display, screen))->map_entries;
	for (i = 0; i < 2; i++)
	{
		/* pass 1: get default colormap
		 * pass 2: create custom colormap
		 */
		if (i == 0)
		{
			DeviceColormap = XDefaultColormap(display, screen);
		}
		else
		{
			DeviceColormap = XCreateColormap(display,
				XRootWindow(display, screen),
				XDefaultVisual(display, screen),
				AllocNone);
		}
		/* pass 1: save default colormap colors for pass 2
		 * pass 2: initialize with default colormap colors to minimize
		 *	   techni-color(tm) effect
		 */
		if (i == 0)
		{
			DeviceColormapValues = (XColor *)
				WinMalloc(DeviceColormapSize * sizeof(XColor));
			for (j = 0; j < DeviceColormapSize; j++)
			{
				DeviceColormapValues[j].pixel = j;
			}
			XQueryColors(display, DeviceColormap,
				DeviceColormapValues,
				DeviceColormapSize);
		}
		else
		{
			pixels = (unsigned long *) WinMalloc(DeviceColormapSize *
				sizeof(unsigned long));
			XAllocColorCells(display, DeviceColormap, True,
				planes, 0, pixels, DeviceColormapSize);
			XStoreColors(display, DeviceColormap,
				DeviceColormapValues,
				DeviceColormapSize);
			XFreeColors(display, DeviceColormap, pixels,
				DeviceColormapSize, 0L);
		}
		/* allocate as many color planes as possible */
		if ((minplanes < 1) || (maxplanes < 1))
			break;
		for (j = maxplanes; j >= minplanes; j--)
		{
			if (!XAllocColorCells(display, DeviceColormap, True,
				pixel_masks, j, &pixel0, 1))
			{
				continue;
			}
			pixel_numplanes = j;
			pixel_mask0 = ~0;
			for (pixel_mask = 0, j = 0; j < pixel_numplanes; j++)
			{
				pixel_mask |= pixel_masks[j];
				pixel_mask0 = min(pixel_mask0, pixel_masks[j]);
			}
			break;
		}
		if (j >= minplanes)
			break;
	}
	if (i == 2)
	{
		ERRSTR((LF_WARNING, 
			"%s: Unable to alloc %d to %d planes.\n",
			"CreateDeviceColormap",
			minplanes, maxplanes));
		return (FALSE);
	}

	/* success */
	return (TRUE);

}
Example #15
0
int main(int argc, char **argv)
{
  FILE *fp;
  int x_1,y_1,x_2,y_2,x_3,y_3;
  char a;
  int i,j;
  int outside;
  int ButtonPressed = 0;
  int temp_x, temp_y;
  pixel_count = 0;
  for(i=0;i<302;i++)
  {              
    for(j=0;j<302;j++)  
    {          
      cost[i][j] = 9999; 
    } 
  }

  if( (display_ptr = XOpenDisplay(display_name)) == NULL )
    { printf("Could not open display. \n"); exit(-1);}
  printf("Connected to X server  %s\n", XDisplayName(display_name) );
  screen_num = DefaultScreen( display_ptr );
  screen_ptr = DefaultScreenOfDisplay( display_ptr );
  color_map  = XDefaultColormap( display_ptr, screen_num );
  display_width  = DisplayWidth( display_ptr, screen_num );
  display_height = DisplayHeight( display_ptr, screen_num );

  printf("Width %d, Height %d, Screen Number %d\n", 
           display_width, display_height, screen_num);
  border_width = 10;
  win_x = 0; win_y = 0;
  win_width = display_width;
  win_height = display_height; 
  
  win= XCreateSimpleWindow( display_ptr, RootWindow( display_ptr, screen_num),
                            win_x, win_y, win_width, win_height, border_width,
                            BlackPixel(display_ptr, screen_num),
                            WhitePixel(display_ptr, screen_num) );
  size_hints = XAllocSizeHints();
  wm_hints = XAllocWMHints();
  class_hints = XAllocClassHint();
  if( size_hints == NULL || wm_hints == NULL || class_hints == NULL )
    { printf("Error allocating memory for hints. \n"); exit(-1);}

  size_hints -> flags = PPosition | PSize | PMinSize  ;
  size_hints -> min_width = 60;
  size_hints -> min_height = 60;

  XStringListToTextProperty( &win_name_string,1,&win_name);
  XStringListToTextProperty( &icon_name_string,1,&icon_name);
  
  wm_hints -> flags = StateHint | InputHint ;
  wm_hints -> initial_state = NormalState;
  wm_hints -> input = False;

  class_hints -> res_name = "x_use_example";
  class_hints -> res_class = "examples";

  XSetWMProperties( display_ptr, win, &win_name, &icon_name, argv, argc,
                    size_hints, wm_hints, class_hints );

  XSelectInput( display_ptr, win, 
            ExposureMask | StructureNotifyMask | ButtonPressMask );
  
  XMapWindow( display_ptr, win );

  XFlush(display_ptr);
  gc_red = XCreateGC( display_ptr, win, valuemask, &gc_red_values);
  XSetLineAttributes( display_ptr, gc_red, 3, LineSolid, CapRound, JoinRound);
  if( XAllocNamedColor( display_ptr, color_map, "red", 
      &tmp_color1, &tmp_color2 ) == 0 )
    {printf("failed to get color red\n"); exit(-1);} 
  else
    XSetForeground( display_ptr, gc_red, tmp_color1.pixel );
  gc_black = XCreateGC( display_ptr, win, valuemask, &gc_black_values);
  XSetLineAttributes(display_ptr, gc_black, 3, LineSolid,CapRound, JoinRound);
  if( XAllocNamedColor( display_ptr, color_map, "black", 
      &tmp_color1, &tmp_color2 ) == 0 )
    {printf("failed to get color black\n"); exit(-1);} 
  else
    XSetForeground( display_ptr, gc_black, tmp_color1.pixel );
  gc_blue = XCreateGC( display_ptr, win, valuemask, &gc_blue_values);
  XSetLineAttributes(display_ptr, gc_blue, 3, LineSolid,CapRound, JoinRound);
  if( XAllocNamedColor( display_ptr, color_map, "blue", 
      &tmp_color1, &tmp_color2 ) == 0 )
    {printf("failed to get blue yellow\n"); exit(-1);} 
  else
    XSetForeground( display_ptr, gc_blue, tmp_color1.pixel );
  gc_white = XCreateGC( display_ptr, win, valuemask, &gc_white_values);
  XSetLineAttributes(display_ptr, gc_white, 3, LineSolid,CapRound, JoinRound);
  if( XAllocNamedColor( display_ptr, color_map, "white", 
      &tmp_color1, &tmp_color2 ) == 0 )
    {printf("failed to get color white\n"); exit(-1);} 
  else
    XSetForeground( display_ptr, gc_white, tmp_color1.pixel );

  if ( argc != 2 ) 
  {
      printf( "Usage: %s filename.extension \n", argv[0] );
      exit(-1);
  }
  fp = fopen(argv[1], "r");
  if (fp == NULL) 
  {
    fprintf(stderr, "Can't open file %s!\n", argv[1]);
    printf( "Usage: %s filename.extension or Check whether file is present or not\n", argv[0] );
    exit(-1);
  } 
  triangle_count = 0;
  while (fscanf(fp, "%c %c%d%c%d%c %c%d%c%d%c %c%d%c%d%c%c", &a,&a,&x_1,&a,&y_1,&a,&a,&x_2,&a,&y_2,&a,&a,&x_3,&a,&y_3,&a,&a) != EOF) 
  {
    if(get_x_min(x_1,x_2,x_3) >= 0 && get_y_min(y_1,y_2,y_3) >= 0 && get_x_max(x_1,x_2,x_3) <= display_width - 300 && get_y_max(y_1,y_2,y_3) <= display_height - 200)
    {
      t[triangle_count].x1 = x_1;
      t[triangle_count].x2 = x_2;
      t[triangle_count].x3 = x_3;
      t[triangle_count].y1 = y_1;
      t[triangle_count].y2 = y_2;
      t[triangle_count].y3 = y_3;
      triangle_count++;
    }   
  }
  
  x_min = t[0].x1;
  x_max = x_min;
  y_min = t[0].y1;
  y_max = y_min;
  for(i=0;i<triangle_count;i++)
  {
    if(x_min > t[i].x1)
      x_min = t[i].x1;
    if(x_min > t[i].x2)
      x_min = t[i].x2;
    if(x_min > t[i].x2)
      x_min = t[i].x3;
    if(y_min > t[i].y1)
      y_min = t[i].y1;
    if(y_min > t[i].y2)
      y_min = t[i].y2;
    if(y_min > t[i].y3)
      y_min = t[i].y3;
    if(x_max < t[i].x1)
      x_max = t[i].x1;
    if(x_max < t[i].x2)
      x_max = t[i].x2;
    if(x_max < t[i].x3)
      x_max = t[i].x3;
    if(y_max < t[i].y1)
      y_max = t[i].y1;
    if(y_max < t[i].y2)
      y_max = t[i].y2;
    if(y_max < t[i].y3)
      y_max = t[i].y3;        
  }
   
  x_center = win_width / 2;
  y_center = win_height / 2;
  x_gap = x_max - x_min;
  y_gap = y_max - y_min;
  x_start = x_center - x_gap/2 - 50;
  y_start = y_center - y_gap/2 - 50;
  x_end = x_start + x_gap + 100;
  y_end = y_start + y_gap + 100;
  rec_width = x_end - x_start;
  rec_height = y_end - y_start;

  for(i=0;i<triangle_count;i++)
  {
    t[i].x1 = t[i].x1 + x_start + 50 - x_min;
    t[i].x2 = t[i].x2 + x_start + 50 - x_min;
    t[i].x3 = t[i].x3 + x_start + 50 - x_min;
    t[i].y1 = t[i].y1 + y_start + 50 - y_min;
    t[i].y2 = t[i].y2 + y_start + 50 - y_min;
    t[i].y3 = t[i].y3 + y_start + 50 - y_min;
  }
  for(i=0;i<triangle_count;i++)
  {
    t[i].point_1_inside_triangle = 0;
    t[i].point_2_inside_triangle = 0;
    t[i].point_3_inside_triangle = 0;       
  }
  for(i=0;i<triangle_count;i++)
  {
    for(j=0;j<triangle_count;j++)
    {
      if(j!=i)
      {
        if(point_in_triangle(t[i].x1,t[i].y1,t[j].x1,t[j].y1,t[j].x2,t[j].y2,t[j].x3,t[j].y3)==1)
        {
          t[i].point_1_inside_triangle = 1;
        }
        if(point_in_triangle(t[i].x2,t[i].y2,t[j].x1,t[j].y1,t[j].x2,t[j].y2,t[j].x3,t[j].y3)==1)
        {
          t[i].point_2_inside_triangle = 1;
        }
        if(point_in_triangle(t[i].x3,t[i].y3,t[j].x1,t[j].y1,t[j].x2,t[j].y2,t[j].x3,t[j].y3)==1)
        {
          t[i].point_3_inside_triangle = 1;
        }
      }
    }
  }
  
  while(1)
  { 
    XNextEvent( display_ptr, &report );
    switch( report.type )
	  {
	    case Expose:
	      for(i=0;i<triangle_count;i++)
        {
          XDrawLine(display_ptr, win, gc_black, t[i].x1, t[i].y1, t[i].x2, t[i].y2);
          XDrawLine(display_ptr, win, gc_black, t[i].x2, t[i].y2, t[i].x3, t[i].y3);
          XDrawLine(display_ptr, win, gc_black, t[i].x3, t[i].y3, t[i].x1, t[i].y1);
        }
        XDrawRectangle(display_ptr, win, gc_black, x_start, y_start, rec_width, rec_height ); 
        break;
        
      case ConfigureNotify:
          win_width = report.xconfigure.width;
          win_height = report.xconfigure.height;
          break;
        
      case ButtonPress:
      {  
        int x, y;
  	    x = report.xbutton.x;
        y = report.xbutton.y;
        if (report.xbutton.button == Button1 )
	      {
          outside = 0;
          if(x <= x_start || y <= y_start || x >= x_end || y >= y_end)
          {
            outside = 1;
          } 
          for(i=0;i<triangle_count;i++)
          {
            if(point_in_triangle(x,y,t[i].x1,t[i].y1,t[i].x2,t[i].y2,t[i].x3,t[i].y3)==1)
            {
              outside = 1;
              break;
            }
          }
          if(outside == 0)
          {
            ButtonPressed++;
            if(ButtonPressed == 1)
            { 
              temp_x = x;
              temp_y = y;
              pixel_count = 0;
              XFillArc( display_ptr, win, gc_red, x - win_height/150, y - win_height/150, win_height/100, win_height/100, 0, 360*64);
              pixel[pixel_count].name = pixel_count;
              pixel[pixel_count].x = x; 
              pixel[pixel_count].y = y;
              pixel_count++;
            }
            else if(ButtonPressed == 2)
            { 
              if(temp_x == x && temp_y == y)
              {
                ButtonPressed = 1;
                break;
              }
              XFillArc( display_ptr, win, gc_red, x - win_height/150, y - win_height/150, win_height/100, win_height/100, 0, 360*64);
              for(i=0;i<triangle_count;i++)
              {
                if(t[i].point_1_inside_triangle != 1)
                {
                  pixel[pixel_count].name = pixel_count;
                  pixel[pixel_count].x = t[i].x1; 
                  pixel[pixel_count].y = t[i].y1;
                  pixel_count++;
                }
                if(t[i].point_2_inside_triangle != 1)
                {
                  pixel[pixel_count].name = pixel_count;
                  pixel[pixel_count].x = t[i].x2; 
                  pixel[pixel_count].y = t[i].y2;
                  pixel_count++;
                }
                if(t[i].point_3_inside_triangle != 1)
                {
                  pixel[pixel_count].name = pixel_count;
                  pixel[pixel_count].x = t[i].x3; 
                  pixel[pixel_count].y = t[i].y3;
                  pixel_count++;
                }
              }
              pixel[pixel_count].name = pixel_count;
              pixel[pixel_count].x = x; 
              pixel[pixel_count].y = y;
              pixel_count++;
              for(i=0;i<pixel_count-1;i++)
              {         
                for(j=i+1;j<pixel_count;j++)
                {
                  if(can_see(pixel[i].x,pixel[i].y,pixel[j].x,pixel[j].y)==1)
                  {
                    cost[pixel[i].name][pixel[j].name] = cost[pixel[j].name][pixel[i].name] = eculidian_dist(pixel[i].x,pixel[i].y,pixel[j].x,pixel[j].y);
                  }
                }
              }
              dijsktra(pixel[0].name, pixel[pixel_count-1].name);
            }
            else
            {
              clear_cost();
              expose();
              ButtonPressed = 0;          
            }
          }
        }
        else
        {
          XFlush(display_ptr);
          XCloseDisplay(display_ptr);
          exit(0);
        }
      }
      break;
      default:
        break;
    }
  }
  exit(0);
}
Example #16
0
	int32_t run(Filesystem* fs, ConfigSettings* cs)
	{
		// Create main window
		XInitThreads();
		XSetErrorHandler(x11_error_handler);
		m_x11_display = XOpenDisplay(NULL);

		CE_ASSERT(m_x11_display != NULL, "Unable to open X11 display");

		int screen = DefaultScreen(m_x11_display);
		int depth = DefaultDepth(m_x11_display, screen);
		Visual* visual = DefaultVisual(m_x11_display, screen);

		m_x11_parent_window = (m_parent_window_handle == 0) ? RootWindow(m_x11_display, screen) :
			(Window) m_parent_window_handle;

		// Create main window
		XSetWindowAttributes win_attribs;
		win_attribs.background_pixmap = 0;
		win_attribs.border_pixel = 0;
		win_attribs.event_mask = FocusChangeMask
			| StructureNotifyMask 
			| KeyPressMask
			| KeyReleaseMask 
			| ButtonPressMask 
			| ButtonReleaseMask
			| PointerMotionMask;

		m_x11_window = XCreateWindow(m_x11_display,
			m_x11_parent_window,
			0, 0,
			cs->window_width,
			cs->window_height,
			0,
			depth,
			InputOutput,
			visual,
			CWBorderPixel | CWEventMask,
			&win_attribs
		);
		CE_ASSERT(m_x11_window != None, "Unable to create X window");

		// Do we have detectable autorepeat?
		Bool detectable;
		m_x11_detectable_autorepeat = (bool) XkbSetDetectableAutoRepeat(m_x11_display, true, &detectable);

		// Build hidden cursor
		Pixmap bm_no;
		XColor black, dummy;
		Colormap colormap;
		static char no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 };

		colormap = XDefaultColormap(m_x11_display, screen);
		XAllocNamedColor(m_x11_display, colormap, "black", &black, &dummy);
		bm_no = XCreateBitmapFromData(m_x11_display, m_x11_window, no_data, 8, 8);
		m_x11_hidden_cursor = XCreatePixmapCursor(m_x11_display, bm_no, bm_no, &black, &black, 0, 0);

		m_wm_delete_message = XInternAtom(m_x11_display, "WM_DELETE_WINDOW", False);
		XSetWMProtocols(m_x11_display, m_x11_window, &m_wm_delete_message, 1);

		oswindow_set_window(m_x11_display, m_x11_window);
		bgfx::x11SetDisplayWindow(m_x11_display, m_x11_window);
		XMapRaised(m_x11_display, m_x11_window);

		// Get screen configuration
		m_screen_config = XRRGetScreenInfo(m_x11_display, RootWindow(m_x11_display, screen));

		Rotation rr_old_rot;
		const SizeID rr_old_sizeid = XRRConfigCurrentConfiguration(m_screen_config, &rr_old_rot);

		// Start main thread
		MainThreadArgs mta;
		mta.fs = fs;
		mta.cs = cs;

		Thread main_thread;
		main_thread.start(func, &mta);

		while (!s_exit)
		{
			pump_events();
		}

		main_thread.stop();

		// Restore previous screen configuration if changed
		Rotation rr_cur_rot;
		const SizeID rr_cur_sizeid = XRRConfigCurrentConfiguration(m_screen_config, &rr_cur_rot);

		if (rr_cur_rot != rr_old_rot || rr_cur_sizeid != rr_old_sizeid)
		{
			XRRSetScreenConfig(m_x11_display,
				m_screen_config,
				RootWindow(m_x11_display, screen),
				rr_old_sizeid,
				rr_old_rot,
				CurrentTime);
		}
		XRRFreeScreenConfigInfo(m_screen_config);

		XDestroyWindow(m_x11_display, m_x11_window);
		XCloseDisplay(m_x11_display);
		return EXIT_SUCCESS;
	}
int main(int argc, char **argv)
{
    /* opening display: basic connection to X Server */
    if( (display_ptr = XOpenDisplay(display_name)) == NULL )
    {
        printf("Could not open display. \n");
        exit(-1);
    }
    printf("Connected to X server  %s\n", XDisplayName(display_name) );
    screen_num = DefaultScreen( display_ptr );
    screen_ptr = DefaultScreenOfDisplay( display_ptr );
    color_map  = XDefaultColormap( display_ptr, screen_num );
    display_width  = DisplayWidth( display_ptr, screen_num );
    display_height = DisplayHeight( display_ptr, screen_num );

    printf("Width %d, Height %d, Screen Number %d\n",
           display_width, display_height, screen_num);
    /* creating the window */
    border_width = 10;
    win_x = 0;
    win_y = 0;
    win_width = display_width/2;
    win_height = (int) (win_width / 1.7); /*rectangular window*/

    win= XCreateSimpleWindow( display_ptr, RootWindow( display_ptr, screen_num),
                              win_x, win_y, win_width, win_height, border_width,
                              BlackPixel(display_ptr, screen_num),
                              WhitePixel(display_ptr, screen_num) );
    /* now try to put it on screen, this needs cooperation of window manager */
    size_hints = XAllocSizeHints();
    wm_hints = XAllocWMHints();
    class_hints = XAllocClassHint();
    if( size_hints == NULL || wm_hints == NULL || class_hints == NULL )
    {
        printf("Error allocating memory for hints. \n");
        exit(-1);
    }

    size_hints -> flags = PPosition | PSize | PMinSize  ;
    size_hints -> min_width = 60;
    size_hints -> min_height = 60;

    XStringListToTextProperty( &win_name_string,1,&win_name);
    XStringListToTextProperty( &icon_name_string,1,&icon_name);

    wm_hints -> flags = StateHint | InputHint ;
    wm_hints -> initial_state = NormalState;
    wm_hints -> input = False;

    class_hints -> res_name = "x_use_example";
    class_hints -> res_class = "examples";

    XSetWMProperties( display_ptr, win, &win_name, &icon_name, argv, argc,
                      size_hints, wm_hints, class_hints );

    /* what events do we want to receive */
    XSelectInput( display_ptr, win,
                  ExposureMask | StructureNotifyMask | ButtonPressMask );

    /* finally: put window on screen */
    XMapWindow( display_ptr, win );

    XFlush(display_ptr);

    /* create graphics context, so that we may draw in this window */
    gc = XCreateGC( display_ptr, win, valuemask, &gc_values);
    XSetForeground( display_ptr, gc, BlackPixel( display_ptr, screen_num ) );
    XSetLineAttributes( display_ptr, gc, 4, LineSolid, CapRound, JoinRound);
    /* and three other graphics contexts, to draw in yellow and red and grey*/
    gc_yellow = XCreateGC( display_ptr, win, valuemask, &gc_yellow_values);
    XSetLineAttributes(display_ptr, gc_yellow, 6, LineSolid,CapRound, JoinRound);
    if( XAllocNamedColor( display_ptr, color_map, "yellow",
                          &tmp_color1, &tmp_color2 ) == 0 )
    {
        printf("failed to get color yellow\n");
        exit(-1);
    }
    else
        XSetForeground( display_ptr, gc_yellow, tmp_color1.pixel );
    gc_red = XCreateGC( display_ptr, win, valuemask, &gc_red_values);
    XSetLineAttributes( display_ptr, gc_red, 6, LineSolid, CapRound, JoinRound);
    if( XAllocNamedColor( display_ptr, color_map, "red",
                          &tmp_color1, &tmp_color2 ) == 0 )
    {
        printf("failed to get color red\n");
        exit(-1);
    }
    else
        XSetForeground( display_ptr, gc_red, tmp_color1.pixel );
    gc_grey = XCreateGC( display_ptr, win, valuemask, &gc_grey_values);
    if( XAllocNamedColor( display_ptr, color_map, "light grey",
                          &tmp_color1, &tmp_color2 ) == 0 )
    {
        printf("failed to get color grey\n");
        exit(-1);
    }
    else
        XSetForeground( display_ptr, gc_grey, tmp_color1.pixel );

    /* and now it starts: the event loop */
    while(1)
    {   XNextEvent( display_ptr, &report );
        switch( report.type )
        {
        case Expose:
            /* (re-)draw the example figure. This event happens
               each time some part ofthe window gets exposed (becomes visible) */
            XDrawLine(display_ptr, win, gc, win_width /4, win_height/ 3,
                      3*win_width/4, win_height/3 );
            XDrawLine(display_ptr, win, gc_red, win_width /4, 2*win_height/ 3,
                      3*win_width/4, 2*win_height/3 );
            XFillArc( display_ptr, win, gc_grey, win_width/2-win_height/6,
                      win_height/3,
                      win_height/3, win_height/3, 0, 360*64);
            XDrawArc( display_ptr, win, gc_yellow, win_width/4, win_height/3,
                      win_height/6, win_height/3, 90*64, 180*64);

            break;
        case ConfigureNotify:
            /* This event happens when the user changes the size of the window*/
            win_width = report.xconfigure.width;
            win_height = report.xconfigure.height;
            break;
        case ButtonPress:
            /* This event happens when the user pushes a mouse button. I draw
              a circle to show the point where it happened, but do not save
              the position; so when the next redraw event comes, these circles
            disappear again. */
        {
            int x, y;
            x = report.xbutton.x;
            y = report.xbutton.y;
            if (report.xbutton.button == Button1 )
                XFillArc( display_ptr, win, gc_red,
                          x -win_height/40, y- win_height/40,
                          win_height/20, win_height/20, 0, 360*64);
            else
                XFillArc( display_ptr, win, gc_yellow,
                          x - win_height/40, y - win_height/40,
                          win_height/20, win_height/20, 0, 360*64);

        }
        break;
        default:
            /* this is a catch-all for other events; it does not do anything.
                   One could look at the report type to see what the event was */
            break;
        }

    }
    exit(0);
}
Example #18
0
File: Menu.C Project: bbidulock/wmx
Menu::Menu(WindowManager *manager, XEvent *e)
    : m_items(0), m_nItems(0), m_nHidden(0),
      m_hasSubmenus(False),
      m_windowManager(manager),
      m_event(e)
{
    if (!m_initialised)
    {
	XGCValues *values;
	XSetWindowAttributes *attr;

        m_menuGC = (GC *) malloc(m_windowManager->screensTotal() * sizeof(GC));
        m_window = (Window *) malloc(m_windowManager->screensTotal() *
				     sizeof(Window));
#ifdef CONFIG_USE_XFT
	char *fi = strdup(CONFIG_MENU_FONT);
	char *ffi = fi, *tokstr = fi;
	while ((fi = strtok(tokstr, ","))) {
		
	    fprintf(stderr, "fi = \"%s\"\n", fi);
	    tokstr = 0;
	    
	    FcPattern *pattern = FcPatternCreate();
	    FcPatternAddString(pattern, FC_FAMILY, (FcChar8 *)fi);
	    FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);

#ifndef FC_WEIGHT_REGULAR
#define FC_WEIGHT_REGULAR FC_WEIGHT_MEDIUM
#endif
	    FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_REGULAR);
	    FcPatternAddInteger(pattern, FC_PIXEL_SIZE, CONFIG_MENU_FONT_SIZE);
	    FcConfigSubstitute(FcConfigGetCurrent(), pattern, FcMatchPattern);

	    FcResult result = FcResultMatch;
	    FcPattern *match = FcFontMatch(FcConfigGetCurrent(), pattern, &result);
	    FcPatternDestroy(pattern);

	    if (!match || result != FcResultMatch) {
		if (match) FcPatternDestroy(match);
		continue;
	    }

	    m_font = XftFontOpenPattern(display(), match);
	    if (m_font) break;
	    FcPatternDestroy(match);
	}
	free(ffi);
	if (!m_font) {
	    m_windowManager->fatal("couldn't load menu Xft font");
	}
	m_xftColour = (XftColor *) malloc(m_windowManager->screensTotal() *
					  sizeof(XftColor));
	m_xftDraw = (XftDraw **) malloc(m_windowManager->screensTotal() *
					sizeof(XftDraw *));
#else
	m_font = (XFontStruct **) malloc(m_windowManager->screensTotal() *
					 sizeof(XFontStruct *));
#endif
	values = (XGCValues *) malloc(m_windowManager->screensTotal() *
				      sizeof(XGCValues));
	attr = (XSetWindowAttributes *) malloc(m_windowManager->screensTotal() *
				      sizeof(XSetWindowAttributes));
	
        for (int i = 0; i < m_windowManager->screensTotal(); i++)
	{
	    m_foreground = m_windowManager->allocateColour
	      (i, CONFIG_MENU_FOREGROUND, "menu foreground");
	    m_background = m_windowManager->allocateColour
	      (i, CONFIG_MENU_BACKGROUND, "menu background");
	    m_border = m_windowManager->allocateColour
	      (i, CONFIG_MENU_BORDERS, "menu border");

#ifndef CONFIG_USE_XFT
	    char **ml;
	    int mc;
	    char *ds;
	    
	    m_fontset = XCreateFontSet(display(), CONFIG_NICE_MENU_FONT,
				       &ml, &mc, &ds);
	    if (!m_fontset)
	      m_fontset = XCreateFontSet(display(), CONFIG_NASTY_FONT,
					 &ml, &mc, &ds);
	    if (m_fontset) {
		XFontStruct **fs_list;
		XFontsOfFontSet(m_fontset, &fs_list, &ml);
		m_font[i] = fs_list[0];
	    } else {
		m_font[i] = NULL;
	    }
#define XDrawString(t,u,v,w,x,y,z) XmbDrawString(t,u,m_fontset,v,w,x,y,z)
	    if (!m_font[i]) m_windowManager->fatal("couldn't load menu font\n");
#endif
	    
	    values[i].background = m_background;
	    values[i].foreground = m_foreground ^ m_background;
	    values[i].function = GXxor;
	    values[i].line_width = 0;
	    values[i].subwindow_mode = IncludeInferiors;
#ifndef CONFIG_USE_XFT
	    values[i].font = m_font[i]->fid;
#endif
	    m_menuGC[i] = XCreateGC
	      (display(), m_windowManager->mroot(i),
	       GCForeground | GCBackground | GCFunction |
	       GCLineWidth | GCSubwindowMode, &values[i]);

#ifndef CONFIG_USE_XFT
	    XChangeGC(display(), Border::drawGC(m_windowManager, i),
		      GCFont, &values[i]);
#endif

	    m_window[i] = XCreateSimpleWindow
	      (display(), m_windowManager->mroot(i), 0, 0, 1, 1, 1,
	       m_border, m_background);

	    
#if ( CONFIG_USE_PIXMAPS != False ) && ( CONFIG_USE_PIXMAP_MENUS != False )
	    attr[i].background_pixmap = Border::backgroundPixmap(manager);
#endif
	    attr[i].save_under =
	      (DoesSaveUnders(ScreenOfDisplay(display(), i)) ?
	     True : False);

#if ( CONFIG_USE_PIXMAPS != False ) && ( CONFIG_USE_PIXMAP_MENUS != False )
	    XChangeWindowAttributes
	      (display(), m_window[i], CWBackPixmap, &attr[i]);
#endif
	    XChangeWindowAttributes
	      (display(), m_window[i], CWSaveUnder, &attr[i]);

#ifdef CONFIG_USE_XFT
	    XftColorAllocName
		(display(),
		 XDefaultVisual(display(), i),
		 XDefaultColormap(display(), i),
		 CONFIG_MENU_FOREGROUND,
		 &m_xftColour[i]);

	    m_xftDraw[i] = XftDrawCreate(display(), m_window[i],
					 XDefaultVisual(display(), i),
					 XDefaultColormap(display(), i));
#endif
	}
	m_initialised = True;
    }
}
Example #19
0
/****************************************************************************
 *
 * Creates an icon window as needed
 *
 ****************************************************************************/
int main(int argc, char **argv)
{
  char *display_name = NULL, *string = NULL;
  int retval = 0;
  XEvent Event;
  fd_set in_fdset;
  int fd_width ;
  struct timeval value;
  int fd[2];

  fd_width = GetFdWidth();

  /* Save our program  name - for error messages */
  string = strrchr (argv[0], '/');
  if (string != (char *) 0) string++;

  myName = safemalloc (strlen (string) + 1);
  strcpy (myName, string);

  if(argc>=3)
  {
      /* sever our connection with fvwm, if we have one. */
      fd[0] = atoi(argv[1]);
      fd[1] = atoi(argv[2]);

#if 0
      if(fd[0]>0)close(fd[0]);
      if(fd[1]>0)close(fd[1]);
#endif /* 0 */
  }
  else
  {
    fprintf (stderr,
	     "%s version %s should only be executed by fvwm!\n",
	     myName,
	     VERSION);
    exit(1);
  }

  if (argc > 6) {
    pixmapName = safemalloc (strlen (argv[6]) + 1);
    strcpy (pixmapName, argv[6]);
  }

  /* Open the display */
  if (!(dpy = XOpenDisplay(display_name)))
    {
      fprintf(stderr,"FvwmBanner: can't open display %s",
	      XDisplayName(display_name));
      exit (1);
    }
  screen= DefaultScreen(dpy);
  Root = RootWindow(dpy, screen);
  colormap = XDefaultColormap(dpy,screen);
  d_depth = DefaultDepth(dpy, screen);
  x_fd = XConnectionNumber(dpy);

  ScreenHeight = DisplayHeight(dpy,screen);
  ScreenWidth = DisplayWidth(dpy,screen);

  parseOptions(fd);

  /* Get the xpm banner */
  if (pixmapName)
    GetXPMFile(pixmapName,pixmapPath);
  else
#if 0
    if(d_depth > 4)
      GetXPMData(k2_xpm);
    else
#endif /* 0 */
      GetXPMData(fvwm2_big_xpm);

  /* Create a window to hold the banner */
  mysizehints.flags=
    USSize|USPosition|PWinGravity|PResizeInc|PBaseSize|PMinSize|PMaxSize;
  /* subtract one for the right/bottom border */
  mysizehints.width = view.attributes.width;
  mysizehints.height=view.attributes.height;
  mysizehints.width_inc = 1;
  mysizehints.height_inc = 1;
  mysizehints.base_height = mysizehints.height;
  mysizehints.base_width = mysizehints.width;
  mysizehints.min_height = mysizehints.height;
  mysizehints.min_width = mysizehints.width;
  mysizehints.max_height = mysizehints.height;
  mysizehints.max_width = mysizehints.width;
  mysizehints.win_gravity = NorthWestGravity;

  mysizehints.x = (ScreenWidth - view.attributes.width)/2;
  mysizehints.y = (ScreenHeight - view.attributes.height)/2;

  win = XCreateSimpleWindow(dpy,Root,mysizehints.x,mysizehints.y,
				 mysizehints.width,mysizehints.height,
				 0,fore_pix ,None);


  /* Set assorted info for the window */
  XSetTransientForHint(dpy,win,Root);
  wm_del_win = XInternAtom(dpy,"WM_DELETE_WINDOW",False);
  XSetWMProtocols(dpy,win,&wm_del_win,1);

  XSetWMNormalHints(dpy,win,&mysizehints);
  change_window_name("FvwmBanner");

  XSetWindowBackgroundPixmap(dpy,win,view.pixmap);
#ifdef SHAPE
  if(view.mask != None)
    XShapeCombineMask(dpy, win, ShapeBounding,0,0,view.mask, ShapeSet);
#endif
  XMapWindow(dpy,win);
  XSync(dpy,0);
#if 0
  usleep(timeout);
#else
  XSelectInput(dpy,win,ButtonReleaseMask);
  /* Display the window */
  value.tv_usec = timeout % 1000000;
  value.tv_sec = timeout / 1000000;
  while(1)
  {
    FD_ZERO(&in_fdset);
    FD_SET(x_fd,&in_fdset);

    if(!XPending(dpy))

      retval=select(fd_width,SELECT_TYPE_ARG234 &in_fdset, 0, 0, &value);

    if (retval==0)
    {
      XDestroyWindow(dpy,win);
      XSync(dpy,0);
      exit(0);
    }

    if(FD_ISSET(x_fd, &in_fdset))
    {
      /* read a packet */
      XNextEvent(dpy,&Event);
      switch(Event.type)
      {
        case ButtonRelease:
          XDestroyWindow(dpy,win);
          XSync(dpy,0);
          exit(0);
        case ClientMessage:
          if (Event.xclient.format==32 && Event.xclient.data.l[0]==wm_del_win)
          {
            XDestroyWindow(dpy,win);
            XSync(dpy,0);
            exit(0);
          }
        default:
          break;
      }
    }
  }
#endif /* 0 */
  return 0;
}
Example #20
0
File: P1.c Project: hugonomura/CG2
int main(){
	//Pontos iniciais
	Ponto P1, P2, P3, P4, P5, P6, P7, P8;

	float se, co, tz, cpz;

	//Pontos rotacionados
	Ponto *rP1, *rP2, *rP3, *rP4, *rP5, *rP6, *rP7, *rP8;

	//Pontos Projetados perspectivamente
	Ponto *iP1, *iP2, *iP3, *iP4, *iP5, *iP6, *iP7, *iP8;

	//Declaração da matriz de rotação
	struct matriz4x4 mRotaciona;

	int RXmin,RXmax,RYmin,RYmax,a,b;

	Window win;
	Display *display;
	int width = 256, height = 256, x = 0, y = 0, i, tx, ty,ref,rot;
	GC gc;
	unsigned long valuemask = 0;
	XGCValues values;
	XColor cor;


	P1.x =  30; P1.y = -10; P1.z =  10; P1.W = 1;
	P2.x =  30; P2.y = -10; P2.z = -10; P2.W = 1;
	P3.x =  30; P3.y =  10; P3.z =  10; P3.W = 1;
	P4.x =  30; P4.y =  10; P4.z = -10; P4.W = 1;
	P5.x = -30; P5.y = -10; P5.z =  10; P5.W = 1;
	P6.x = -30; P6.y = -10; P6.z = -10; P6.W = 1;
	P7.x = -30; P7.y =  10; P7.z =  10; P7.W = 1;
	P8.x = -30; P8.y =  10; P8.z = -10; P8.W = 1;

	//Variaveis para calculo do seno e cosseno do angulo de rotacao
	se = sin(90*PI/180);
	co = cos(90*PI/180);

	//Inicializacao da matriz de Rotacao em relacao ao eixo z

	mRotaciona.a11 = co; mRotaciona.a12 = -se; mRotaciona.a13 = 0; mRotaciona.a14 = 0;
	mRotaciona.a21 = se; mRotaciona.a22 = co; mRotaciona.a23 = 0; mRotaciona.a24 = 0;
	mRotaciona.a31 = 0; mRotaciona.a32 = 0; mRotaciona.a33 = 1; mRotaciona.a34 = 0;
	mRotaciona.a41 = 0; mRotaciona.a42 = 0; mRotaciona.a43 = 0; mRotaciona.a44 = 1;



//**************************************  (a)  **********************************************

	//Estou utilizando a regra da mão direita
	//Chamada da funcao que rotaciona o ponto
	rP1 = rotaciona(&mRotaciona, &P1);
	rP2 = rotaciona(&mRotaciona, &P2);
	rP3 = rotaciona(&mRotaciona, &P3);
	rP4 = rotaciona(&mRotaciona, &P4);
	rP5 = rotaciona(&mRotaciona, &P5);
	rP6 = rotaciona(&mRotaciona, &P6);
	rP7 = rotaciona(&mRotaciona, &P7);
	rP8 = rotaciona(&mRotaciona, &P8);

	
//**************************************  (b)  **********************************************

	//Projeção Perspectiva

	printf("\n\nDigite o valor Tz: \n");
	scanf("%f",&tz);
	printf("\nDigite o valor Cpz: \n");
	scanf("%f",&cpz);

	iP1 = Projeta(tz, cpz, rP1);
	iP2 = Projeta(tz, cpz, rP2);
	iP3 = Projeta(tz, cpz, rP3);
	iP4 = Projeta(tz, cpz, rP4);
	iP5 = Projeta(tz, cpz, rP5);
	iP6 = Projeta(tz, cpz, rP6);
	iP7 = Projeta(tz, cpz, rP7);
	iP8 = Projeta(tz, cpz, rP8);

	
//**************************************  (c)  **********************************************


	//Entrada dos valores do retangulo de visualizacao
	printf("\n\nDigite o valor do RXmin: \n");
	scanf("%f",&RXmin);
	printf("\nDigite o valor RXmax: \n");
	scanf("%f",&RXmax);

	printf("\n\nDigite o valor do RYmin: \n");
	scanf("%f",&RYmin);
	printf("\nDigite o valor RYmax: \n");
	scanf("%f",&RYmax);

	//width = modulo(RXmin) + modulo(RXmax);
	//height = modulo(RYmin) + modulo(RYmax);
	
	win = XCreateSimpleWindow(display, RootWindow(display, DefaultScreen(display)), x, y, width, height, 4, 	BlackPixel(display, DefaultScreen(display)), WhitePixel(display, DefaultScreen(display)));
	XMapWindow(display, win);
	gc = XCreateGC(display, win, valuemask, &values);
	XSync(display, False);

	XSetForeground(display, gc, WhitePixel(display, DefaultScreen(display)));
	XSetBackground(display, gc, BlackPixel(display, DefaultScreen(display)));

	XAllocNamedColor(display, XDefaultColormap(display, DefaultScreen(display)),"black", &cor, &cor);

	XSetForeground(display, gc, cor.pixel);


	//Desenhando os pontos
	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP2->x;
	b = iP2->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	a = iP1->x;
	b = iP1->y;
	XDrawPoint(display, win, gc, a, b);

	//Desenhando as 12 retas
        reta(&win, &gc, display,iP1->x,iP2->x,iP1->y,iP2->y);

        reta(&win, &gc, display,iP2->x,iP4->x,iP2->y,iP4->y);

        reta(&win, &gc, display,iP4->x,iP3->x,iP4->y,iP3->y);

        reta(&win, &gc, display,iP3->x,iP1->x,iP3->y,iP1->y);

        reta(&win, &gc, display,iP1->x,iP5->x,iP1->y,iP5->y);

        reta(&win, &gc, display,iP2->x,iP6->x,iP2->y,iP6->y);

        reta(&win, &gc, display,iP3->x,iP7->x,iP3->y,iP7->y);

        reta(&win, &gc, display,iP4->x,iP8->x,iP4->y,iP8->y);

        reta(&win, &gc, display,iP5->x,iP6->x,iP5->y,iP6->y);

        reta(&win, &gc, display,iP6->x,iP8->x,iP6->y,iP8->y);

        reta(&win, &gc, display,iP8->x,iP7->x,iP8->y,iP7->y);

        reta(&win, &gc, display,iP7->x,iP5->x,iP7->y,iP5->y);


	XFlush(display);

	sleep(30);

	XFreeGC(display, gc);
	XCloseDisplay(display);

	return 0;
}
Example #21
0
void OpenGraphics() {
  Colormap map;
  char     *disp = NULL;
  XColor   exact;
  int c;

  if (!(display = XOpenDisplay(disp)))
  {
    perror("Cannot open display\n");
    exit(-1);
  }

  map = XDefaultColormap(display,DefaultScreen(display));
  
    XAllocNamedColor(display,map,"black",&color[BLACK],&exact);
    XAllocNamedColor(display,map,"grey41",&color[DIM_GREY],&exact);
    XAllocNamedColor(display,map,"grey69",&color[GREY_69],&exact);
    XAllocNamedColor(display,map,"grey75",&color[GREY],&exact);
    XAllocNamedColor(display,map,"grey82",&color[LIGHT_GREY],&exact);
    XAllocNamedColor(display,map,"white",&color[WHITE],&exact);
    XAllocNamedColor(display,map,"red",&color[RED],&exact);
    XAllocNamedColor(display,map,"green",&color[GREEN],&exact);
    XAllocNamedColor(display,map,"blue",&color[BLUE],&exact);
    XAllocNamedColor(display,map,"cyan",&color[CYAN],&exact);
    XAllocNamedColor(display,map,"magenta",&color[MAGENTA],&exact);
    XAllocNamedColor(display,map,"yellow",&color[YELLOW],&exact);
    XAllocNamedColor(display,map,"lime green",&color[LIME_GREEN],&exact);  
    XAllocNamedColor(display,map,"#00b0f0",&color[BLUE_CYAN],&exact);
    XAllocNamedColor(display,map,"#00f0b0",&color[CYAN_GREEN],&exact);
    XAllocNamedColor(display,map,"#b0f000",&color[GREEN_YELLOW],&exact);
    XAllocNamedColor(display,map,"#f0b000",&color[YELLOW_RED],&exact);
    XAllocNamedColor(display,map,"brown",&color[BROWN],&exact);
    XAllocNamedColor(display,map,"maroon",&color[MAROON],&exact);
    XAllocNamedColor(display,map,"gold",&color[GOLD],&exact);
    XAllocNamedColor(display,map,"aquamarine",&color[AQUAMARINE],&exact);
    XAllocNamedColor(display,map,"firebrick",&color[FIREBRICK],&exact);
    XAllocNamedColor(display,map,"goldenrod",&color[GOLDENROD],&exact);
    XAllocNamedColor(display,map,"blue violet",&color[BLUE_VIOLET],&exact);
    XAllocNamedColor(display,map,"cadet blue",&color[CADET_BLUE],&exact);
    XAllocNamedColor(display,map,"coral",&color[CORAL],&exact);
    XAllocNamedColor(display,map,"cornflower blue",&color[CORNFLOWER_BLUE],
                     &exact);
    XAllocNamedColor(display,map,"dark green",&color[DARK_GREEN],&exact);
    XAllocNamedColor(display,map,"dark olive green",&color[DARK_OLIVE_GREEN],
                     &exact);
    XAllocNamedColor(display,map,"peach puff",&color[PEACH_PUFF],&exact);
    XAllocNamedColor(display,map,"papaya whip",&color[PAPAYA_WHIP],&exact);
    XAllocNamedColor(display,map,"bisque",&color[BISQUE],&exact);
    XAllocNamedColor(display,map,"azure",&color[AZURE],&exact);
    XAllocNamedColor(display,map,"lavender",&color[LAVENDER],&exact);
    XAllocNamedColor(display,map,"misty rose",&color[MISTY_ROSE],&exact);
    XAllocNamedColor(display,map,"medium blue",&color[MEDIUM_BLUE],&exact);
    XAllocNamedColor(display,map,"navy blue",&color[NAVY_BLUE],&exact);
    XAllocNamedColor(display,map,"pale turquoise",&color[PALE_TURQUOISE],
                     &exact);
    XAllocNamedColor(display,map,"sea green",&color[SEA_GREEN],&exact);


  XListFonts(display,FONT1,1,&c);
  if (c) font=XLoadFont(display,FONT1);
  else   font=XLoadFont(display,FONT2);
  window = XCreateSimpleWindow(display,
                               RootWindow(display,DefaultScreen(display)),
                               0,0,WINDOW_W,WINDOW_H,0,
                               WhitePixel(display,DefaultScreen(display)),
                               BlackPixel(display,DefaultScreen(display)));
  XChangeProperty(display,window,XA_WM_NAME,XA_STRING,8,PropModeReplace,
                  (unsigned char *)
                 "Graphics",47);
  XChangeProperty(display,window,XA_WM_ICON_NAME,XA_STRING,8,PropModeReplace,
                  (unsigned char *)"Neural Map Simulator",17);
  XSelectInput(display,window,ExposureMask|KeyPressMask|ButtonPressMask|
                              ButtonReleaseMask|PointerMotionMask);
  XMapWindow(display,window);
  gc = XCreateGC(display,window,0,NULL);
  XSetBackground(display,gc,color[GREY].pixel);
  XSetFont(display,gc,font);
}
Example #22
0
int main(int argc, char *argv[]){
	FILE *fp;
	char buff[1000];
	int ch, i, j, x, y;
	int line_count = 0;

	count = -1;
	count_intersect = 0;
	k = 0;
	
	fp = fopen(argv[1], "r");

	if (fp == NULL){
		printf("There's no input file.\n");
		exit(0);
	}
	else{
		if( (display = XOpenDisplay(display_name)) == NULL ){ 
			printf("Could not open display. \n"); 
			exit(-1);
		}
		printf("Connected to X server  %s\n", XDisplayName(display_name) );
		
		screen_num = DefaultScreen(display);
		screen = DefaultScreenOfDisplay(display);
		colormap = XDefaultColormap(display, screen_num);
		display_width = DisplayWidth(display, screen_num);
		display_height = DisplayHeight(display, screen_num);

		//obtaining line count
		while(!feof(fp)){
			ch = fgetc(fp);
			if (ch == '\n'){
				line_count++;
			}
		}
		rewind(fp);
	}

	//int m[line_count][6];
	int m[line_count+1][6];

	//Creating window
	border_width = 10;
	win_x = 0; win_y = 0;
	win_width = display_width/2;
	win_height = display_height * 0.8;
	//win_height = (int)(win_width/1.7); //rectangular window

	printf("window width: %d\n window height: %d\n", display_width, display_height);

	//win = XCreateSimpleWindow(display, RootWindow(display, 0), 1, 1, win_width, win_height, 10, WhitePixel (display, 0), WhitePixel (display, 0));
	win = XCreateSimpleWindow(display, RootWindow(display, screen_num), 
		win_x, win_y, win_width, win_height, border_width,
		BlackPixel(display, screen_num), WhitePixel(display, screen_num));
	

	//Maps window on screen
	size_hints = XAllocSizeHints();
	wm_hints = XAllocWMHints();
	class_hints = XAllocClassHint();
	if (size_hints == NULL || wm_hints == NULL || class_hints == NULL){
		printf("Error allocating memory for hints\n");
		exit(-1);
	}

	size_hints -> flags = PPosition | PSize | PMinSize;
	size_hints -> min_width = 60;
	size_hints -> min_height = 60;

	XStringListToTextProperty(&win_name_string, 1, &win_name);
	XStringListToTextProperty(&icon_name_string, 1, &icon_name);

	wm_hints -> flags = StateHint | InputHint;
	wm_hints -> initial_state = NormalState;
	wm_hints -> input = False;

	class_hints -> res_name = "x_use_example";
	class_hints -> res_class = "homework1";
	
	XSetWMProperties(display, win, &win_name, &icon_name, argv, argc, size_hints, wm_hints, class_hints );
	XSelectInput(display, win, ExposureMask | KeyPressMask | ButtonPressMask);

	// put on screen
	XMapWindow(display, win);
	XFlush(display);

	//graphics setup
	green_gc = XCreateGC(display, win, 0, 0);
	XParseColor(display, colormap, green, &green_col);
	if (XAllocColor(display, colormap, &green_col) == 0){
		printf("Failed to get color green\n");
		exit(-1);
	}
	else{
		printf("Success green!\n");
		XSetForeground(display, green_gc, green_col.pixel);

	}

	red_gc = XCreateGC(display, win, 0, 0);
	XParseColor(display, colormap, red, &red_col);
	if (XAllocColor(display, colormap, &red_col) == 0){
		printf("Failed to get color red\n");
		exit(-1);
	}
	else{
		printf("Success red!\n");
		XSetForeground(display, red_gc, red_col.pixel);
	}


	black_gc = XCreateGC(display, win, 0, 0);
	XParseColor(display, colormap, black, &black_col);
	if (XAllocColor(display, colormap, &black_col) == 0){
		printf("Failed to get color black\n");
		exit(-1);
	}
	else{
		printf("Success black!\n");
		XSetForeground(display, black_gc, black_col.pixel);
	}


	light_purple_gc = XCreateGC(display, win, 0, 0);
	XParseColor(display, colormap, light_purple, &light_purple_col);
	if (XAllocColor(display, colormap, &light_purple_col) == 0){
		printf("Failed to get color light purple\n");
		exit(-1);
	}
	else{
		printf("Success light purple!\n");
		XSetForeground(display, light_purple_gc, light_purple_col.pixel);
	}


	white_gc = XCreateGC(display, win, 0, 0);
	XParseColor(display, colormap, white, &white_col);	
	if (XAllocColor(display, colormap, &white_col) == 0){
		printf("Failed to get color white\n");
		exit(-1);
	}
	else{
		printf("Success white!\n");
		XSetForeground(display, white_gc, white_col.pixel);	
	}
	

	
	while(1){
		XNextEvent(display, &report);
		switch(report.type){
			case Expose:
			{	
				
				for (i = 0; i <= line_count; i++){
					fscanf(fp, "%*s ( %d, %d) ( %d, %d) (%d, %d)", &m[i][0], &m[i][1], &m[i][2], &m[i][3], &m[i][4], &m[i][5]);
				}

				m[line_count+1][0] = -5;

				for (i = 0; i <= line_count ; i++){
					for (j=0; j<6; j+=2){
						m[i][j] = m[i][j] + 100;
						m[i][j+1] = m[i][j+1] + 100;
					}
				}

				for (i = 0; i <=line_count; i++){
					//Draw the triangles
					XDrawLine(display, win, green_gc, m[i][0], m[i][1], m[i][2], m[i][3]);
					XDrawLine(display, win, green_gc, m[i][2], m[i][3], m[i][4], m[i][5]);
					XDrawLine(display, win, green_gc, m[i][4], m[i][5], m[i][0], m[i][1]);
				}

				rewind(fp);

				if (valid_vertex[0][0] != 0.0){
					for (i= 0; i<k; i++){
						if  (valid_vertex[i][6] == 0.0 || valid_vertex[i][6] == -4.0){
							printf("from (%d, %d) to (%d, %d) length: %f and path length: %f\n", (int)valid_vertex[i][0], (int)valid_vertex[i][1], (int)valid_vertex[i][2], (int)valid_vertex[i][3], valid_vertex[i][4], valid_vertex[i][5]);
							XDrawLine(display, win, light_purple_gc, valid_vertex[i][0], valid_vertex[i][1], valid_vertex[i][2], valid_vertex[i][3]);
						}
					}

					XFillArc( display, win, black_gc, start_x, start_y, win_width/200, win_width/200, 0, 360*64);
					XFillArc( display, win, black_gc, target_x, target_y, win_width/200, win_width/200, 0, 360*64);
				}
				else{}
				//printf("exposed\n");
				XFlush(display);
				break;
			}
			case ButtonPress:
			{
				//printf("Button press %d, %d.\n",report.xbutton.x, report.xbutton.y);
				double distance1;
				x = report.xbutton.x;
				y = report.xbutton.y;
				int inTriangle;

				if (report.xbutton.button == Button1){
					/* left click */
					count++;
					
					inTriangle = check_if_in_triangle(line_count, m, x, y);

					if (inTriangle == 0){
						XFillArc( display, win, black_gc, x, y, win_width/200, win_width/200, 0, 360*64);
					}
					

				}
				else{
					printf("Closing Window.\n");
					XDestroyWindow(display, win);
					XCloseDisplay(display);
					exit(1);
				}

				//printf("count: %d\n", count);

				if (count == 0){
					reset(m, line_count);
					start_x = x;
					start_y = y;

					if (inTriangle == 1){
						count = -1;
					}
				}
				else if (count == 1){

					if (inTriangle == 0){
						target_x = x;
						target_y = y;

						printf("\n\nStarting point: (%d, %d)\nTarget point: (%d, %d)\n", start_x, start_y, target_x, target_y);

						int vertex[line_count][6];
						int * nearest_triangles;
						int * result_line_seg;

						for(i=0;i<=line_count;i++){
							//store formatted input file in array m
							fscanf(fp, "%*s ( %d, %d) ( %d, %d) (%d, %d)", &vertex[i][0], &vertex[i][1], &vertex[i][2], &vertex[i][3], &vertex[i][4], &vertex[i][5]);					
						}
						rewind(fp);
						
						printf("Total triangles: %d\n", line_count+1);

						for (i = 0; i <= line_count ; i++){
							for (j=0; j<6; j+=2){
								vertex[i][j] = vertex[i][j] + 100;
								vertex[i][j+1] = vertex[i][j+1] + 100;
							}
						}

						start_graph(line_count, vertex, start_x, start_y, target_x, target_y);

						printf("Applied start_graph()\n");
						
						shortest_path();

						printf("Applied shortest_path()\n");

						organize();

						printf("The shortest path: \n");

						for (i= 0; i<k; i++){
							if  (valid_vertex[i][6] == 0.0 || valid_vertex[i][6] == -4.0){
								printf("from (%d, %d) to (%d, %d) length: %f and path length: %f\n", (int)valid_vertex[i][0], (int)valid_vertex[i][1], (int)valid_vertex[i][2], (int)valid_vertex[i][3], valid_vertex[i][4], valid_vertex[i][5]);
								XDrawLine(display, win, light_purple_gc, valid_vertex[i][0], valid_vertex[i][1], valid_vertex[i][2], valid_vertex[i][3]);
							}
						}
						
						printf("DONE\n");
						
						count = -1;
						
					}
				}

				XFlush(display);
				break;
			}
			default:
				break;
		}
	}
	fclose(fp);
	return 0;
}
Example #23
0
int
main(int argc, char ** argv)
{

  setbuf(stdout, NULL);
  setbuf(stderr, NULL);
  
  Display * display = XOpenDisplay(NULL);
  assert(display != NULL);
  XSynchronize(display, True);

  XtAppContext context = XtCreateApplicationContext();

  Widget appshell = XtVaAppInitialize(&context, "SoXtTest", NULL, 0, &argc, argv, NULL, NULL);
  fprintf(stderr, "appshell: %p\n", appshell);

#if WANT_VISUALID
  int i, numvisuals;
  unsigned int wanted = WANT_VISUALID;
  XVisualInfo templ;
  XVisualInfo * visuals = XGetVisualInfo(display, VisualNoMask, &templ, &numvisuals);
  for ( i = 0; i < numvisuals; i++ ) {
    if ( visuals[i].visualid == wanted ) goto selected;
  }
  assert(0 && "no visual selected");
selected:

  Visual * visual = visuals[i].visual;
  int visualid = visuals[i].visualid;
  int depth = visuals[i].depth;
  Colormap colormap = 0;

  fprintf(stderr, "visualid: %d, depth: %d, class: %s\n", visualid, depth, visuals[i].c_class == DirectColor ? "DirectColor" : "Other");

  int numcmaps;
  XStandardColormap * stdcolormaps = NULL;
  if ( XmuLookupStandardColormap(display, visuals[i].screen, visuals[i].visualid, visuals[i].depth,
                                 XA_RGB_DEFAULT_MAP, False, True) &&
       XGetRGBColormaps(display, RootWindow(display, visuals[i].screen),
                        &stdcolormaps, &numcmaps, XA_RGB_DEFAULT_MAP) ) {
    for ( int j = 0; j < numcmaps; j++ ) {
      if (stdcolormaps[j].visualid == visuals[i].visualid) {
        colormap = stdcolormaps[j].colormap;
        goto cont;
      }
    }
    colormap = XCreateColormap(display, RootWindow(display, visuals[i].screen), visuals[i].visual, AllocNone);
    fprintf(stderr, "standard RGB colormaps did not work with visual - created own (%ld)", colormap);
  } else {
    assert(0);
  }

cont:
  fprintf(stderr, "colormap: %ld\n", colormap);
#else
  Visual * visual = NULL;
  int depth = 0;
  Colormap colormap = 0;

  int snum = XDefaultScreen(display);
  visual = XDefaultVisual(display, snum);
  depth = XDefaultDepth(display, snum);
  colormap = XDefaultColormap(display, snum);

  fprintf(stderr, "visual: %p, depth: %d\n", visual, depth);
  fprintf(stderr, "colormap: %ld\n", colormap);
#endif

  XtVaSetValues(appshell,
    XmNwidth, 100,
    XmNheight, 100,
    XmNvisual, visual,
    XmNcolormap, colormap,
    XmNdepth, depth,
    NULL);

  Widget form = XtVaCreateManagedWidget(
    "form", xmFormWidgetClass,
    appshell,
    NULL);

  Widget button = XtVaCreateManagedWidget(
    "button", xmPushButtonWidgetClass,
    form,
    XmNtopAttachment, XmATTACH_FORM,
    XmNleftAttachment, XmATTACH_FORM,
    XmNbottomAttachment, XmATTACH_FORM,
    XmNrightAttachment, XmATTACH_FORM,
    NULL);

  Pixmap pixmap = createPixmapFromXpm(button, home_xpm);
  XtVaSetValues(button,
    XmNlabelType, XmPIXMAP,
    XmNlabelPixmap, pixmap,
    XmNlabelInsensitivePixmap, pixmap,
    XmNselectPixmap, pixmap,
    XmNselectInsensitivePixmap, pixmap,
    NULL);

  Widget list[] = { appshell, form, button, NULL };
  XtSetWMColormapWindows(appshell, list, 3);

  XtRealizeWidget(appshell);
  XtAppMainLoop(context);
}
Example #24
0
int main(int argc, char **argv)
{
  /* code add by andrew GONG for reading file from command line argument */
    
    point p[N];
    point q[N];
    point array[V];
    unsigned int G[V][V];

    point s = {0, 0};
    point t = {0, 0};
    int i, j, k;
    int press;
    i = j = k = 0;
    press = 0;

    for (i = 0; i < N; i++) {
      p[i].x = p[i].y = 0;
      q[i].x = q[i].y = 0;
    }
    
    if(argc != 2) {
      printf("usage:%s filename", argv[0]);
    }
    else {
      FILE *file = fopen(argv[1], "r");
      if(file == 0) {
        printf("Could not open file!\n");
      }
      else {
        i = 0;
        printf("%s\n", argv[1]);
        while(!feof(file)) {
          if(fscanf(file, "S (%d, %d) (%d, %d)\n",
		    &p[i].x, &p[i].y, &q[i].x, &q[i].y) != 4) {
            break;
          }
          else {
            i++;
          }
        }
      }
      
      fclose(file);
    }
    
    
    


  /* opening display: basic connection to X Server */
  if( (display_ptr = XOpenDisplay(display_name)) == NULL )
    { printf("Could not open display. \n"); exit(-1); }
  printf("Connected to X server  %s\n", XDisplayName(display_name));
  screen_num = DefaultScreen(display_ptr);
  screen_ptr = DefaultScreenOfDisplay(display_ptr);
  color_map  = XDefaultColormap(display_ptr, screen_num);
  display_width  = DisplayWidth(display_ptr, screen_num);
  display_height = DisplayHeight(display_ptr, screen_num);

  printf("Width %d, Height %d, Screen Number %d\n", 
           display_width, display_height, screen_num);

  /* creating the window */
  border_width = 10;
  win_x = 0; win_y = 0;
  win_width = display_width/2; 
  win_height = (unsigned int) (win_width / 1.7); /* rectangular window */
  win= XCreateSimpleWindow(display_ptr, RootWindow(display_ptr, screen_num), win_x, win_y, win_width, win_height, border_width, BlackPixel(display_ptr, screen_num), WhitePixel(display_ptr, screen_num));

/* now try to put it on screen, this needs cooperation of window manager */
  size_hints = XAllocSizeHints();
  wm_hints = XAllocWMHints(); 
  class_hints = XAllocClassHint(); 
  if( size_hints == NULL || wm_hints == NULL || class_hints == NULL ) {
    printf("Error allocating memory for hints. \n"); exit(-1); }
  size_hints -> flags = PPosition | PSize | PMinSize  ; 
  size_hints -> min_width = 60; 
  size_hints -> min_height = 60; 
  XStringListToTextProperty(&win_name_string, 1, &win_name);
  XStringListToTextProperty(&icon_name_string, 1, &icon_name);
  wm_hints -> flags = StateHint | InputHint ; 
  wm_hints -> initial_state = NormalState; 
  wm_hints -> input = False; 
  class_hints -> res_name = "x_use_example"; 
  class_hints -> res_class = "examples"; 
  XSetWMProperties(display_ptr, win, &win_name, &icon_name, argv, argc, size_hints, wm_hints, class_hints);

  /* what events do we want to receive */
  XSelectInput(display_ptr, win,
            ExposureMask | StructureNotifyMask | ButtonPressMask);
  
  /* finally: put window on screen */
  XMapWindow(display_ptr, win);

  XFlush(display_ptr);
  /* create graphics context, so that we may draw in this window */
  gc = XCreateGC(display_ptr, win, valuemask, &gc_values);
  XSetForeground(display_ptr, gc, BlackPixel(display_ptr, screen_num));
  XSetLineAttributes(display_ptr, gc, 2, LineSolid, CapRound, JoinRound);

  /* and three other graphics contexts, to draw in yellow and red and grey */
  gc_yellow = XCreateGC( display_ptr, win, valuemask, &gc_yellow_values);
  XSetLineAttributes(display_ptr, gc_yellow, 2, LineSolid, CapRound, JoinRound);
  if(XAllocNamedColor(display_ptr, color_map, "yellow",
			&tmp_color1, &tmp_color2 ) == 0)
    {printf("failed to get color yellow\n"); exit(-1); } 
  else
    XSetForeground(display_ptr, gc_yellow, tmp_color1.pixel);
  gc_red = XCreateGC(display_ptr, win, valuemask, &gc_red_values);
 /* XSetLineAttributes(display_ptr, gc_red, 6, LineSolid, CapRound, JoinRound); */
  if( XAllocNamedColor(display_ptr, color_map, "red",
			&tmp_color1, &tmp_color2) == 0 )
    {printf("failed to get color red\n"); exit(-1);} 
  else
    XSetForeground(display_ptr, gc_red, tmp_color1.pixel);
  gc_grey = XCreateGC(display_ptr, win, valuemask, &gc_grey_values);
  if( XAllocNamedColor(display_ptr, color_map, "light grey",
			&tmp_color1, &tmp_color2) == 0)
    {printf("failed to get color grey\n"); exit(-1);} 
  else
    XSetForeground(display_ptr, gc_grey, tmp_color1.pixel);

  /* and now it starts: the event loop */
  while(1) { 
    XNextEvent( display_ptr, &report );
    switch(report.type)
    {
      case Expose:
      /* (re-)draw the example figure. This event happens
       * each time some part ofthe window gets exposed (becomes visible) */
      
      /* print all the obstacles */
      for (i = 0; i < N; i++) {
        if (p[i].x != 0 && p[i].y != 0 && q[i].x != 0 && q[i].y !=0) {
          XDrawLine(display_ptr, win, gc, p[i].x, p[i].y, q[i].x, q[i].y);
        }
      }
      break;
      case ConfigureNotify:
      /* This event happens when the user changes the size of the window */
      win_width = report.xconfigure.width;
      win_height = report.xconfigure.height;
      break;

      /* This event happens when the user pushes a mouse button. I draw
       * a circle to show the point where it happened, but do not save 
       * the position; so when the next redraw event comes, these circles
       * disappear again. */
      case ButtonPress: {
      int x, y;
      x = report.xbutton.x;
      y = report.xbutton.y;
      /* read point s, t */
      if (press == 0) {
	    s.x = report.xbutton.x;
	    s.y = report.xbutton.y;
      }
      else if (press == 1) {
	    t.x = report.xbutton.x;
	    t.y = report.xbutton.y;
      }
      
      press += 1;
      
      if (report.xbutton.button == Button1)
	    XFillArc(display_ptr, win, gc_red,
        x - win_height/40, y - win_height/40,
        win_height / 20, win_height / 20, 0, 360*64);
      else
	    XFillArc(display_ptr, win, gc_yellow,
        x - win_height / 40, y - win_height / 40,
        win_height / 20, win_height / 20, 0, 360*64);
      
      
      printf("%d, %d, %d, %d\n", s.x, s.y, t.x, t.y);
      printf("press = %d\n", press);
      
      if (press == 2) {
        XFlush(display_ptr);
          /* construction graph G
           *s is the first point and t is the last point */
	
        array[0].x = s.x;
        array[0].y = s.y;
        array[V-1].x = t.x;
        array[V-1].y = t.y;
	  
        for (i = 1; i < V-1; i++) {
          if ( i <= N ) {
            array[i].x = p[i-1].x;
            array[i].y = p[i-1].y;
          }
          else if (i > N) {
            array[i].x = q[i-N-1].x;
            array[i].y = q[i-N-1].y;
          }
        }
	
        for (i = 0; i < V; i++) {
          int j;
          for(j = 0; j < V; j++) {
            if (( array[i].x == 0 && array[i].y == 0 ) || ( array[j].x == 0 && array[j].y == 0)) {
              G[i][j] = INT_MAX;
            }
            else {
              G[i][j] = distant(array[i],array[j]);
            }
            for (k = 0; k < N; k++) {
              if (p[k].x != 0 && p[k].y != 0 && q[k].x != 0 &&
                  q[k].y != 0 && array[i].x !=0 && array[i].y !=0 &&
                  intersect( array[i], array[j], p[k], q[k])) {
                G[i][j] = INT_MAX;
              }
            }
          }
        }
	    
        dijkstra(G, 0, array);
      }
    }
      break;
    default:
      /* this is a catch-all for other events; it does not do anything.
       *One could look at the report type to see what the event was */ 
      break;
    }
    
  }
  
  exit(0);
}