The R Project SVN R

Rev

Rev 8872 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 8872 Rev 8971
Line 17... Line 17...
17 
 *  along with this program; if not, write to the Free Software
 17 
 *  along with this program; if not, write to the Free Software
18 
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 18 
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 
 */
 19 
 */
20 
 
 20 
 
21 
/*--- Device Driver for Windows; this file started from
 21 
/*--- Device Driver for Windows; this file started from
22 
 *  ../unix/devX11.c --
 22 
 *  ../unix/X11/devX11.c --
23 
 */
 23 
 */
24 
#ifdef HAVE_CONFIG_H
 24 
#ifdef HAVE_CONFIG_H
25 
#include <config.h>
 25 
#include <config.h>
26 
#endif
 26 
#endif
27 
 
 27 
 
Line 54... Line 54...
54 
#define SHOW  gbitblt(xd->gawin,xd->bm,pt(0,0),getrect(xd->bm));
 54 
#define SHOW  gbitblt(xd->gawin,xd->bm,pt(0,0),getrect(xd->bm));
55 
 
 55 
 
56 
        /********************************************************/
 56 
        /********************************************************/
57 
	/* Each driver can have its own device-specic graphical */
 57 
	/* Each driver can have its own device-specic graphical */
58 
	/* parameters and resources.  these should be wrapped	*/
 58 
	/* parameters and resources.  these should be wrapped	*/
59 
	/* in a structure (like the x11Desc structure below)    */
 59 
	/* in a structure (like the gadesc structure below)    */
60 
	/* and attached to the overall device description via 	*/
 60 
	/* and attached to the overall device description via 	*/
61 
	/* the dd->deviceSpecific pointer			*/
 61 
	/* the dd->deviceSpecific pointer			*/
62 
	/* NOTE that there are generic graphical parameters	*/
 62 
	/* NOTE that there are generic graphical parameters	*/
63 
	/* which must be set by the device driver, but are	*/
 63 
	/* which must be set by the device driver, but are	*/
64 
	/* common to all device types (see Graphics.h)		*/
 64 
	/* common to all device types (see Graphics.h)		*/
Line 100... Line 100...
100 
    int   recording, replaying, needsave;
 100 
    int   recording, replaying, needsave;
101 
    bitmap bm;
 101 
    bitmap bm;
102 
  /* PNG and JPEG section */
 102 
  /* PNG and JPEG section */
103 
    FILE *fp;
 103 
    FILE *fp;
104 
    int quality;
 104 
    int quality;
105 
  /*Used to rescale font size so that bitmap devices have 72dpi */
 105 
  /* Used to rescale font size so that bitmap devices have 72dpi */
106 
    int truedpi, wanteddpi;
106 
    int truedpi, wanteddpi;
107 
    rgb   fgcolor;		/* Foreground color */
 107 
    rgb   fgcolor;		/* Foreground color */
108 
    rgb   bgcolor;		/* Background color */
 108 
    rgb   bgcolor;		/* Background color */
109 
    rect  clip;			/* The clipping rectangle */
 109 
    rect  clip;			/* The clipping rectangle */
110 
    int   usefixed;
 110 
    int   usefixed;
111 
    font  fixedfont;
 111 
    font  fixedfont;
112 
    font  font;
 112 
    font  font;
113 
    int   locator, clicked, px, py;
 113 
    int   locator, clicked, px, py;
114 
    int   lty, lwd;
 114 
    int   lty, lwd;
115 
}     x11Desc;
 115 
}     gadesc;
116 
 
 - 
 
117 
	/********************************************************/
 - 
 
118 
	/* If there are resources that are shared by all devices*/
 - 
 
119 
	/* of this type, you may wish to make them globals	*/
 - 
 
120 
	/* rather than including them in the device-specific	*/
 - 
 
121 
	/* parameters structure (especially if they are large !)*/
 - 
 
122 
	/********************************************************/
 - 
 
123 
 
 - 
 
124 
			/* X11 Driver Specific */
 - 
 
125 
			/* parameters with only one copy for all x11 devices */
 - 
 
126 
 
 - 
 
127 
 
 - 
 
128 
	/********************************************************/
 - 
 
129 
	/* There must be an entry point for the device driver	*/
 - 
 
130 
	/* which will create device-specific resources, 	*/
 - 
 
131 
	/* initialise the device-specific parameters structure 	*/
 - 
 
132 
	/* and return whether the setup succeeded		*/
 - 
 
133 
	/* This is called by the graphics engine when the user	*/
 - 
 
134 
	/* creates a new device of this type			*/
 - 
 
135 
	/********************************************************/
 - 
 
136 
 
 116 
 
137 
 
 117 
 
138 
	/********************************************************/
 118 
	/********************************************************/
139 
	/* There are a number of actions that every device 	*/
 119 
	/* There are a number of actions that every device 	*/
140 
	/* driver is expected to perform (even if, in some	*/
 120 
	/* driver is expected to perform (even if, in some	*/
Line 146... Line 126...
146 
	/* device is first created				*/
 126 
	/* device is first created				*/
147 
	/********************************************************/
 127 
	/********************************************************/
148 
 
 128 
 
149 
	/* Device Driver Actions */
 129 
	/* Device Driver Actions */
150 
 
 130 
 
151 
static void   X11_Activate(DevDesc *);
 131 
static void   GA_Activate(DevDesc *);
152 
static void   X11_Circle(double, double, int, double, int, int, DevDesc*);
 132 
static void   GA_Circle(double, double, int, double, int, int, DevDesc*);
153 
static void   X11_Clip(double, double, double, double, DevDesc*);
 133 
static void   GA_Clip(double, double, double, double, DevDesc*);
154 
static void   X11_Close(DevDesc*);
 134 
static void   GA_Close(DevDesc*);
155 
static void   X11_Deactivate(DevDesc *);
 135 
static void   GA_Deactivate(DevDesc *);
156 
static void   X11_Hold(DevDesc*);
 136 
static void   GA_Hold(DevDesc*);
157 
static void   X11_Line(double, double, double, double, int, DevDesc*);
 137 
static void   GA_Line(double, double, double, double, int, DevDesc*);
158 
static int    X11_Locator(double*, double*, DevDesc*);
 138 
static int    GA_Locator(double*, double*, DevDesc*);
159 
static void   X11_Mode(int);
 139 
static void   GA_Mode(int);
160 
static void   X11_NewPage(DevDesc*);
 140 
static void   GA_NewPage(DevDesc*);
161 
static int    X11_Open(DevDesc*, x11Desc*, char*, double, double);
 141 
static int    GA_Open(DevDesc*, gadesc*, char*, double, double);
162 
static void   X11_Polygon(int, double*, double*, int, int, int, DevDesc*);
 142 
static void   GA_Polygon(int, double*, double*, int, int, int, DevDesc*);
163 
static void   X11_Polyline(int, double*, double*, int, DevDesc*);
 143 
static void   GA_Polyline(int, double*, double*, int, DevDesc*);
164 
static void   X11_Rect(double, double, double, double, int, int, int, DevDesc*);
 144 
static void   GA_Rect(double, double, double, double, int, int, int, DevDesc*);
165 
static void   X11_Resize(DevDesc*);
 145 
static void   GA_Resize(DevDesc*);
166 
static double X11_StrWidth(char*, DevDesc*);
 146 
static double GA_StrWidth(char*, DevDesc*);
167 
static void   X11_Text(double, double, int, char*, double, double, DevDesc*);
 147 
static void   GA_Text(double, double, int, char*, double, double, DevDesc*);
168 
static void   X11_MetricInfo(int, double*, double*, double*, DevDesc*);
 148 
static void   GA_MetricInfo(int, double*, double*, double*, DevDesc*);
169 
 
 149 
 
170 
	/********************************************************/
 150 
	/********************************************************/
171 
	/* end of list of required device driver actions 	*/
 151 
	/* end of list of required device driver actions 	*/
172 
	/********************************************************/
 152 
	/********************************************************/
173 
 
 153 
 
Line 186... Line 166...
186 
static void SaveAsBitmap(DevDesc *dd);
 166 
static void SaveAsBitmap(DevDesc *dd);
187 
void  R_ProcessEvents();
 167 
void  R_ProcessEvents();
188 
 
 168 
 
189 
static void PrivateCopyDevice(DevDesc *dd,DevDesc *ndd, char *name)
 169 
static void PrivateCopyDevice(DevDesc *dd,DevDesc *ndd, char *name)
190 
{
 170 
{
191 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 171 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
192 
    gsetcursor(xd->gawin, WatchCursor);
 172 
    gsetcursor(xd->gawin, WatchCursor);
193 
    gsetVar(install(".Device"),
 173 
    gsetVar(install(".Device"),
194 
	    mkString(name), R_NilValue);
 174 
	    mkString(name), R_NilValue);
195 
    addDevice(ndd);
 175 
    addDevice(ndd);
196 
    initDisplayList(ndd);
 176 
    initDisplayList(ndd);
Line 209... Line 189...
209 
	R_ShowMessage("No enough memory to copy graphics window");
 189 
	R_ShowMessage("No enough memory to copy graphics window");
210 
	return;
 190 
	return;
211 
    }
 191 
    }
212 
    ndd->displayList = R_NilValue;
 192 
    ndd->displayList = R_NilValue;
213 
    GInit(&ndd->dp);
 193 
    GInit(&ndd->dp);
214 
    if (X11DeviceDriver(ndd, display,
 194 
    if (GADeviceDriver(ndd, display,
215 
			 GConvertXUnits(1.0, NDC, INCHES, dd),
 195 
			 GConvertXUnits(1.0, NDC, INCHES, dd),
216 
			 GConvertYUnits(1.0, NDC, INCHES, dd),
 196 
			 GConvertYUnits(1.0, NDC, INCHES, dd),
217 
			 dd->gp.ps))
 197 
			 dd->gp.ps))
218 
        PrivateCopyDevice(dd, ndd, display);
 198 
        PrivateCopyDevice(dd, ndd, display);
219 
}
 199 
}
220 
 
 200 
 
221 
 
 201 
 
222 
static void SaveAsPostscript(DevDesc *dd, char *fn)
 202 
