g2_x11.c

ViennaRNA-1.6.1

	return -1;
    }
}


int g2_X11_clear_palette(int pid, void *pdp)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XFreeColors(xout->display,xout->colormap,
		xout->inks,xout->NofInks,0x0ul);
    xout->NofInks=0;
    if(xout->inks!=NULL)
        free(xout->inks);
    xout->inks=NULL;
    return 0;
}


int g2_X11_set_background(int pid, void *pdp, int color)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    if(color>=xout->NofInks || color<0)
	return -1;
    if (xout->backing_pixmap == None)
      {
        XSetWindowBackground(xout->display,xout->dest,
			 xout->inks[color]);
      }
    else
      {
	xout->background = xout->inks[color];
      }
    g2_X11_clear(pid,pdp);
    return 0;
}


int g2_X11_pen(int pid, void *pdp, int color)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    if(color>=xout->NofInks || color<0)
	return -1;
    XSetForeground(xout->display, xout->gc, xout->inks[color]);
    return 0;
}



int g2_X11_paper(int pid, void *pdp, int color)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    if(color>=xout->NofInks || color<0)
	return -1;
    XSetBackground(xout->display, xout->gc, xout->inks[color]);
    return 0;
}


int g2_X11_set_line_width(int pid, void *pdp, int w)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XGCValues val;
    
    val.line_width=w;
    XChangeGC(xout->display, xout->gc, GCLineWidth, &val);
    return 0;
}


int g2_X11_set_dash(int pid, void *pdp, int n, int *data)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XGCValues val;
    int i;
    
    if(n<=0 || data==NULL) {
	val.line_style=LineSolid;
	XChangeGC(xout->display, xout->gc, GCLineStyle,&val);
    } else {
	char *ch_data;
	ch_data=g2_malloc(n*sizeof(char));
	val.line_style=LineOnOffDash;
	for(i=0;i<n;i++)
	    if(data[i]>0)
		ch_data[i]=(char)data[i];
	    else
		ch_data[i]=1;
	XChangeGC(xout->display, xout->gc, GCLineStyle, &val);
	XSetDashes(xout->display, xout->gc, 0, ch_data, n);
	g2_free(ch_data);
    }
    return 0;
}


int g2_X11_set_font_size(int pid, void *pdp, int size)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XFontStruct *fnt_str;
    char font_name[256];
    int sizei, d, n;
    
    sizei=dtoi(size);

    if(sizei<=0)
	sizei=1;				  /* set to smallest size */
    
    for(n=1;n<32;n++) {
	d=((n&0x01)? -1:1)*(n>>1);
	sprintf(font_name, g2_X11Font, sizei+d);
	fnt_str=XLoadQueryFont(xout->display, font_name);
	if(fnt_str==NULL) {
	    if(!d)
		fprintf(stderr,"g2: can not load font: '%s'\n",font_name);
	} else {
	    XSetFont(xout->display,xout->gc,fnt_str->fid);
	    if(d)
		fprintf(stderr,"g2: using '%s' instead\n",font_name);
	    return 0;
	}
    }
    fprintf(stderr, "g2: are you sure about %d point size\n", size);
    return -1;
}


int g2_X11_plot(int pid, void *pdp, int x, int y)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawPoint(xout->display, xout->dest, xout->gc,
	       x, y);
    return 0;
}


int g2_X11_line(int pid, void *pdp, int x1, int y1, int x2, int y2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawLine(xout->display,xout->dest,xout->gc,
	      x1, y1, x2, y2);
    return 0;
}


int g2_X11_poly_line(int pid, void *pdp, int N, int *p)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XPoint *points;
    int i;
    points=g2_malloc(N*sizeof(XPoint));
    for(i=0;i<N;i++) {
	points[i].x=(short)p[i*2];
	points[i].y=(short)p[i*2+1];
    }
    XDrawLines(xout->display,xout->dest,xout->gc,
	       points, N,
	       CoordModeOrigin);
    g2_free(points);
    return 0;
}


int g2_X11_polygon(int pid, void *pdp, int N, int *p)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XPoint *points;
    int i;
    points=g2_malloc((N+1)*sizeof(XPoint));
    for(i=0;i<N;i++) {
	points[i].x=(short)p[i*2];
	points[i].y=(short)p[i*2+1];
    }
    points[N].x=(short)p[0];
    points[N].y=(short)p[1];
    XDrawLines(xout->display,xout->dest,xout->gc,
	       points, N+1,
	       CoordModeOrigin);
    g2_free(points);
    return 0;
}


int g2_X11_filled_polygon(int pid, void *pdp, int N, int *p)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XPoint *points;
    int i;
    points=g2_malloc((N+1)*sizeof(XPoint));
    for(i=0;i<N;i++) {
	points[i].x=(short)p[i*2];
	points[i].y=(short)p[i*2+1];
    }
    points[N].x=(short)p[0];
    points[N].y=(short)p[1];
    XFillPolygon(xout->display,xout->dest,xout->gc,
		 points, N+1,
		 Complex, CoordModeOrigin);
    g2_free(points);
    return 0;
}


int g2_X11_triangle(int pid, void *pdp,
		    int x1, int y1,
		    int x2, int y2,
		    int x3, int y3)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XPoint points[4];
    points[0].x=x1; points[0].y=y1; 
    points[1].x=x2; points[1].y=y2; 
    points[2].x=x3; points[2].y=y3; 
    points[3].x=x1; points[3].y=y1; 
    XDrawLines(xout->display,xout->dest,xout->gc,
	       points, 4, CoordModeOrigin);
    return 0;
}