static void SaveAsPostscript(DevDesc *dd, char *fn)
223 
{
 203 
{
224 
   SEXP s = findVar(install(".PostScript.Options"), R_GlobalEnv);
 204 
    SEXP s = findVar(install(".PostScript.Options"), R_GlobalEnv);
225 
   DevDesc *ndd = (DevDesc *) malloc(sizeof(DevDesc));
 205 
    DevDesc *ndd = (DevDesc *) malloc(sizeof(DevDesc));
226 
   char family[256], paper[256], bg[256], fg[256];
 206 
    char family[256], paper[256], bg[256], fg[256];
227 
 
 207 
 
228 
   if (!ndd) {
 208 
    if (!ndd) {
229 
	R_ShowMessage("No enough memory to copy graphics window");
 209 
	R_ShowMessage("No enough memory to copy graphics window");
230 
	return;
 210 
	return;
231 
   }
 211 
    }
232 
   ndd->displayList = R_NilValue;
 212 
    ndd->displayList = R_NilValue;
233 
   GInit(&ndd->dp);
 213 
    GInit(&ndd->dp);
234 
 
 214 
 
235 
   /* Set default values... */
 215 
    /* Set default values... */
236 
   strcpy(family, "Helvetica");
 216 
    strcpy(family, "Helvetica");
237 
   strcpy(paper, "default");
 217 
    strcpy(paper, "default");
238 
   strcpy(bg, "white");
 218 
    strcpy(bg, "white");
239 
   strcpy(fg, "black");
 219 
    strcpy(fg, "black");
240 
   /* and then try to get it from .PostScript.Options */
 220 
    /* and then try to get it from .PostScript.Options */
241 
   if ((s!=R_UnboundValue) && (s!=R_NilValue)) {
 221 
    if ((s!=R_UnboundValue) && (s!=R_NilValue)) {
242 
      SEXP names = getAttrib(s, R_NamesSymbol);
 222 
	SEXP names = getAttrib(s, R_NamesSymbol);
243 
      int i,done;
 223 
	int i,done;
244 
      for (i=0, done=0; (done<4) && (i<length(s)) ; i++) {
 224 
	for (i=0, done=0; (done<4) && (i<length(s)) ; i++) {
245 
        if(!strcmp("family", CHAR(STRING(names)[i]))) {
 225 
	    if(!strcmp("family", CHAR(STRING(names)[i]))) {
246 
           strcpy(family, CHAR(STRING(VECTOR(s)[i])[0]));
 226 
		strcpy(family, CHAR(STRING(VECTOR(s)[i])[0]));
247 
           done += 1;
 227 
		done += 1;
248 
        }
 228 
	    }
249 
        if(!strcmp("paper", CHAR(STRING(names)[i]))) {
 229 
	    if(!strcmp("paper", CHAR(STRING(names)[i]))) {
250 
           strcpy(paper, CHAR(STRING(VECTOR(s)[i])[0]));
 230 
		strcpy(paper, CHAR(STRING(VECTOR(s)[i])[0]));
251 
           done += 1;
 231 
		done += 1;
252 
        }
 232 
	    }
253 
        if(!strcmp("bg", CHAR(STRING(names)[i]))) {
 233 
	    if(!strcmp("bg", CHAR(STRING(names)[i]))) {
254 
           strcpy(bg, CHAR(STRING(VECTOR(s)[i])[0]));
 234 
		strcpy(bg, CHAR(STRING(VECTOR(s)[i])[0]));
255 
           done += 1;
 235 
		done += 1;
256 
        }
 236 
	    }
257 
        if(!strcmp("fg", CHAR(STRING(names)[i]))) {
 237 
	    if(!strcmp("fg", CHAR(STRING(names)[i]))) {
258 
           strcpy(fg, CHAR(STRING(VECTOR(s)[i])[0]));
 238 
		strcpy(fg, CHAR(STRING(VECTOR(s)[i])[0]));
259 
           done += 1;
 239 
		done += 1;
260 
        }
 240 
	    }
261 
      }
 241 
	}
262 
   }
 242 
    }
263 
   if (PSDeviceDriver(ndd, fn, paper, family, bg, fg,
 243 
    if (PSDeviceDriver(ndd, fn, paper, family, bg, fg,
264 
		      GConvertXUnits(1.0, NDC, INCHES, dd),
 244 
		       GConvertXUnits(1.0, NDC, INCHES, dd),
265 
		      GConvertYUnits(1.0, NDC, INCHES, dd),
 245 
		       GConvertYUnits(1.0, NDC, INCHES, dd),
266 
		      (double)0, dd->gp.ps, 0, 1, 0, ""))
 246 
		       (double)0, dd->gp.ps, 0, 1, 0, ""))
267 
    /* horizontal=F, onefile=F, pagecentre=T, print.it=F */
 247 
	/* horizontal=F, onefile=F, pagecentre=T, print.it=F */
268 
     PrivateCopyDevice(dd, ndd, "postscript");
 248 
	PrivateCopyDevice(dd, ndd, "postscript");
269 
}
 249 
}
270 
 
 250 
 
271 
 
 251 
 
272 
 
 252 
 
273 
			/* Pixel Dimensions (Inches) */
 253 
			/* Pixel Dimensions (Inches) */
Line 366... Line 346...
366 
    }
 346 
    }
367 
}
 347 
}
368 
 
 348 
 
369 
 
 349 
 
370 
 
 350 
 
371 
static int SetBaseFont(x11Desc *xd)
 351 