int g2_X11_filled_triangle(int pid, void *pdp,
			   int x1, int y1,
			   int x2, int y2,
			   int x3, int y3)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XPoint points[4];
    points[0].x=x1; points[0].y=y1; 
    points[1].x=x2; points[1].y=y2; 
    points[2].x=x3; points[2].y=y3; 
    points[3].x=x1; points[3].y=y1; 
    XFillPolygon(xout->display,xout->dest,xout->gc,
		 points, 4, Convex, CoordModeOrigin);
    return 0;
}


int g2_X11_rectangle(int pid, void *pdp, int x1, int y1, int x2, int y2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawRectangle(xout->display,xout->dest,xout->gc,
		   x1, y1, x2-x1, y2-y1);
    return 0;
}



int g2_X11_filled_rectangle(int pid, void *pdp, int x1, int y1, int x2, int y2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawRectangle(xout->display,xout->dest,xout->gc,
		   x1, y1, x2-x1, y2-y1);
    XFillRectangle(xout->display,xout->dest,xout->gc,
		   x1, y1, x2-x1, y2-y1);
    return 0;
}


int g2_X11_arc(int pid, void *pdp, int x, int y,
	       int r1, int r2, double a1, double a2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    double a0, d;

    a0=fmod(a1, 360.) + (a1<0? 360:0);   /* map a1 to [0, 360) */
    d=a2>a1? a2-a1:a2-a1+360;
     
    XDrawArc(xout->display,xout->dest,xout->gc,
	     x-r1, y-r2,
	     r1*2, r2*2,
	     (int)(a0*64.), (int)(d*64.));
    return 0;
}
 

int g2_X11_filled_arc(int pid, void *pdp, int x, int y,
		      int r1, int r2, double a1, double a2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    double a0, d;
    
    a0=fmod(a1, 360.) + (a1<0? 360:0);   /* map a1 to [0, 360) */
    d=a2>a1? a2-a1:a2-a1+360;
    
    XDrawArc(xout->display,xout->dest,xout->gc,
	     x-r1, y-r2,
	     r1*2, r2*2,
	     (int)(a0*64.), (int)(d*64.));
    XFillArc(xout->display,xout->dest,xout->gc,
	     x-r1, y-r2,
	     r1*2, r2*2,
	     (int)(a0*64.), (int)(d*64.));
    return 0;
}
 

int g2_X11_ellipse(int pid, void *pdp, int x, int y, int r1, int r2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawArc(xout->display,xout->dest,xout->gc,
	     x-r1, y-r2,
	     r1*2, r2*2,
	     0,360*64);
    return 0;
}


int g2_X11_filled_ellipse(int pid, void *pdp, int x, int y, int r1, int r2)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawArc(xout->display,xout->dest,xout->gc,
	     x-r1, y-r2,
	     r1*2, r2*2,
	     0,360*64);
    XFillArc(xout->display,xout->dest,xout->gc,
	     x-r1, y-r2,
	     r1*2, r2*2,
	     0,360*64);
    XFlush(xout->display);
    return 0;
}
 

int g2_X11_draw_string(int pid, void *pdp, int x, int y, const char *text)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XDrawString(xout->display,xout->dest,xout->gc,
		x, y, text, strlen(text));
    return 0;
}


int g2_X11_image(int pid, void *pdp,
		 int x, int y, int width, int height, int *pen_array)
{
    g2_X11_device *xout=&g2_X11_dev[pid];
    XImage *image=NULL;
    Screen *screen;
    unsigned long *ink_array;
    int i;

    ink_array=malloc(sizeof(unsigned long)*width*height);
    for(i=0;i<width*height;i++)
	ink_array[i]=xout->inks[pen_array[i]];

    screen=DefaultScreenOfDisplay(xout->display);
    image=XCreateImage(xout->display,
		       DefaultVisualOfScreen(screen),
		       DefaultDepthOfScreen(screen),
		       ZPixmap,
		       0,			  /* offset */
		       (char *)ink_array,
		       width, height,
		       sizeof(unsigned long)*8,	  /* bitmap pad */
		       0);			  /* bytes per line */
    /* XInitImage(image); problems with AIX ?!! */
    XPutImage(xout->display, xout->dest, xout->gc,
	      image,
	      0, 0,
	      x, y, width, height);
	
    XDestroyImage(image);
    free(ink_array);
    return 0;
}


int g2_X11_query_pointer(int pid, void *pdp,
			 int *x, int *y, unsigned int *button)
{
    Bool rv;
    g2_X11_device *xout=&g2_X11_dev[pid];
    Window root, child;
    int rx, ry;

    rv = XQueryPointer(xout->display, xout->window,
		       &root, &child, &rx, &ry,
		       x, y, button);

    if(rv)
	return 0;
    else
	return 1;
}



int g2_X11_get_pd_handles(int pid, void *pdp, void *handles[G2_PD_HANDLES_SIZE])
{
    g2_X11_device *xout=&g2_X11_dev[pid];

    handles[0]=xout->display;
    handles[1]=&xout->window;
    handles[2]=&xout->root;
    handles[3]=&xout->colormap;
    handles[4]=&xout->gc;
    handles[5]=&xout->dest;
    return 0;
}