static int SetBaseFont(gadesc *xd)
372 
{
 352 
{
373 
    xd->fontface = 1;
 353 
    xd->fontface = 1;
374 
    xd->fontsize = xd->basefontsize;
 354 
    xd->fontsize = xd->basefontsize;
375 
    xd->fontangle = 0.0;
 355 
    xd->fontangle = 0.0;
376 
    xd->usefixed = 0;
 356 
    xd->usefixed = 0;
377 
    xd->font = gnewfont(xd->gawin, fontname[0], fontstyle[0],
357 
    xd->font = gnewfont(xd->gawin, fontname[0], fontstyle[0],
378 
			MulDiv(xd->fontsize,xd->wanteddpi,xd->truedpi), 0.0);
 358 
			MulDiv(xd->fontsize, xd->wanteddpi, xd->truedpi), 0.0);
379 
    if (!xd->font) {
 359 
    if (!xd->font) {
380 
	xd->usefixed = 1;
 360 
	xd->usefixed = 1;
381 
	xd->font = xd->fixedfont = FixedFont;
 361 
	xd->font = xd->fixedfont = FixedFont;
382 
	if (!xd->fixedfont)
 362 
	if (!xd->fixedfont)
383 
	    return 0;
 363 
	    return 0;
Line 396... Line 376...
396 
#define SMALLEST 8
 376 
#define SMALLEST 8
397 
#define LARGEST 64
 377 
#define LARGEST 64
398 
 
 378 
 
399 
static void SetFont(int face, int size, double rot, DevDesc *dd)
 379 
static void SetFont(int face, int size, double rot, DevDesc *dd)
400 
{
 380 
{
401 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 381 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
402 
 
 382 
 
403 
    if (face < 1 || face > fontnum)
 383 
    if (face < 1 || face > fontnum)
404 
	face = 1;
 384 
	face = 1;
405 
    size = MulDiv(size,xd->wanteddpi,xd->truedpi);
 385 
    size = MulDiv(size,xd->wanteddpi,xd->truedpi);
406 
    if (size < SMALLEST)
 386 
    if (size < SMALLEST)
Line 426... Line 406...
426 
 
 406 
 
427 
 
 407 
 
428 
static void SetColor(int color, DevDesc *dd)
 408 
static void SetColor(int color, DevDesc *dd)
429 
{
 409 
{
430 
    int   r, g, b;
 410 
    int   r, g, b;
431 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 411 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
432 
 
 412 
 
433 
    if (color != xd->col) {
 413 
    if (color != xd->col) {
434 
	/* Gamma Correction */
 414 
	/* Gamma Correction */
435 
	/* This is very experimental! */
 415 
	/* This is very experimental! */
436 
	xd->col = color;
 416 
	xd->col = color;
Line 484... Line 464...
484 
 *	spaced.
 464 
 *	spaced.
485 
 */
 465 
 */
486 
 
 466 
 
487 
static void SetLinetype(int newlty, double nlwd, DevDesc *dd)
 467 
static void SetLinetype(int newlty, double nlwd, DevDesc *dd)
488 
{
 468 
{
489 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 469 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
490 
    int   newlwd;
 470 
    int   newlwd;
491 
 
 471 
 
492 
    newlwd = nlwd;
 472 
    newlwd = nlwd;
493 
    if (newlwd < 1)
 473 
    if (newlwd < 1)
494 
	newlwd = 1;
 474 
	newlwd = 1;
Line 504... Line 484...
504 
static void HelpResize(window w,rect r)
 484 
static void HelpResize(window w,rect r)
505 
{
 485 
{
506 
    if (AllDevicesKilled) return;
 486 
    if (AllDevicesKilled) return;
507 
    {
 487 
    {
508 
	DevDesc *dd = (DevDesc *) getdata(w);
 488 
	DevDesc *dd = (DevDesc *) getdata(w);
509 
	x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 489 
	gadesc *xd = (gadesc *) dd->deviceSpecific;
510 
 
 490 
 
511 
	if (r.width) {
 491 
	if (r.width) {
512 
	    if ((xd->windowWidth != r.width) ||
 492 
	    if ((xd->windowWidth != r.width) ||
513 
		((xd->windowHeight != r.height))) {
 493 
		((xd->windowHeight != r.height))) {
514 
		xd->windowWidth = r.width;
 494 
		xd->windowWidth = r.width;
Line 531... Line 511...
531 
static void HelpExpose(window w,rect r)
 511 
static void HelpExpose(window w,rect r)
532 
{
 512 
{
533 
    if (AllDevicesKilled) return;
 513 
    if (AllDevicesKilled) return;
534 
    {
 514 
    {
535 
	DevDesc *dd = (DevDesc *) getdata(w);
 515 
	DevDesc *dd = (DevDesc *) getdata(w);
536 
	x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 516 
	gadesc *xd = (gadesc *) dd->deviceSpecific;
537 
 
 517 
 
538 
	if (xd->resize) {
 518 
	if (xd->resize) {
539 
	    dd->dp.resize(dd);
 519 
	    dd->dp.resize(dd);
540 
	    xd->replaying = 1;
 520 
	    xd->replaying = 1;
541 
	    playDisplayList(dd);
 521 
	    playDisplayList(dd);
Line 549... Line 529...
549 
static void HelpMouseClick(window w, int button, point pt)
 529 
static void HelpMouseClick(window w, int button, point pt)
550 
{
 530 
{
551 
    if (AllDevicesKilled) return;
 531 
    if (AllDevicesKilled) return;
552 
    {
 532 
    {
553 
	DevDesc *dd = (DevDesc *) getdata(w);
 533 
	DevDesc *dd = (DevDesc *) getdata(w);
554 
	x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 534 
	gadesc *xd = (gadesc *) dd->deviceSpecific;
555 
 
 535 
 
556 
	if (!xd->locator)
 536 
	if (!xd->locator)
557 
	    return;
 537 
	    return;
558 
	if (button & LeftButton) {
 538 
	if (button & LeftButton) {
559 
	    gabeep();
 539 
	    gabeep();
Line 565... Line 545...
565 
    }
 545 
    }
566 
}
 546 
}
567 
 
 547 
 
568 
static void menustop(control m)
 548 
static void menustop(control m)
569 
{
 549 
{
570 
  DevDesc *dd = (DevDesc *) getdata(m);
 550 
    DevDesc *dd = (DevDesc *) getdata(m);
571 
  x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 551 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
572 
  if (!xd->locator)
 552 
    if (!xd->locator)
573 
     return;
 553 
	return;
574 
  xd->clicked = 2;
 554 
    xd->clicked = 2;
575 
}
 555 
}
576 
 
 556 
 
577 
void  fixslash(char *);
 557 
void  fixslash(char *);
578 
 
 558 
 
579 
static void menufilebitmap(control m)
 559 
static void menufilebitmap(control m)
580 
{
 560 
{
581 
    DevDesc *dd = (DevDesc *) getdata(m);
 561 
    DevDesc *dd = (DevDesc *) getdata(m);
582 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 562 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
583 
    char *fn;
 563 
    char *fn;
584 
    if (m==xd->mpng) {
 564 
    if (m==xd->mpng) {
585 
      setuserfilter("Png files (*.png)\0*.png\0\0");
 565 
      setuserfilter("Png files (*.png)\0*.png\0\0");
586 
      fn = askfilesave("Portable network graphics file", "");
 566 
      fn = askfilesave("Portable network graphics file", "");
587 
    } else if (m==xd->mbmp) {
 567 
    } else if (m==xd->mbmp) {
Line 640... Line 620...
640 
}
 620 
}
641 
 
 621 
 
642 
static void menuclpbm(control m)
 622 
static void menuclpbm(control m)
643 
{
 623 
{
644 
    DevDesc *dd = (DevDesc *) getdata(m);
 624 
    DevDesc *dd = (DevDesc *) getdata(m);
645 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 625 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
646 
 
 626 
 
647 
    show(xd->gawin);
 627 
    show(xd->gawin);
648 
    gsetcursor(xd->gawin, WatchCursor);
 628 
    gsetcursor(xd->gawin, WatchCursor);
649 
    copytoclipboard(xd->bm);
 629 
    copytoclipboard(xd->bm);
650 
    gsetcursor(xd->gawin, ArrowCursor);
 630 
    gsetcursor(xd->gawin, ArrowCursor);
Line 659... Line 639...
659 
 
 639 
 
660 
 
 640 
 
661 
static void menuclose(control m)
 641 
static void menuclose(control m)
662 
{
 642 
{
663 
    DevDesc *dd = (DevDesc *) getdata(m);
 643 
    DevDesc *dd = (DevDesc *) getdata(m);
664 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 644 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
665 
 
 645 
 
666 
    HelpClose(xd->gawin);
 646 
    HelpClose(xd->gawin);
667 
}
 647 
}
668 
 
 648 
 
669 
/* plot history */
 649 
/* plot history */
Line 779... Line 759...
779 
 
 759 
 
780 
 
 760 
 
781 
 
 761 
 
782 
static void Replay(DevDesc *dd,SEXP vDL)
 762 
static void Replay(DevDesc *dd,SEXP vDL)
783 
{
 763 
{
784 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 764 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
785 
 
 765 
 
786 
    xd->replaying = 1;
 766 
    xd->replaying = 1;
787 
    dd->displayList = pCURRENTdl;
 767 
    dd->displayList = pCURRENTdl;
788 
    gsetcursor(xd->gawin, WatchCursor);
 768 
    gsetcursor(xd->gawin, WatchCursor);
789 
    copyGPar((GPar *) pCURRENTgp, &dd->dpSaved);
 769 
    copyGPar((GPar *) pCURRENTgp, &dd->dpSaved);
Line 796... Line 776...
796 
 
 776 
 
797 
 
 777 
 
798 
static void menurec(control m)
 778 
static void menurec(control m)
799 
{
 779 
{
800 
    DevDesc *dd = (DevDesc *) getdata(m);
 780 
    DevDesc *dd = (DevDesc *) getdata(m);
801 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 781 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
802 
 
 782 
 
803 
    if (xd->recording) {
 783 
    if (xd->recording) {
804 
	xd->recording = 0;
 784 
	xd->recording = 0;
805 
	uncheck(m);
 785 
	uncheck(m);
806 
    } else {
 786 
    } else {
Line 811... Line 791...
811 
 
 791 
 
812 
 
 792 
 
813 
static void menuadd(control m)
 793 
static void menuadd(control m)
814 
{
 794 
{
815 
    DevDesc *dd = (DevDesc *) getdata(m);
 795 
    DevDesc *dd = (DevDesc *) getdata(m);
816 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 796 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
817 
 
 797 
 
818 
    AddtoPlotHistory(dd->displayList, &dd->dpSaved, 0);
 798 
    AddtoPlotHistory(dd->displayList, &dd->dpSaved, 0);
819 
    xd->needsave = 0;
 799 
    xd->needsave = 0;
820 
}
 800 
}
821 
 
 801 
 
Line 834... Line 814...
834 
}
 814 
}
835 
 
 815 
 
836 
static void menunext(control m)
 816 
static void menunext(control m)
837 
{
 817 
{
838 
    DevDesc *dd = (DevDesc *) getdata(m);
 818 
    DevDesc *dd = (DevDesc *) getdata(m);
839 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 819 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
840 
 
 820 
 
841 
    GETDL;
 821 
    GETDL;
842 
    if (xd->needsave) return;
 822 
    if (xd->needsave) return;
843 
    pMUSTEXIST;
 823 
    pMUSTEXIST;
844 
    pCHECK;
 824 
    pCHECK;
Line 846... Line 826...
846 
}
 826 
}
847 
 
 827 
 
848 
static void menuprev(control m)
 828 
static void menuprev(control m)
849 
{
 829 
{
850 
    DevDesc *dd = (DevDesc*) getdata(m);
 830 
    DevDesc *dd = (DevDesc*) getdata(m);
851 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 831 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
852 
 
 832 
 
853 
    GETDL;
 833 
    GETDL;
854 
    pMUSTEXIST;
 834 
    pMUSTEXIST;
855 
    pCHECK;
 835 
    pCHECK;
856 
    if (pNUMPLOTS) {
 836 
    if (pNUMPLOTS) {
Line 906... Line 886...
906 
}
 886 
}
907 
 
 887 
 
908 
static void CHelpKeyIn(control w,int key)
 888 
static void CHelpKeyIn(control w,int key)
909 
{
 889 
{
910 
    DevDesc *dd = (DevDesc *) getdata(w);
 890 
    DevDesc *dd = (DevDesc *) getdata(w);
911 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 891 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
912 
 
 892 
 
913 
    switch (key) {
 893 
    switch (key) {
914 
      case INS:
 894 
      case INS:
915 
	menuadd(xd->madd);
 895 
	menuadd(xd->madd);
916 
	break;
 896 
	break;
Line 924... Line 904...
924 
}
 904 
}
925 
 
 905 
 
926 
static void NHelpKeyIn(control w,int key)
 906 
static void NHelpKeyIn(control w,int key)
927 
{
 907 
{
928 
    DevDesc *dd = (DevDesc *) getdata(w);
 908 
    DevDesc *dd = (DevDesc *) getdata(w);
929 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 909 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
930 
 
 910 
 
931 
    if (ggetkeystate() != CtrlKey)
 911 
    if (ggetkeystate() != CtrlKey)
932 
	return;
 912 
	return;
933 
    key = 'A' + key - 1;
 913 
    key = 'A' + key - 1;
934 
    if (key == 'C')
 914 
    if (key == 'C')
Line 942... Line 922...
942 
}
 922 
}
943 
 
 923 
 
944 
static void mbarf(control m)
 924 
static void mbarf(control m)
945 
{
 925 
{
946 
    DevDesc *dd = (DevDesc *) getdata(m);
 926 
    DevDesc *dd = (DevDesc *) getdata(m);
947 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 927 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
948 
 
 928 
 
949 
    GETDL;
 929 
    GETDL;
950 
    if (pEXIST) {
 930 
    if (pEXIST) {
951 
	enable(xd->mnext);
 931 
	enable(xd->mnext);
952 
	enable(xd->mprev);
 932 
	enable(xd->mprev);
Line 1009... Line 989...
1009 
	/* of course :)						*/
 989 
	/* of course :)						*/
1010 
	/********************************************************/
 990 
	/********************************************************/
1011 
 
 991 
 
1012 
#define MCHECK(m) {if(!(m)) {del(xd->gawin); return 0;}}
 992 
#define MCHECK(m) {if(!(m)) {del(xd->gawin); return 0;}}
1013 
 
 993 
 
1014 
static int setupScreenDevice(DevDesc *dd, x11Desc *xd, int w, int h)
994 
static int setupScreenDevice(DevDesc *dd, gadesc *xd, int w, int h)
1015 
{
 995 
{
1016 
  menu  m;
 996 
    menu  m;
1017 
  int   iw, ih;
 997 
    int   iw, ih;
1018 
  double dw, dh, d;
 998 
    double dw, dh, d;
1019 
 
 999 
 
1020 
  xd->kind = SCREEN;
 1000 
    xd->kind = SCREEN;
1021 
  dw = w / pixelWidth(NULL);
 1001 
    dw = w / pixelWidth(NULL);
1022 
  dh = h / pixelHeight(NULL);
 1002 
    dh = h / pixelHeight(NULL);
1023 
  if ((dw / devicewidth(NULL)) > 0.85) {
 1003 
    if ((dw / devicewidth(NULL)) > 0.85) {
1024 
    d = dh / dw;
 1004 
	d = dh / dw;
1025 
    dw = 0.85 * devicewidth(NULL);
 1005 
	dw = 0.85 * devicewidth(NULL);
1026 
    dh = d * dw;
 1006 
	dh = d * dw;
1027 
  }
 1007 
    }
1028 
  if ((dh / deviceheight(NULL)) > 0.85) {
 1008 
    if ((dh / deviceheight(NULL)) > 0.85) {
1029 
    d = dw / dh;
 1009 
	d = dw / dh;
1030 
    dh = 0.85 * deviceheight(NULL);
 1010 
	dh = 0.85 * deviceheight(NULL);
1031 
    dw = d * dh;
 1011 
	dw = d * dh;
1032 
  }
 1012 
    }
1033 
  iw = dw + 0.5;
 1013 
    iw = dw + 0.5;
1034 
  ih = dh + 0.5;
 1014 
    ih = dh + 0.5;
1035 
  if (!(xd->gawin = newwindow("R Graphics",
 1015 
    if (!(xd->gawin = newwindow("R Graphics",
1036 
			     rect(devicewidth(NULL) - iw - 5, 0, iw, ih),
 1016 
				rect(devicewidth(NULL) - iw - 5, 0, iw, ih),
1037 
			     Document | StandardWindow | Menubar))) {
 1017 
				Document | StandardWindow | Menubar))) {
1038 
    return 0;
 1018 
	return 0;
1039 
  }
 1019 
    }
1040 
 
 1020 
 
1041 
  addto(xd->gawin);
 1021 
    addto(xd->gawin);
1042 
  gsetcursor(xd->gawin, ArrowCursor);
 1022 
    gsetcursor(xd->gawin, ArrowCursor);
1043 
  if (ismdi() && (RguiMDI & RW_TOOLBAR)) {
 1023 
    if (ismdi() && (RguiMDI & RW_TOOLBAR)) {
1044 
    int btsize = 24;
 1024 
	int btsize = 24;
1045 
    rect r = rect(2, 2, btsize, btsize);
 1025 
	rect r = rect(2, 2, btsize, btsize);
1046 
    control bt, tb;
 1026 
	control bt, tb;
1047
1027
1048 
    MCHECK(tb = newtoolbar(btsize + 4));
 1028 
	MCHECK(tb = newtoolbar(btsize + 4));
1049 
    gsetcursor(tb, ArrowCursor);
 1029 
	gsetcursor(tb, ArrowCursor);
1050 
    addto(tb);
 1030 
	addto(tb);
1051
1031
1052 
    MCHECK(bt = newtoolbutton(cam_image, r, menuclpwm));
 1032 
	MCHECK(bt = newtoolbutton(cam_image, r, menuclpwm));
1053 
    MCHECK(addtooltip(bt, "Copy to the clipboard as a metafile"));
 1033 
	MCHECK(addtooltip(bt, "Copy to the clipboard as a metafile"));
1054 
    gsetcursor(bt, ArrowCursor);
 1034 
	gsetcursor(bt, ArrowCursor);
1055 
    setdata(bt, (void *) dd);
 1035 
	setdata(bt, (void *) dd);
1056 
    r.x += (btsize + 6);
 1036 
	r.x += (btsize + 6);
1057
1037
1058 
    MCHECK(bt = newtoolbutton(print_image, r, menuprint));
 1038 
	MCHECK(bt = newtoolbutton(print_image, r, menuprint));
1059 
    MCHECK(addtooltip(bt, "Print"));
 1039 
	MCHECK(addtooltip(bt, "Print"));
1060 
    gsetcursor(bt, ArrowCursor);
 1040 
	gsetcursor(bt, ArrowCursor);
1061 
    setdata(bt, (void *) dd);
 1041 
	setdata(bt, (void *) dd);
1062 
    r.x += (btsize + 6);
 1042 
	r.x += (btsize + 6);
1063 
 
 1043 
 
1064 
    MCHECK(bt = newtoolbutton(console_image, r, menuconsole));
 1044 
	MCHECK(bt = newtoolbutton(console_image, r, menuconsole));
1065 
    MCHECK(addtooltip(bt, "Return focus to console"));
 1045 
	MCHECK(addtooltip(bt, "Return focus to console"));
1066 
    gsetcursor(bt, ArrowCursor);
 1046 
	gsetcursor(bt, ArrowCursor);
1067 
    setdata(bt, (void *) dd);
 1047 
	setdata(bt, (void *) dd);
1068 
    r.x += (btsize + 6);
 1048 
	r.x += (btsize + 6);
1069 
 
 1049 
 
1070 
    MCHECK(xd->stoploc = newtoolbutton(stop_image, r, menustop));
 1050 
	MCHECK(xd->stoploc = newtoolbutton(stop_image, r, menustop));
1071 
    MCHECK(addtooltip(xd->stoploc, "Stop locator"));
 1051 
	MCHECK(addtooltip(xd->stoploc, "Stop locator"));
1072 
    gsetcursor(bt, ArrowCursor);
 1052 
	gsetcursor(bt, ArrowCursor);
1073 
    setdata(xd->stoploc,(void *) dd);
 1053 
	setdata(xd->stoploc,(void *) dd);
1074 
    hide(xd->stoploc);
 1054 
	hide(xd->stoploc);
1075 
  } else
 1055 
    } else
1076 
    xd->stoploc = NULL;
 1056 
	xd->stoploc = NULL;
1077 
 
 1057 
 
1078 
  /* First we prepare 'locator' menubar and popup */
 1058 
    /* First we prepare 'locator' menubar and popup */
1079 
  addto(xd->gawin);
 1059 
    addto(xd->gawin);
1080 
  MCHECK(xd->mbarloc = newmenubar(NULL));
 1060 
    MCHECK(xd->mbarloc = newmenubar(NULL));
1081 
  MCHECK(newmenu("Stop"));
 1061 
    MCHECK(newmenu("Stop"));
1082 
  MCHECK(m = newmenuitem("Stop locator", 0, menustop));
 1062 
    MCHECK(m = newmenuitem("Stop locator", 0, menustop));
1083 
  setdata(m, (void *) dd);
 1063 
    setdata(m, (void *) dd);
1084 
  MCHECK(xd->locpopup = newpopup(NULL));
 1064 
    MCHECK(xd->locpopup = newpopup(NULL));
1085 
  MCHECK(m = newmenuitem("Stop", 0, menustop));
 1065 
    MCHECK(m = newmenuitem("Stop", 0, menustop));
1086 
  setdata(m, (void *) dd);
 1066 
    setdata(m, (void *) dd);
1087 
  MCHECK(newmenuitem("Continue", 0, NULL));
 1067 
    MCHECK(newmenuitem("Continue", 0, NULL));
1088
1068
1089 
  /* Normal menubar */
 1069 
    /* Normal menubar */
1090 
  MCHECK(xd->mbar = newmenubar(mbarf));
 1070 
    MCHECK(xd->mbar = newmenubar(mbarf));
1091 
  MCHECK(m = newmenu("File"));
 1071 
    MCHECK(m = newmenu("File"));
1092 
  MCHECK(xd->msubsave = newsubmenu(m, "Save as"));
 1072 
    MCHECK(xd->msubsave = newsubmenu(m, "Save as"));
1093 
  MCHECK(xd->mwm = newmenuitem("Metafile", 0, menuwm));
 1073 
    MCHECK(xd->mwm = newmenuitem("Metafile", 0, menuwm));
1094 
  MCHECK(xd->mps = newmenuitem("Postscript", 0, menups));
 1074 
    MCHECK(xd->mps = newmenuitem("Postscript", 0, menups));
1095 
  MCHECK(xd->mpng = newmenuitem("Png", 0, menufilebitmap));
 1075 
    MCHECK(xd->mpng = newmenuitem("Png", 0, menufilebitmap));
1096 
  MCHECK(xd->mbmp = newmenuitem("Bmp", 0, menufilebitmap));
 1076 
    MCHECK(xd->mbmp = newmenuitem("Bmp", 0, menufilebitmap));
1097 
  MCHECK(newsubmenu(xd->msubsave,"Jpeg"));
 1077 
    MCHECK(newsubmenu(xd->msubsave,"Jpeg"));
1098 
  MCHECK(xd->mjpeg50 = newmenuitem("50% quality", 0, menufilebitmap));
 1078 
    MCHECK(xd->mjpeg50 = newmenuitem("50% quality", 0, menufilebitmap));
1099 
  MCHECK(xd->mjpeg75 = newmenuitem("75% quality", 0, menufilebitmap));
 1079 
    MCHECK(xd->mjpeg75 = newmenuitem("75% quality", 0, menufilebitmap));
1100 
  MCHECK(xd->mjpeg100 = newmenuitem("100% quality", 0, menufilebitmap));
 1080 
    MCHECK(xd->mjpeg100 = newmenuitem("100% quality", 0, menufilebitmap));
1101 
  MCHECK(newsubmenu(m, "Copy to the clipboard"));
 1081 
    MCHECK(newsubmenu(m, "Copy to the clipboard"));
1102 
  MCHECK(xd->mclpbm = newmenuitem("as a Bitmap\tCTRL+C", 0, menuclpbm));
 1082 
    MCHECK(xd->mclpbm = newmenuitem("as a Bitmap\tCTRL+C", 0, menuclpbm));
1103 
  MCHECK(xd->mclpwm = newmenuitem("as a Metafile\tCTRL+W", 0, menuclpwm));
 1083 
    MCHECK(xd->mclpwm = newmenuitem("as a Metafile\tCTRL+W", 0, menuclpwm));
1104 
  addto(m);
 1084 
    addto(m);
1105 
  MCHECK(newmenuitem("-", 0, NULL));
 1085 
    MCHECK(newmenuitem("-", 0, NULL));
1106 
  MCHECK(xd->mprint = newmenuitem("Print\tCTRL+P", 0, menuprint));
 1086 
    MCHECK(xd->mprint = newmenuitem("Print\tCTRL+P", 0, menuprint));
1107 
  MCHECK(newmenuitem("-", 0, NULL));
 1087 
    MCHECK(newmenuitem("-", 0, NULL));
1108 
  MCHECK(xd->mclose = newmenuitem("close Device", 0, menuclose));
 1088 
    MCHECK(xd->mclose = newmenuitem("close Device", 0, menuclose));
1109 
  MCHECK(newmenu("History"));
 1089 
    MCHECK(newmenu("History"));
1110 
  MCHECK(xd->mrec = newmenuitem("Recording", 0, menurec));
 1090 
    MCHECK(xd->mrec = newmenuitem("Recording", 0, menurec));
1111 
  MCHECK(newmenuitem("-", 0, NULL));
 1091 
    MCHECK(newmenuitem("-", 0, NULL));
1112 
  MCHECK(xd->madd = newmenuitem("Add\tINS", 0, menuadd));
 1092 
    MCHECK(xd->madd = newmenuitem("Add\tINS", 0, menuadd));
1113 
  MCHECK(xd->mreplace = newmenuitem("Replace", 0, menureplace));
 1093 
    MCHECK(xd->mreplace = newmenuitem("Replace", 0, menureplace));
1114 
  MCHECK(newmenuitem("-", 0, NULL));
 1094 
    MCHECK(newmenuitem("-", 0, NULL));
1115 
  MCHECK(xd->mprev = newmenuitem("Previous\tPgUp", 0, menuprev));
 1095 
    MCHECK(xd->mprev = newmenuitem("Previous\tPgUp", 0, menuprev));
1116 
  MCHECK(xd->mnext = newmenuitem("Next\tPgDown", 0, menunext));
 1096 
    MCHECK(xd->mnext = newmenuitem("Next\tPgDown", 0, menunext));
1117 
  MCHECK(newmenuitem("-", 0, NULL));
 1097 
    MCHECK(newmenuitem("-", 0, NULL));
1118 
  MCHECK(xd->msvar = newmenuitem("Save to variable", 0, menusvar));
 1098 
    MCHECK(xd->msvar = newmenuitem("Save to variable", 0, menusvar));
1119 
  MCHECK(xd->mgvar = newmenuitem("Get from variable", 0, menugvar));
 1099 
    MCHECK(xd->mgvar = newmenuitem("Get from variable", 0, menugvar));
1120 
  MCHECK(newmenuitem("-", 0, NULL));
 1100 
    MCHECK(newmenuitem("-", 0, NULL));
1121 
  MCHECK(xd->mclear = newmenuitem("Clear history", 0, menuclear));
 1101 
    MCHECK(xd->mclear = newmenuitem("Clear history", 0, menuclear));
1122 
  newmdimenu();
 1102 
    newmdimenu();
1123 
 
 1103 
 
1124 
  /* Normal popup */
 1104 
    /* Normal popup */
1125 
  MCHECK(xd->grpopup = newpopup(NULL));
 1105 
    MCHECK(xd->grpopup = newpopup(NULL));
1126 
  MCHECK(m = newmenuitem("Copy as metafile", 0, menuclpwm));
 1106 
    MCHECK(m = newmenuitem("Copy as metafile", 0, menuclpwm));
1127 
  setdata(m, (void *) dd);
 1107 
    setdata(m, (void *) dd);
1128 
  MCHECK(m = newmenuitem("Copy as bitmap", 0, menuclpbm));
 1108 
    MCHECK(m = newmenuitem("Copy as bitmap", 0, menuclpbm));
1129 
  setdata(m, (void *) dd);
 1109 
    setdata(m, (void *) dd);
1130 
  MCHECK(newmenuitem("-", 0, NULL));
 1110 
    MCHECK(newmenuitem("-", 0, NULL));
1131 
  MCHECK(m = newmenuitem("Save as metafile", 0, menuwm));
 1111 
    MCHECK(m = newmenuitem("Save as metafile", 0, menuwm));
1132 
  setdata(m, (void *) dd);
 1112 
    setdata(m, (void *) dd);
1133 
  MCHECK(m = newmenuitem("Save as postscript", 0, menups));
 1113 
    MCHECK(m = newmenuitem("Save as postscript", 0, menups));
1134 
  setdata(m, (void *) dd);
 1114 
    setdata(m, (void *) dd);
1135 
  MCHECK(newmenuitem("-", 0, NULL));
 1115 
    MCHECK(newmenuitem("-", 0, NULL));
1136 
  MCHECK(m = newmenuitem("Print", 0, menuprint));
 1116 
    MCHECK(m = newmenuitem("Print", 0, menuprint));
1137 
  setdata(m, (void *) dd);
 1117 
    setdata(m, (void *) dd);
1138 
  gchangepopup(xd->gawin, xd->grpopup);
 1118 
    gchangepopup(xd->gawin, xd->grpopup);
1139 
 
 1119 
 
1140 
  MCHECK(xd->bm = newbitmap(getwidth(xd->gawin), getheight(xd->gawin),
1120 
    MCHECK(xd->bm = newbitmap(getwidth(xd->gawin), getheight(xd->gawin),
1141 
			    getdepth(xd->gawin)));
 1121 
			      getdepth(xd->gawin)));
1142 
 
 1122 
 
1143 
  addto(xd->gawin);
 1123 
    addto(xd->gawin);
1144 
  setdata(xd->mbar, (void *) dd);
 1124 
    setdata(xd->mbar, (void *) dd);
1145 
  setdata(xd->mpng, (void *) dd);
 1125 
    setdata(xd->mpng, (void *) dd);
1146 
  setdata(xd->mbmp, (void *) dd);
 1126 
    setdata(xd->mbmp, (void *) dd);
1147 
  setdata(xd->mjpeg50, (void *) dd);
 1127 
    setdata(xd->mjpeg50, (void *) dd);
1148 
  setdata(xd->mjpeg75, (void *) dd);
 1128 
    setdata(xd->mjpeg75, (void *) dd);
1149 
  setdata(xd->mjpeg100, (void *) dd);
 1129 
    setdata(xd->mjpeg100, (void *) dd);
1150 
  setdata(xd->mps, (void *) dd);
 1130 
    setdata(xd->mps, (void *) dd);
1151 
  setdata(xd->mwm, (void *) dd);
 1131 
    setdata(xd->mwm, (void *) dd);
1152 
  setdata(xd->mclpwm, (void *) dd);
 1132 
    setdata(xd->mclpwm, (void *) dd);
1153 
  setdata(xd->mclpbm, (void *) dd);
 1133 
    setdata(xd->mclpbm, (void *) dd);
1154 
  setdata(xd->mprint, (void *) dd);
 1134 
    setdata(xd->mprint, (void *) dd);
1155 
  setdata(xd->mclose, (void *) dd);
 1135 
    setdata(xd->mclose, (void *) dd);
1156 
  setdata(xd->mrec, (void *) dd);
 1136 
    setdata(xd->mrec, (void *) dd);
1157 
  setdata(xd->mprev, (void *) dd);
 1137 
    setdata(xd->mprev, (void *) dd);
1158 
  setdata(xd->mnext, (void *) dd);
 1138 
    setdata(xd->mnext, (void *) dd);
1159 
  setdata(xd->mgvar, (void *) dd);
 1139 
    setdata(xd->mgvar, (void *) dd);
1160 
  setdata(xd->madd, (void *) dd);
 1140 
    setdata(xd->madd, (void *) dd);
1161 
  setdata(xd->mreplace, (void *) dd);
 1141 
    setdata(xd->mreplace, (void *) dd);
1162 
  show(xd->gawin);
 1142 
    show(xd->gawin);
1163 
  show(xd->gawin);
 1143 
    show(xd->gawin);
1164 
  setresize(xd->gawin, HelpResize);
 1144 
    setresize(xd->gawin, HelpResize);
1165 
  setredraw(xd->gawin, HelpExpose);
 1145 
    setredraw(xd->gawin, HelpExpose);
1166 
  setmousedown(xd->gawin, HelpMouseClick);
 1146 
    setmousedown(xd->gawin, HelpMouseClick);
1167 
  setkeydown(xd->gawin, NHelpKeyIn);
 1147 
    setkeydown(xd->gawin, NHelpKeyIn);
1168 
  setkeyaction(xd->gawin, CHelpKeyIn);
 1148 
    setkeyaction(xd->gawin, CHelpKeyIn);
1169 
  setclose(xd->gawin, HelpClose);
 1149 
    setclose(xd->gawin, HelpClose);
1170 
  xd->recording = 0;
 1150 
    xd->recording = 0;
1171 
  xd->replaying = 0;
 1151 
    xd->replaying = 0;
1172 
 
 1152 
 
1173 
  return 1;
 1153 
    return 1;
1174 
}
 1154 
}
1175 
 
 1155 
 
1176 
static int X11_Open(DevDesc *dd, x11Desc *xd, char *dsp,
 1156 
static int GA_Open(DevDesc *dd, gadesc *xd, char *dsp,
1177 
                    double w, double h)
 1157 
                    double w, double h)
1178 
{
 1158 
{
1179 
    rect  rr;
 1159 
    rect  rr;
1180 
 
 1160 
 
1181 
    if (!fontinitdone)
 1161 
    if (!fontinitdone)
Line 1213... Line 1193...
1213 
	  if (xd->fp != NULL) fclose(xd->fp);
 1193 
	  if (xd->fp != NULL) fclose(xd->fp);
1214 
	  return 0;
 1194 
	  return 0;
1215 
	}
 1195 
	}
1216 
    } else if (!strncmp(dsp, "jpeg:", 5)) {
 1196 
    } else if (!strncmp(dsp, "jpeg:", 5)) {
1217 
        char *p = strchr(&dsp[5], ':');
 1197 
        char *p = strchr(&dsp[5], ':');
1218 
        xd->kind = JPEG ;
 1198 
        xd->kind = JPEG;
1219 
	if (!p) return 0;
 1199 
	if (!p) return 0;
1220 
	if (!Load_Rbitmap_Dll()) {
 1200 
	if (!Load_Rbitmap_Dll()) {
1221 
	  warning("Impossible to load Rbitmap.dll");
 1201 
	  warning("Impossible to load Rbitmap.dll");
1222 
	  return 0;
 1202 
	  return 0;
1223 
	}
 1203 
	}
Line 1249... Line 1229...
1249 
	xd->kind = METAFILE;
 1229 
	xd->kind = METAFILE;
1250 
	if (!xd->gawin)
 1230 
	if (!xd->gawin)
1251 
	    return 0;
 1231 
	    return 0;
1252 
    }
 1232 
    }
1253 
    xd->truedpi = devicepixelsy(xd->gawin);
 1233 
    xd->truedpi = devicepixelsy(xd->gawin);
1254 
    if ((xd->kind==PNG) || (xd->kind==JPEG) || (xd->kind==BMP))
1234 
    if ((xd->kind == PNG) || (xd->kind == JPEG) || (xd->kind == BMP))
1255 
      xd->wanteddpi = 72 ;
 1235 
      xd->wanteddpi = 72 ;
1256 
    else
 1236 
    else
1257 
      xd->wanteddpi = xd->truedpi;
 1237 
      xd->wanteddpi = xd->truedpi;
1258 
    if (!SetBaseFont(xd)) {
 1238 
    if (!SetBaseFont(xd)) {
1259 
	Rprintf("can't find any fonts\n");
 1239 
	Rprintf("can't find any fonts\n");
1260 
	del(xd->gawin);
 1240 
	del(xd->gawin);
1261 
	if (xd->kind==SCREEN) del(xd->bm);
 1241 
	if (xd->kind == SCREEN) del(xd->bm);
1262 
	return 0;
 1242 
	return 0;
1263 
    }
 1243 
    }
1264 
    rr = getrect(xd->gawin);
 1244 
    rr = getrect(xd->gawin);
1265 
    xd->windowWidth = rr.width;
 1245 
    xd->windowWidth = rr.width;
1266 
    xd->windowHeight = rr.height;
 1246 
    xd->windowHeight = rr.height;
Line 1275... Line 1255...
1275 
	/* string in DEVICE units (GStrWidth is responsible for */
 1255 
	/* string in DEVICE units (GStrWidth is responsible for */
1276 
	/* converting from DEVICE to whatever units the user 	*/
 1256 
	/* converting from DEVICE to whatever units the user 	*/
1277 
	/* asked for						*/
 1257 
	/* asked for						*/
1278 
	/********************************************************/
 1258 
	/********************************************************/
1279 
 
 1259 
 
1280 
static double X11_StrWidth(char *str, DevDesc *dd)
 1260 
static double GA_StrWidth(char *str, DevDesc *dd)
1281 
{
 1261 
{
1282 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1262 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1283 
    double a;
 1263 
    double a;
1284 
    int   size = dd->gp.cex * dd->gp.ps + 0.5;
 1264 
    int   size = dd->gp.cex * dd->gp.ps + 0.5;
1285 
 
 1265 
 
1286 
    SetFont(dd->gp.font, size, 0.0, dd);
 1266 
    SetFont(dd->gp.font, size, 0.0, dd);
1287 
    a = (double) gstrwidth(xd->gawin, xd->font, str);
 1267 
    a = (double) gstrwidth(xd->gawin, xd->font, str);
Line 1297... Line 1277...
1297 
	/********************************************************/
 1277 
	/********************************************************/
1298 
 
 1278 
 
1299 
	/* Character Metric Information */
 1279 
	/* Character Metric Information */
1300 
	/* Passing c == 0 gets font information */
 1280 
	/* Passing c == 0 gets font information */
1301 
 
 1281 
 
1302 
static void X11_MetricInfo(int c, double* ascent, double* descent,
 1282 
static void GA_MetricInfo(int c, double* ascent, double* descent,
1303 
			   double* width, DevDesc *dd)
 1283 
			   double* width, DevDesc *dd)
1304 
{
 1284 
{
1305 
    int   a, d, w;
 1285 
    int   a, d, w;
1306 
    int   size = dd->gp.cex * dd->gp.ps + 0.5;
 1286 
    int   size = dd->gp.cex * dd->gp.ps + 0.5;
1307 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1287 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1308 
 
 1288 
 
1309 
    SetFont(dd->gp.font, size, 0.0, dd);
 1289 
    SetFont(dd->gp.font, size, 0.0, dd);
1310 
    gcharmetric(xd->gawin, xd->font, c, &a, &d, &w);
 1290 
    gcharmetric(xd->gawin, xd->font, c, &a, &d, &w);
1311 
    *ascent = (double) a;
 1291 
    *ascent = (double) a;
1312 
    *descent = (double) d;
 1292 
    *descent = (double) d;
Line 1318... Line 1298...
1318 
	/* top of a rectangle (in DEVICE coordinates).  it 	*/
 1298 
	/* top of a rectangle (in DEVICE coordinates).  it 	*/
1319 
	/* should have the side-effect that subsequent output	*/
 1299 
	/* should have the side-effect that subsequent output	*/
1320 
	/* is clipped to the given rectangle			*/
 1300 
	/* is clipped to the given rectangle			*/
1321 
	/********************************************************/
 1301 
	/********************************************************/
1322 
 
 1302 
 
1323 
static void X11_Clip(double x0, double x1, double y0, double y1, DevDesc *dd)
 1303 
static void GA_Clip(double x0, double x1, double y0, double y1, DevDesc *dd)
1324 
{
 1304 
{
1325 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1305 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1326 
 
 1306 
 
1327 
    xd->clip = rcanon(rpt(pt(x0, y0), pt(x1, y1)));
 1307 
    xd->clip = rcanon(rpt(pt(x0, y0), pt(x1, y1)));
1328 
    xd->clip.width  += 1;
 1308 
    xd->clip.width  += 1;
1329 
    xd->clip.height += 1;
 1309 
    xd->clip.height += 1;
1330 
}
 1310 
}
Line 1339... Line 1319...
1339 
	/* (e.g., a window resize) are usually detected by	*/
 1319 
	/* (e.g., a window resize) are usually detected by	*/
1340 
	/* device-specific code	(see R_ProcessEvents in ./system.c)*/
 1320 
	/* device-specific code	(see R_ProcessEvents in ./system.c)*/
1341 
	/********************************************************/
 1321 
	/********************************************************/
1342 
 
 1322 
 
1343 
 
 1323 
 
1344 
static void X11_Resize(DevDesc *dd)
 1324 
static void GA_Resize(DevDesc *dd)
1345 
{
 1325 
{
1346 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1326 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1347 
 
 1327 
 
1348 
    if (xd->resize) {
 1328 
    if (xd->resize) {
1349 
	int   iw, ih;
 1329 
	int   iw, ih;
1350 
 
 1330 
 
1351 
	dd->dp.left = dd->gp.left = 0.0;
 1331 
	dd->dp.left = dd->gp.left = 0.0;
Line 1370... Line 1350...
1370 
	/* a new page.  a new page might mean just clearing the	*/
 1350 
	/* a new page.  a new page might mean just clearing the	*/
1371 
	/* device (as in this case) or moving to a new page	*/
 1351 
	/* device (as in this case) or moving to a new page	*/
1372 
	/* (e.g., postscript)					*/
 1352 
	/* (e.g., postscript)					*/
1373 
	/********************************************************/
 1353 
	/********************************************************/
1374 
 
 1354 
 
1375 
static void X11_NewPage(DevDesc *dd)
 1355 
static void GA_NewPage(DevDesc *dd)
1376 
{
 1356 
{
1377 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1357 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1378 
 
 1358 
 
1379 
    if ((xd->kind == PRINTER) && xd->needsave)
 1359 
    if ((xd->kind == PRINTER) && xd->needsave)
1380 
	nextpage(xd->gawin);
 1360 
	nextpage(xd->gawin);
1381 
    if ((xd->kind == METAFILE) && xd->needsave)
 1361 
    if ((xd->kind == METAFILE) && xd->needsave)
1382 
	error("A metafile can store only one figure.");
 1362 
	error("A metafile can store only one figure.");
Line 1384... Line 1364...
1384 
	error("A png file can store only one figure.");
 1364 
	error("A png file can store only one figure.");
1385 
    if ((xd->kind == JPEG) && xd->needsave)
 1365 
    if ((xd->kind == JPEG) && xd->needsave)
1386 
	error("A jpeg file can store only one figure.");
 1366 
	error("A jpeg file can store only one figure.");
1387 
    if ((xd->kind == BMP) && xd->needsave)
 1367 
    if ((xd->kind == BMP) && xd->needsave)
1388 
	error("A bmp file can store only one figure.");
 1368 
	error("A bmp file can store only one figure.");
1389 
    if (xd->kind==SCREEN) {
 1369 
    if (xd->kind == SCREEN) {
1390 
	if (xd->recording && xd->needsave)
 1370 
	if (xd->recording && xd->needsave)
1391 
	    AddtoPlotHistory(savedDisplayList, &savedGPar, 0);
 1371 
	    AddtoPlotHistory(savedDisplayList, &savedGPar, 0);
1392 
	if (xd->replaying)
 1372 
	if (xd->replaying)
1393 
	    xd->needsave = 0;
 1373 
	    xd->needsave = 0;
1394 
	else
 1374 
	else
Line 1397... Line 1377...
1397 
    xd->bg = dd->dp.bg;
 1377 
    xd->bg = dd->dp.bg;
1398 
    xd->bgcolor = rgb(R_RED(xd->bg),
 1378 
    xd->bgcolor = rgb(R_RED(xd->bg),
1399 
		      R_GREEN(xd->bg),
 1379 
		      R_GREEN(xd->bg),
1400 
		      R_BLUE(xd->bg));
 1380 
		      R_BLUE(xd->bg));
1401 
    if (xd->kind!=SCREEN) {
 1381 
    if (xd->kind!=SCREEN) {
1402 
      xd->needsave = 1;
 1382 
	xd->needsave = 1;
1403 
      xd->clip = getrect(xd->gawin);
 1383 
	xd->clip = getrect(xd->gawin);
1404 
    } else {
 1384 
    } else {
1405 
      xd->clip = getrect(xd->bm);
 1385 
	xd->clip = getrect(xd->bm);
1406 
    }
 1386 
    }
1407 
    DRAW(gfillrect(_d, xd->bgcolor, getrect(_d)));
 1387 
    DRAW(gfillrect(_d, xd->bgcolor, getrect(_d)));
1408 
}
 1388 
}
1409 
 
 1389 
 
1410 
	/********************************************************/
 1390 
	/********************************************************/
Line 1413... Line 1393...
1413 
	/* device-specific resources that were created in	*/
 1393 
	/* device-specific resources that were created in	*/
1414 
	/* device_Open and for FREEing the device-specific	*/
 1394 
	/* device_Open and for FREEing the device-specific	*/
1415 
	/* parameters structure					*/
 1395 
	/* parameters structure					*/
1416 
	/********************************************************/
 1396 
	/********************************************************/
1417 
 
 1397 
 
1418 
static void X11_Close(DevDesc *dd)
 1398 
static void GA_Close(DevDesc *dd)
1419 
{
 1399 
{
1420 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1400 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1421 
 
 1401 
 
1422 
    if (xd->kind==SCREEN) {
 1402 
    if (xd->kind==SCREEN) {
1423 
	hide(xd->gawin);
 1403 
	hide(xd->gawin);
1424 
	del(xd->bm);
 1404 
	del(xd->bm);
1425 
    } else if ((xd->kind == PNG) || (xd->kind == JPEG) || (xd->kind == BMP)) {
 1405 
    } else if ((xd->kind == PNG) || (xd->kind == JPEG) || (xd->kind == BMP)) {
Line 1443... Line 1423...
1443 
	/* do anything						*/
 1423 
	/* do anything						*/
1444 
	/********************************************************/
 1424 
	/********************************************************/
1445 
 
 1425 
 
1446 
static unsigned char title[20] = "R Graphics";
 1426 
static unsigned char title[20] = "R Graphics";
1447 
 
 1427 
 
1448 
static void X11_Activate(DevDesc *dd)
 1428 
static void GA_Activate(DevDesc *dd)
1449 
{
 1429 
{
1450 
    char  t[50];
 1430 
    char  t[50];
1451 
    char  num[3];
 1431 
    char  num[3];
1452 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1432 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1453 
 
 1433 
 
1454 
    if (xd->replaying || (xd->kind!=SCREEN))
 1434 
    if (xd->replaying || (xd->kind!=SCREEN))
1455 
	return;
 1435 
	return;
1456 
    strcpy(t, (char *) title);
 1436 
    strcpy(t, (char *) title);
1457 
    strcat(t, ": Device ");
 1437 
    strcat(t, ": Device ");
Line 1467... Line 1447...
1467 
	/* title of a window to indicate the inactive status of */
 1447 
	/* title of a window to indicate the inactive status of */
1468 
	/* the device to the user.  not all device types will	*/
 1448 
	/* the device to the user.  not all device types will	*/
1469 
	/* do anything						*/
 1449 
	/* do anything						*/
1470 
	/********************************************************/
 1450 
	/********************************************************/
1471 
 
 1451 
 
1472 
static void X11_Deactivate(DevDesc *dd)
 1452 
static void GA_Deactivate(DevDesc *dd)
1473 
{
 1453 
{
1474 
    char  t[50];
 1454 
    char  t[50];
1475 
    char  num[3];
 1455 
    char  num[3];
1476 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1456 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1477 
 
 1457 
 
1478 
    if (xd->replaying || (xd->kind!=SCREEN))
 1458 
    if (xd->replaying || (xd->kind != SCREEN))
1479 
	return;
 1459 
	return;
1480 
    strcpy(t, (char *) title);
 1460 
    strcpy(t, (char *) title);
1481 
    strcat(t, ": Device ");
 1461 
    strcat(t, ": Device ");
1482 
    sprintf(num, "%i", deviceNumber(dd) + 1);
 1462 
    sprintf(num, "%i", deviceNumber(dd) + 1);
1483 
    strcat(t, num);
 1463 
    strcat(t, num);
Line 1497... Line 1477...
1497 
	/* the locations are in an arbitrary coordinate system	*/
 1477 
	/* the locations are in an arbitrary coordinate system	*/
1498 
	/* and this function is responsible for converting the	*/
 1478 
	/* and this function is responsible for converting the	*/
1499 
	/* locations to DEVICE coordinates using GConvert	*/
 1479 
	/* locations to DEVICE coordinates using GConvert	*/
1500 
	/********************************************************/
 1480 
	/********************************************************/
1501 
 
 1481 
 
1502 
static void X11_Rect(double x0, double y0, double x1, double y1,
 1482 
static void GA_Rect(double x0, double y0, double x1, double y1,
1503 
		     int coords, int bg, int fg, DevDesc *dd)
 1483 
		     int coords, int bg, int fg, DevDesc *dd)
1504 
{
 1484 
{
1505 
    int   tmp;
 1485 
    int   tmp;
1506 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1486 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1507 
    rect  r;
 1487 
    rect  r;
1508 
 
 1488 
 
1509 
    /* These in-place conversions are ok */
 1489 
    /* These in-place conversions are ok */
1510 
    TRACEDEVGA("rect");
 1490 
    TRACEDEVGA("rect");
1511 
    GConvert(&x0, &y0, coords, DEVICE, dd);
 1491 
    GConvert(&x0, &y0, coords, DEVICE, dd);
Line 1547... Line 1527...
1547 
	/* function is responsible for converting this to	*/
 1527 
	/* function is responsible for converting this to	*/
1548 
	/* DEVICE coordinates.  the radius is given in DEVICE	*/
 1528 
	/* DEVICE coordinates.  the radius is given in DEVICE	*/
1549 
	/* coordinates						*/
 1529 
	/* coordinates						*/
1550 
	/********************************************************/
 1530 
	/********************************************************/
1551 
 
 1531 
 
1552 
static void X11_Circle(double x, double y, int coords,
 1532 
static void GA_Circle(double x, double y, int coords,
1553 
		       double r, int col, int border, DevDesc *dd)
 1533 
		       double r, int col, int border, DevDesc *dd)
1554 
{
 1534 
{
1555 
    int   ir, ix, iy;
 1535 
    int   ir, ix, iy;
1556 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1536 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1557 
    rect  rr;
 1537 
    rect  rr;
1558 
 
 1538 
 
1559 
    TRACEDEVGA("circle");
 1539 
    TRACEDEVGA("circle");
1560 
#ifdef OLD
 1540 
#ifdef OLD
1561 
    ir = ceil(r);
 1541 
    ir = ceil(r);
Line 1586... Line 1566...
1586 
	/* x1, y1, x2, and y2 are in arbitrary coordinates and	*/
 1566 
	/* x1, y1, x2, and y2 are in arbitrary coordinates and	*/
1587 
	/* the function is responsible for converting them to	*/
 1567 
	/* the function is responsible for converting them to	*/
1588 
	/* DEVICE coordinates using GConvert			*/
 1568 
	/* DEVICE coordinates using GConvert			*/
1589 
	/********************************************************/
 1569 
	/********************************************************/
1590 
 
 1570 
 
1591 
static void X11_Line(double x1, double y1, double x2, double y2,
 1571 
static void GA_Line(double x1, double y1, double x2, double y2,
1592 
		     int coords, DevDesc *dd)
 1572 
		     int coords, DevDesc *dd)
1593 
{
 1573 
{
1594 
    int   xx1, yy1, xx2, yy2;
 1574 
    int   xx1, yy1, xx2, yy2;
1595 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1575 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1596 
 
 1576 
 
1597 
    /* In-place conversion ok */
 1577 
    /* In-place conversion ok */
1598 
    TRACEDEVGA("line");
 1578 
    TRACEDEVGA("line");
1599 
    GConvert(&x1, &y1, coords, DEVICE, dd);
 1579 
    GConvert(&x1, &y1, coords, DEVICE, dd);
1600 
    GConvert(&x2, &y2, coords, DEVICE, dd);
 1580 
    GConvert(&x2, &y2, coords, DEVICE, dd);
Line 1616... Line 1596...
1616 
	/* the x and y values are in arbitrary coordinates and	*/
 1596 
	/* the x and y values are in arbitrary coordinates and	*/
1617 
	/* the function is responsible for converting them to	*/
 1597 
	/* the function is responsible for converting them to	*/
1618 
	/* DEVICE coordinates using GConvert			*/
 1598 
	/* DEVICE coordinates using GConvert			*/
1619 
	/********************************************************/
 1599 
	/********************************************************/
1620 
 
 1600 
 
1621 
static void X11_Polyline(int n, double *x, double *y, int coords, DevDesc *dd)
 1601 
static void GA_Polyline(int n, double *x, double *y, int coords, DevDesc *dd)
1622 
{
 1602 
{
1623 
    point *p = (point *) C_alloc(n, sizeof(point));
 1603 
    point *p = (point *) C_alloc(n, sizeof(point));
1624 
    double devx, devy;
 1604 
    double devx, devy;
1625 
    int   i;
 1605 
    int   i;
1626 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1606 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1627 
    TRACEDEVGA("pl");
 1607 
    TRACEDEVGA("pl");
1628 
    for ( i = 0; i < n; i++) {
 1608 
    for (i = 0; i < n; i++) {
1629 
      devx = x[i];
 1609 
	devx = x[i];
1630 
      devy = y[i];
 1610 
	devy = y[i];
1631 
      GConvert(&devx, &devy, coords, DEVICE, dd);
 1611 
	GConvert(&devx, &devy, coords, DEVICE, dd);
1632 
      p[i].x = (int) devx;
 1612 
	p[i].x = (int) devx;
1633 
      p[i].y = (int) devy;
 1613 
	p[i].y = (int) devy;
1634 
    }
 1614 
    }
1635 
    SetColor(dd->gp.col, dd),
 1615 
    SetColor(dd->gp.col, dd),
1636 
    SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
 1616 
	SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
1637 
    DRAW(gdrawpolyline(_d, xd->lwd, xd->lty, xd->fgcolor, p, n, 0));
 1617 
    DRAW(gdrawpolyline(_d, xd->lwd, xd->lty, xd->fgcolor, p, n, 0));
1638 
    C_free((char *) p);
 1618 
    C_free((char *) p);
1639 
}
 1619 
}
1640 
 
 1620 
 
1641 
	/********************************************************/
 1621 
	/********************************************************/
Line 1648... Line 1628...
1648 
	/* the x and y values are in arbitrary coordinates and 	*/
 1628 
	/* the x and y values are in arbitrary coordinates and 	*/
1649 
	/* the function is responsible for converting them to 	*/
 1629 
	/* the function is responsible for converting them to 	*/
1650 
	/* DEVICE coordinates using GConvert			*/
 1630 
	/* DEVICE coordinates using GConvert			*/
1651 
	/********************************************************/
 1631 
	/********************************************************/
1652 
 
 1632 
 
1653 
static void X11_Polygon(int n, double *x, double *y, int coords,
 1633 
static void GA_Polygon(int n, double *x, double *y, int coords,
1654 
			int bg, int fg, DevDesc *dd)
 1634 
			int bg, int fg, DevDesc *dd)
1655 
{
 1635 
{
1656 
    point *points;
 1636 
    point *points;
1657 
    double devx, devy;
 1637 
    double devx, devy;
1658 
    int   i;
 1638 
    int   i;
1659 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1639 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1660 
 
 1640 
 
1661 
    TRACEDEVGA("plg");
 1641 
    TRACEDEVGA("plg");
1662 
    points = (point *) C_alloc(n , sizeof(point));
 1642 
    points = (point *) C_alloc(n , sizeof(point));
1663 
    if (!points)
 1643 
    if (!points)
1664 
	return;
 1644 
	return;
Line 1690... Line 1670...
1690 
	/* and this function is responsible for converting the	*/
 1670 
	/* and this function is responsible for converting the	*/
1691 
	/* location to DEVICE coordinates using GConvert	*/
 1671 
	/* location to DEVICE coordinates using GConvert	*/
1692 
	/********************************************************/
 1672 
	/********************************************************/
1693 
 
 1673 
 
1694 
 
 1674 
 
1695 
static void X11_Text(double x, double y, int coords,
 1675 
static void GA_Text(double x, double y, int coords,
1696 
		     char *str, double rot, double hadj, DevDesc *dd)
 1676 
		     char *str, double rot, double hadj, DevDesc *dd)
1697 
{
 1677 
{
1698 
    int   size;
 1678 
    int   size;
1699 
    double pixs, xl, yl, rot1;
 1679 
    double pixs, xl, yl, rot1;
1700 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1680 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1701 
 
 1681 
 
1702 
    size = dd->gp.cex * dd->gp.ps + 0.5;
 1682 
    size = dd->gp.cex * dd->gp.ps + 0.5;
1703 
    GConvert(&x, &y, coords, DEVICE, dd);
 1683 
    GConvert(&x, &y, coords, DEVICE, dd);
1704 
    SetFont(dd->gp.font, size, 0.0, dd);
 1684 
    SetFont(dd->gp.font, size, 0.0, dd);
1705 
    pixs = fontascent(xd->font) + fontdescent(xd->font) - 1;
 1685 
    pixs = fontascent(xd->font) + fontdescent(xd->font) - 1;
Line 1727... Line 1707...
1727 
	/* mouse click (in DEVICE coordinates;  GLocator is	*/
 1707 
	/* mouse click (in DEVICE coordinates;  GLocator is	*/
1728 
	/* responsible for any conversions)			*/
 1708 
	/* responsible for any conversions)			*/
1729 
	/* not all devices will do anything (e.g., postscript)	*/
 1709 
	/* not all devices will do anything (e.g., postscript)	*/
1730 
	/********************************************************/
 1710 
	/********************************************************/
1731 
 
 1711 
 
1732 
static int X11_Locator(double *x, double *y, DevDesc *dd)
 1712 
static int GA_Locator(double *x, double *y, DevDesc *dd)
1733 
{
 1713 
{
1734 
    x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 1714 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
1735 
 
 1715 
 
1736 
    if (xd->kind!=SCREEN)
 1716 
    if (xd->kind!=SCREEN)
1737 
	return 0;
 1717 
	return 0;
1738 
    xd->locator = 1;
 1718 
    xd->locator = 1;
1739 
    xd->clicked = 0;
 1719 
    xd->clicked = 0;
Line 1776... Line 1756...
1776 
	/* starts drawing (mode=1) or stops drawing (mode=1)	*/
 1756 
	/* starts drawing (mode=1) or stops drawing (mode=1)	*/
1777 
	/* the device is not required to do anything		*/
 1757 
	/* the device is not required to do anything		*/
1778 
	/********************************************************/
 1758 
	/********************************************************/
1779 
 
 1759 
 
1780 
/* Set Graphics mode - not needed for X11 */
 1760 
/* Set Graphics mode - not needed for X11 */
1781 
static void X11_Mode(int mode)
 1761 
static void GA_Mode(int mode)
1782 
{
 1762 
{
1783 
}
 1763 
}
1784 
 
 1764 
 
1785 
	/********************************************************/
 1765 
	/********************************************************/
1786 
	/* i don't know what this is for and i can't find it	*/
 1766 
	/* i don't know what this is for and i can't find it	*/
1787 
	/* being used anywhere, but i'm loath to kill it in	*/
 1767 
	/* being used anywhere, but i'm loath to kill it in	*/
1788 
	/* case i'm missing something important			*/
 1768 
	/* case i'm missing something important			*/
1789 
	/********************************************************/
 1769 
	/********************************************************/
1790 
 
 1770 
 
1791 
/* Hold the Picture Onscreen - not needed for X11 */
 1771 
/* Hold the Picture Onscreen - not needed for X11 */
1792 
static void X11_Hold(DevDesc *dd)
 1772 
static void GA_Hold(DevDesc *dd)
1793 
{
 1773 
{
1794 
}
 1774 
}
1795 
 
 1775 
 
1796 
 
 1776 
 
1797 
	/********************************************************/
 1777 
	/********************************************************/
Line 1823... Line 1803...
1823 
	/* but if the device driver freaks out it needs to do 	*/
 1803 
	/* but if the device driver freaks out it needs to do 	*/
1824 
	/* the clean-up itself					*/
 1804 
	/* the clean-up itself					*/
1825 
	/********************************************************/
 1805 
	/********************************************************/
1826 
 
 1806 
 
1827 
 
 1807 
 
1828 
	/*  X11 Device Driver Arguments               */
 - 
 
1829 
 
 1808 
 
1830 
	/*  cpars[0] = display name                   */
 - 
 
1831 
	/*  cpars[1] = paper type (a4, letter, none)  */
 1809 
int GADeviceDriver(DevDesc *dd, char *display, double width,
1832 
 
 - 
 
1833 
	/*  npars[0] = width (inches)                 */
 - 
 
1834 
	/*  npars[1] = height (inches)                */
 - 
 
1835 
	/*  npars[2] = base pointsize                 */
 - 
 
1836 
	/*  npars[3] = paper orientation              */
 - 
 
1837 
	/*	       1 - portrait                   */
 - 
 
1838 
	/*	       2 - landscape                  */
 - 
 
1839 
	/*	       3 - flexible                   */
 - 
 
1840 
 
 - 
 
1841 
 
 - 
 
1842 
 
 - 
 
1843 
int
 - 
 
1844 
X11DeviceDriver
 - 
 
1845 
 (DevDesc *dd, char *display, double width, double height, double pointsize)
 1810 
		   double height, double pointsize)
1846 
{
 1811 
{
1847 
    /* if need to bail out with some sort of "error" then */
 1812 
    /* if need to bail out with some sort of "error" then */
1848 
    /* must free(dd) */
 1813 
    /* must free(dd) */
1849 
 
 1814 
 
1850 
    int   ps;
 1815 
    int   ps;
1851 
    x11Desc *xd;
 1816 
    gadesc *xd;
1852 
    rect  rr;
 1817 
    rect  rr;
1853 
    int a=0, d=0, w=0;
 1818 
    int a=0, d=0, w=0;
1854 
 
 1819 
 
1855 
    /* allocate new device description */
 1820 
    /* allocate new device description */
1856 
    if (!(xd = (x11Desc *) malloc(sizeof(x11Desc))))
 1821 
    if (!(xd = (gadesc *) malloc(sizeof(gadesc))))
1857 
	return 0;
 1822 
	return 0;
1858 
 
 1823 
 
1859 
    /* from here on, if need to bail out with "error", must also */
 1824 
    /* from here on, if need to bail out with "error", must also */
1860 
    /* free(xd) */
 1825 
    /* free(xd) */
1861 
 
 1826 
 
Line 1871... Line 1836...
1871 
    dd->dp.font = 1;
 1836 
    dd->dp.font = 1;
1872 
    dd->dp.ps = ps;
 1837 
    dd->dp.ps = ps;
1873 
 
 1838 
 
1874 
    /* Start the Device Driver and Hardcopy.  */
 1839 
    /* Start the Device Driver and Hardcopy.  */
1875 
 
 1840 
 
1876 
    if (!X11_Open(dd, xd, display, width, height)) {
 1841 
    if (!GA_Open(dd, xd, display, width, height)) {
1877 
	free(xd);
 1842 
	free(xd);
1878 
	return 0;
 1843 
	return 0;
1879 
    }
 1844 
    }
1880 
    /* Set up Data Structures  */
 1845 
    /* Set up Data Structures  */
1881 
 
 1846 
 
1882 
    dd->dp.open = X11_Open;
 1847 
    dd->dp.open = GA_Open;
1883 
    dd->dp.close = X11_Close;
 1848 
    dd->dp.close = GA_Close;
1884 
    dd->dp.activate = X11_Activate;
 1849 
    dd->dp.activate = GA_Activate;
1885 
    dd->dp.deactivate = X11_Deactivate;
 1850 
    dd->dp.deactivate = GA_Deactivate;
1886 
    dd->dp.resize = X11_Resize;
 1851 
    dd->dp.resize = GA_Resize;
1887 
    dd->dp.newPage = X11_NewPage;
 1852 
    dd->dp.newPage = GA_NewPage;
1888 
    dd->dp.clip = X11_Clip;
 1853 
    dd->dp.clip = GA_Clip;
1889 
    dd->dp.strWidth = X11_StrWidth;
 1854 
    dd->dp.strWidth = GA_StrWidth;
1890 
    dd->dp.text = X11_Text;
 1855 
    dd->dp.text = GA_Text;
1891 
    dd->dp.rect = X11_Rect;
 1856 
    dd->dp.rect = GA_Rect;
1892 
    dd->dp.circle = X11_Circle;
 1857 
    dd->dp.circle = GA_Circle;
1893 
    dd->dp.line = X11_Line;
 1858 
    dd->dp.line = GA_Line;
1894 
    dd->dp.polyline = X11_Polyline;
 1859 
    dd->dp.polyline = GA_Polyline;
1895 
    dd->dp.polygon = X11_Polygon;
 1860 
    dd->dp.polygon = GA_Polygon;
1896 
    dd->dp.locator = X11_Locator;
 1861 
    dd->dp.locator = GA_Locator;
1897 
    dd->dp.mode = X11_Mode;
 1862 
    dd->dp.mode = GA_Mode;
1898 
    dd->dp.hold = X11_Hold;
 1863 
    dd->dp.hold = GA_Hold;
1899 
    dd->dp.metricInfo = X11_MetricInfo;
 1864 
    dd->dp.metricInfo = GA_MetricInfo;
1900 
 
 1865 
 
1901 
    /* set graphics parameters that must be set by device driver */
 1866 
    /* set graphics parameters that must be set by device driver */
1902 
    /* Window Dimensions in Pixels */
 1867 
    /* Window Dimensions in Pixels */
1903 
    rr = getrect(xd->gawin);
 1868 
    rr = getrect(xd->gawin);
1904 
    dd->dp.left = (xd->kind == PRINTER) ? rr.x : 0;	/* left */
 1869 
    dd->dp.left = (xd->kind == PRINTER) ? rr.x : 0;	/* left */
Line 1933... Line 1898...
1933 
    dd->dp.canRotateText = 1;
 1898 
    dd->dp.canRotateText = 1;
1934 
    dd->dp.canResizeText = 1;
 1899 
    dd->dp.canResizeText = 1;
1935 
    dd->dp.canClip = 1;
 1900 
    dd->dp.canClip = 1;
1936 
    dd->dp.canHAdj = 0;
 1901 
    dd->dp.canHAdj = 0;
1937 
 
 1902 
 
1938 
    /* initialise x11 device description (most of the work */
 1903 
    /* initialise device description (most of the work */
1939 
    /* has been done in X11_Open) */
 1904 
    /* has been done in GA_Open) */
1940 
 
 1905 
 
1941 
    xd->resize = 0;
 1906 
    xd->resize = 0;
1942 
    xd->locator = 0;
 1907 
    xd->locator = 0;
1943 
    dd->deviceSpecific = (void *) xd;
 1908 
    dd->deviceSpecific = (void *) xd;
1944 
    dd->displayListOn = 1;
 1909 
    dd->displayListOn = 1;
Line 1989... Line 1954...
1989 
 
 1954 
 
1990 
/* Rbitmap  */
 1955 
/* Rbitmap  */
1991 
#define BITMAP_DLL_NAME "\\BIN\\RBITMAP.DLL\0"
 1956 
#define BITMAP_DLL_NAME "\\BIN\\RBITMAP.DLL\0"
1992 
typedef int (*R_SaveAsBitmap)();
 1957 
typedef int (*R_SaveAsBitmap)();
1993 
static R_SaveAsBitmap R_SaveAsPng, R_SaveAsJpeg, R_SaveAsBmp;
 1958 
static R_SaveAsBitmap R_SaveAsPng, R_SaveAsJpeg, R_SaveAsBmp;
1994 
static int RbitmapAlreadyLoaded=0;
 1959 
static int RbitmapAlreadyLoaded = 0;
1995 
static HINSTANCE hRbitmapDll;
 1960 
static HINSTANCE hRbitmapDll;
1996 
 
 1961 
 
1997 
static int Load_Rbitmap_Dll()
 1962 
static int Load_Rbitmap_Dll()
1998 
{
1963 
{
1999 
 if (!RbitmapAlreadyLoaded) {
 1964 
    if (!RbitmapAlreadyLoaded) {
2000 
   char szFullPath[PATH_MAX];
 1965 
	char szFullPath[PATH_MAX];
2001 
   strcpy(szFullPath, R_HomeDir());
 1966 
	strcpy(szFullPath, R_HomeDir());
2002 
   strcat(szFullPath, BITMAP_DLL_NAME);
 1967 
	strcat(szFullPath, BITMAP_DLL_NAME);
2003 
   if (((hRbitmapDll = LoadLibrary(szFullPath)) != NULL) &&
1968 
	if (((hRbitmapDll = LoadLibrary(szFullPath)) != NULL) &&
2004 
       ((R_SaveAsPng=
 1969 
	    ((R_SaveAsPng=
2005 
	 (R_SaveAsBitmap)GetProcAddress(hRbitmapDll,"R_SaveAsPng"))
1970 
	      (R_SaveAsBitmap)GetProcAddress(hRbitmapDll, "R_SaveAsPng"))
2006 
	!= NULL) &&
 1971 
	     != NULL) &&
2007 
       ((R_SaveAsBmp=
 1972 
	    ((R_SaveAsBmp=
2008 
	 (R_SaveAsBitmap)GetProcAddress(hRbitmapDll,"R_SaveAsBmp"))
1973 
	      (R_SaveAsBitmap)GetProcAddress(hRbitmapDll, "R_SaveAsBmp"))
2009 
	!= NULL) &&
 1974 
	     != NULL) &&
2010 
       ((R_SaveAsJpeg=
 1975 
	    ((R_SaveAsJpeg=
2011 
	 (R_SaveAsBitmap)GetProcAddress(hRbitmapDll,"R_SaveAsJpeg"))
1976 
	      (R_SaveAsBitmap)GetProcAddress(hRbitmapDll, "R_SaveAsJpeg"))
2012 
	!= NULL)) {
 1977 
	     != NULL)) {
2013 
     RbitmapAlreadyLoaded = 1;
 1978 
	    RbitmapAlreadyLoaded = 1;
2014 
   } else {
1979 
	} else {
2015 
     if (hRbitmapDll != NULL) FreeLibrary(hRbitmapDll);
 1980 
	    if (hRbitmapDll != NULL) FreeLibrary(hRbitmapDll);
2016 
     RbitmapAlreadyLoaded= -1;
 1981 
	    RbitmapAlreadyLoaded= -1;
2017 
   }
 1982 
	}
2018 
 }
 1983 
    }
2019 
 return (RbitmapAlreadyLoaded>0);
1984 
    return (RbitmapAlreadyLoaded>0);
2020 
}
 1985 
}
2021 
 
 1986 
 
2022 
void UnLoad_Rbitmap_Dll()
 1987 
void UnLoad_Rbitmap_Dll()
2023 
{
 1988 
{
2024 
    if (RbitmapAlreadyLoaded) FreeLibrary(hRbitmapDll);
 1989 
    if (RbitmapAlreadyLoaded) FreeLibrary(hRbitmapDll);
2025 
    RbitmapAlreadyLoaded = 0;
 1990 
    RbitmapAlreadyLoaded = 0;
2026 
}
 1991 
}
2027 
 
 1992 
 
2028 
static unsigned long privategetpixel(void *d,int i, int j) {
 1993 
static unsigned long privategetpixel(void *d,int i, int j)
- 
 
 1994 
{
2029 
  return ggetpixel((bitmap)d,pt(j,i));
 1995 
    return ggetpixel((bitmap)d,pt(j,i));
2030 
}
 1996 
}
2031 
 
 1997 
 
2032 
/* This is the device version */
 1998 
/* This is the device version */
2033 
static void SaveAsBitmap(DevDesc *dd)
 1999 
static void SaveAsBitmap(DevDesc *dd)
2034 
{
 2000 
{
2035 
  rect r;
 2001 
    rect r;
2036 
  x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 2002 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
2037 
  r = ggetcliprect(xd->gawin);
 2003 
    r = ggetcliprect(xd->gawin);
2038 
  gsetcliprect(xd->gawin,getrect(xd->gawin));
 2004 
    gsetcliprect(xd->gawin, getrect(xd->gawin));
2039 
  if (xd->kind==PNG)
2005 
    if (xd->kind==PNG)
2040 
    R_SaveAsPng(xd->gawin,xd->windowWidth, xd->windowHeight,
 2006 
	R_SaveAsPng(xd->gawin, xd->windowWidth, xd->windowHeight,
2041 
		privategetpixel,0,xd->fp) ;
 2007 
		    privategetpixel, 0, xd->fp) ;
2042 
  else if (xd->kind==JPEG)
 2008 
    else if (xd->kind==JPEG)
2043 
    R_SaveAsJpeg(xd->gawin, xd->windowWidth, xd->windowHeight,
 2009 
	R_SaveAsJpeg(xd->gawin, xd->windowWidth, xd->windowHeight,
2044 
		 privategetpixel,0,xd->quality,xd->fp) ;
 2010 
		     privategetpixel, 0, xd->quality, xd->fp) ;
2045 
  else
2011 
    else
2046 
    R_SaveAsBmp(xd->gawin, xd->windowWidth, xd->windowHeight,
 2012 
	R_SaveAsBmp(xd->gawin, xd->windowWidth, xd->windowHeight,
2047 
		 privategetpixel,0,xd->fp) ;
 2013 
		    privategetpixel, 0, xd->fp) ;
2048 
  gsetcliprect(xd->gawin,r);
 2014 
    gsetcliprect(xd->gawin, r);
2049 
  fclose(xd->fp);
 2015 
    fclose(xd->fp);
2050 
}
 2016 
}
2051 
 
 2017 
 
2052 
/* This are the menu item version */
 2018 
/* This are the menu item version */
2053 
static void SaveAsPng(DevDesc *dd,char *fn)
 2019 
static void SaveAsPng(DevDesc *dd,char *fn)
2054 
{
 2020 
{
2055 
  FILE *fp;
 2021 
    FILE *fp;
2056 
  rect r;
 2022 
    rect r;
2057 
  x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 2023 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
2058 
  if (!Load_Rbitmap_Dll()) {
 2024 
    if (!Load_Rbitmap_Dll()) {
2059 
    R_ShowMessage("Impossible to load Rbitmap.dll");
 2025 
	R_ShowMessage("Impossible to load Rbitmap.dll");
2060 
    return;
 2026 
	return;
2061 
  }
 2027 
    }
2062 
  if ((fp=fopen(fn,"wb"))==NULL) {
 2028 
    if ((fp=fopen(fn,"wb")) == NULL) {
2063 
    char msg[MAX_PATH+32];
 2029 
	char msg[MAX_PATH+32];
2064 
 
 2030 
 
2065 
    strcpy(msg,"Impossible to open ");
 2031 
	strcpy(msg,"Impossible to open ");
2066 
    strncat(msg,fn,MAX_PATH);
 2032 
	strncat(msg, fn, MAX_PATH);
2067 
    R_ShowMessage(msg);
 2033 
	R_ShowMessage(msg);
2068 
    return;
 2034 
	return;
2069 
  }
 2035 
    }
2070 
  r = ggetcliprect(xd->bm);
 2036 
    r = ggetcliprect(xd->bm);
2071 
  gsetcliprect(xd->bm,getrect(xd->bm));
 2037 
    gsetcliprect(xd->bm, getrect(xd->bm));
2072 
  R_SaveAsPng(xd->bm,xd->windowWidth, xd->windowHeight,
 2038 
    R_SaveAsPng(xd->bm, xd->windowWidth, xd->windowHeight,
2073 
	      privategetpixel,0,fp) ;
 2039 
		privategetpixel, 0, fp) ;
2074 
  gsetcliprect(xd->bm,r);
 2040 
    gsetcliprect(xd->bm, r);
2075 
  fclose(fp);
 2041 
    fclose(fp);
2076 
}
 2042 
}
2077 
 
 2043 
 
2078 
static void SaveAsJpeg(DevDesc *dd,int quality,char *fn)
 2044 
static void SaveAsJpeg(DevDesc *dd,int quality,char *fn)
2079 
{
 2045 
{
2080 
  FILE *fp;
 2046 
    FILE *fp;
2081 
  rect r;
 2047 
    rect r;
2082 
  x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 2048 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
2083 
  if (!Load_Rbitmap_Dll()) {
 2049 
    if (!Load_Rbitmap_Dll()) {
2084 
    R_ShowMessage("Impossible to load Rbitmap.dll");
 2050 
	R_ShowMessage("Impossible to load Rbitmap.dll");
2085 
    return;
 2051 
	return;
2086 
  }
 2052 
    }
2087 
  if ((fp=fopen(fn,"wb"))==NULL) {
 2053 
    if ((fp=fopen(fn,"wb")) == NULL) {
2088 
    char msg[MAX_PATH+32];
 2054 
	char msg[MAX_PATH+32];
2089 
    strcpy(msg,"Impossible to open ");
 2055 
	strcpy(msg, "Impossible to open ");
2090 
    strncat(msg,fn,MAX_PATH);
 2056 
	strncat(msg, fn, MAX_PATH);
2091 
    R_ShowMessage(msg);
 2057 
	R_ShowMessage(msg);
2092 
    return;
 2058 
	return;
2093 
  }
 2059 
    }
2094 
  r = ggetcliprect(xd->bm);
 2060 
    r = ggetcliprect(xd->bm);
2095 
  gsetcliprect(xd->bm,getrect(xd->bm));
 2061 
    gsetcliprect(xd->bm, getrect(xd->bm));
2096 
  R_SaveAsJpeg(xd->bm,xd->windowWidth, xd->windowHeight,
 2062 
    R_SaveAsJpeg(xd->bm,xd->windowWidth, xd->windowHeight,
2097 
	      privategetpixel,0,quality,fp) ;
 2063 
		 privategetpixel, 0, quality, fp) ;
2098 
  gsetcliprect(xd->bm,r);
 2064 
    gsetcliprect(xd->bm, r);
2099 
  fclose(fp);
 2065 
    fclose(fp);
2100 
}
 2066 
}
2101 
 
 2067 
 
2102 
 
 2068 
 
2103 
static void SaveAsBmp(DevDesc *dd,char *fn)
 2069 
static void SaveAsBmp(DevDesc *dd,char *fn)
2104 
{
 2070 
{
2105 
  FILE *fp;
 2071 
    FILE *fp;
2106 
  rect r;
 2072 
    rect r;
2107 
  x11Desc *xd = (x11Desc *) dd->deviceSpecific;
 2073 
    gadesc *xd = (gadesc *) dd->deviceSpecific;
2108 
  if (!Load_Rbitmap_Dll()) {
 2074 
    if (!Load_Rbitmap_Dll()) {
2109 
    R_ShowMessage("Impossible to load Rbitmap.dll");
 2075 
	R_ShowMessage("Impossible to load Rbitmap.dll");
2110 
    return;
 2076 
	return;
2111 
  }
 2077 
    }
2112 
  if ((fp=fopen(fn,"wb"))==NULL) {
 2078 
    if ((fp=fopen(fn,"wb")) == NULL) {
2113 
    char msg[MAX_PATH+32];
 2079 
	char msg[MAX_PATH+32];
2114 
 
 - 
 
2115 
    strcpy(msg,"Impossible to open ");
 - 
 
2116 
    strncat(msg,fn,MAX_PATH);
 - 
 
2117 
    R_ShowMessage(msg);
 - 
 
2118 
    return;
 - 
 
2119 
  }
 - 
 
2120 
  r = ggetcliprect(xd->bm);
 - 
 
2121 
  gsetcliprect(xd->bm,getrect(xd->bm));
 - 
 
2122 
  R_SaveAsBmp(xd->bm,xd->windowWidth, xd->windowHeight,
 - 
 
2123 
	      privategetpixel,0,fp) ;
 - 
 
2124 
  gsetcliprect(xd->bm,r);
 - 
 
2125 
  fclose(fp);
 - 
 
2126 
}
 - 
 
2127 
 
 - 
 
2128 
 
 2080 
 
- 
 
 2081 
	strcpy(msg,"Impossible to open ");
- 
 
 2082 
	strncat(msg, fn, MAX_PATH);
- 
 
 2083 
	R_ShowMessage(msg);
- 
 
 2084 
	return;
- 
 
 2085 
    }
- 
 
 2086 
    r = ggetcliprect(xd->bm);
- 
 
 2087 
    gsetcliprect(xd->bm, getrect(xd->bm));
- 
 
 2088 
    R_SaveAsBmp(xd->bm, xd->windowWidth, xd->windowHeight,
- 
 
 2089 
		privategetpixel, 0, fp) ;
- 
 
 2090 
    gsetcliprect(xd->bm, r);
- 
 
 2091 
    fclose(fp);
- 
 
 2092 
}