The R Project SVN – R – Diff – /branches/R-NaString/src/gnuwin32/devga.c

+{
     user_xpinch = xpinch;
     user_ypinch = ypinch;
+}
+static rgb GArgb(int color, double gamma)
+{
+    int r, g, b;
+    if (gamma != 1) {
+	r = (int) (255 * pow(R_RED(color) / 255.0, gamma));
+	g = (int) (255 * pow(R_GREEN(color) / 255.0, gamma));
+	b = (int) (255 * pow(R_BLUE(color) / 255.0, gamma));
+    } else {
+	r = R_RED(color);
+	g = R_GREEN(color);
+	b = R_BLUE(color);
+    }
+    return rgb(r, g, b);
+}
 	/********************************************************/
 	/* This device driver has been documented so that it be	*/
 	/* used as a template for new drivers 			*/
     int   bg;			   /* Background */
     int   fontface;		   /* Typeface */
     int   fontsize, basefontsize;  /* Size in points */
     double fontangle;
-    /* X11 Driver Specific */
+    /* devga Driver Specific */
-    /* parameters with copy per x11 device */
+    /* parameters with copy per devga device */
     enum DeviceKinds kind;
     int   windowWidth;		/* Window width (pixels) */
     int   windowHeight;		/* Window height (pixels) */
     int   showWidth;		/* device width (pixels) */
     int quality;
   /* Used to rescale font size so that bitmap devices have 72dpi */
     int truedpi, wanteddpi;
     rgb   fgcolor;		/* Foreground color */
     rgb   bgcolor;		/* Background color */
+    rgb   canvascolor;		/* Canvas color */
+    rgb   outcolor;		/* Outside canvas color */
     rect  clip;			/* The clipping rectangle */
     Rboolean usefixed;
     font  fixedfont;
     font  font;
     Rboolean locator;
 static void   GA_Line(double, double, double, double, int, DevDesc*);
 static Rboolean GA_Locator(double*, double*, DevDesc*);
 static void   GA_Mode(int);
 static void   GA_NewPage(DevDesc*);
 static Rboolean GA_Open(DevDesc*, gadesc*, char*, double, double,
-			Rboolean, int);
+			Rboolean, int, rgb);
 static void   GA_Polygon(int, double*, double*, int, int, int, DevDesc*);
 static void   GA_Polyline(int, double*, double*, int, DevDesc*);
 static void   GA_Rect(double, double, double, double, int, int, int, DevDesc*);
 static void   GA_Resize(DevDesc*);
 static double GA_StrWidth(char*, DevDesc*);
 static void SetColor(int, DevDesc *);
 static void SetFont(int, int, double, DevDesc *);
 static void SetLinetype(int, double, DevDesc *);
 static int Load_Rbitmap_Dll();
 void UnLoad_Rbitmap_Dll();
-static void SaveAsPng(DevDesc *dd,char *fn);
+static void SaveAsPng(DevDesc *dd, char *fn);
-static void SaveAsJpeg(DevDesc *dd,int quality,char *fn);
+static void SaveAsJpeg(DevDesc *dd, int quality, char *fn);
-static void SaveAsBmp(DevDesc *dd,char *fn);
+static void SaveAsBmp(DevDesc *dd, char *fn);
 static void SaveAsBitmap(DevDesc *dd);
 static void PrivateCopyDevice(DevDesc *dd,DevDesc *ndd, char *name)
+{
     gadesc *xd = (gadesc *) dd->deviceSpecific;
     ndd->displayList = R_NilValue;
     GInit(&ndd->dp);
     if (GADeviceDriver(ndd, display,
 			 GConvertXUnits(1.0, NDC, INCHES, dd),
 			 GConvertYUnits(1.0, NDC, INCHES, dd),
-			 dd->gp.ps, 0, 1))
+			 dd->gp.ps, 0, 1, White))
         PrivateCopyDevice(dd, ndd, display);
+}
 static void SaveAsPostscript(DevDesc *dd, char *fn)
     /* Set default values... */
     strcpy(family, "Helvetica");
     strcpy(encoding, "ISOLatin1.enc");
     strcpy(paper, "default");
-    strcpy(bg, "white");
+    strcpy(bg, "transparent");
     strcpy(fg, "black");
     /* and then try to get it from .PostScript.Options */
     if ((s!=R_UnboundValue) && (s!=R_NilValue)) {
 	SEXP names = getAttrib(s, R_NamesSymbol);
 	int i,done;
     GInit(&ndd->dp);
     /* Set default values... */
     strcpy(family, "Helvetica");
     strcpy(encoding, "ISOLatin1.enc");
-    strcpy(bg, "white");
+    strcpy(bg, "transparent");
     strcpy(fg, "black");
     /* and then try to get it from .PostScript.Options */
     if ((s!=R_UnboundValue) && (s!=R_NilValue)) {
 	SEXP names = getAttrib(s, R_NamesSymbol);
 	int i,done;
+}
 static void SetColor(int color, DevDesc *dd)
+{
-    int   r, g, b;
     gadesc *xd = (gadesc *) dd->deviceSpecific;
     if (color != xd->col) {
-	/* Gamma Correction */
-	/* This is very experimental! */
 	xd->col = color;
-	if (dd->gp.gamma != 1) {
-	    r = (int) (255 * pow(R_RED(color) / 255.0, dd->gp.gamma));
-	    g = (int) (255 * pow(R_GREEN(color) / 255.0, dd->gp.gamma));
-	    b = (int) (255 * pow(R_BLUE(color) / 255.0, dd->gp.gamma));
-	} else {
-	    r = R_RED(color);
-	    g = R_GREEN(color);
-	    b = R_BLUE(color);
-	}
-	xd->fgcolor = rgb(r, g, b);
+	xd->fgcolor = GArgb(color, dd->gp.gamma);
+    }
+}
 /*
     setdata(m, (void *) dd);
     gchangepopup(xd->gawin, xd->grpopup);
     MCHECK(xd->bm = newbitmap(getwidth(xd->gawin), getheight(xd->gawin),
 			      getdepth(xd->gawin)));
-    gfillrect(xd->gawin, LightGray, getrect(xd->gawin));
+    gfillrect(xd->gawin, xd->outcolor, getrect(xd->gawin));
-    gfillrect(xd->bm, LightGray, getrect(xd->bm));
+    gfillrect(xd->bm, xd->outcolor, getrect(xd->bm));
     addto(xd->gawin);
     setdata(xd->mbar, (void *) dd);
     setdata(xd->mpng, (void *) dd);
     setdata(xd->mbmp, (void *) dd);
     setdata(xd->mjpeg50, (void *) dd);
     return 1;
+}
 static Rboolean GA_Open(DevDesc *dd, gadesc *xd, char *dsp,
-			double w, double h, Rboolean recording, int resize)
+			double w, double h, Rboolean recording,
+			int resize, rgb canvascolor)
+{
     rect  rr;
     if (!fontinitdone)
 	RFontInit();
     /* Foreground and Background Colors */
-    xd->bg = dd->dp.bg = R_RGB(255, 255, 255);
+    xd->bg = dd->dp.bg = 0xffffffff; /* transparent */
     xd->fg = dd->dp.fg = R_RGB(0, 0, 0);
     xd->col = dd->dp.col = xd->fg;
     xd->fgcolor = Black;
-    xd->bgcolor = White;
+    xd->bgcolor = xd->canvascolor = canvascolor;
+    xd->outcolor = myGetSysColor(COLOR_APPWORKSPACE);
     xd->rescale_factor = 1.0;
     xd->fast = 1;  /* Use `cosmetic pens' if available */
     xd->xshift = xd->yshift = 0;
     if (!dsp[0]) {
       if (!setupScreenDevice(dd, xd, w, h, recording, resize))
 	xd->kind = PRINTER;
 	xd->gawin = newprinter(MM_PER_INCH * w, MM_PER_INCH * h);
 	if (!xd->gawin)
 	    return FALSE;
     } else if (!strncmp(dsp, "png:", 4) || !strncmp(dsp,"bmp:",4)) {
+	xd->bg = dd->dp.bg = R_RGB(255, 255, 255); /* white */
         xd->kind = (dsp[0]=='p') ? PNG : BMP;
 	if (!Load_Rbitmap_Dll()) {
 	    warning("Unable to load Rbitmap.dll");
 	    return FALSE;
+	}
 	    xd->bm = newbitmap(iw, ih, getdepth(xd->gawin));
 	    if (!xd->bm) {
 		R_ShowMessage("Insufficient memory for resize. Killing device");
 		KillDevice(dd);
+	    }
-	    gfillrect(xd->gawin, LightGray, getrect(xd->gawin));
+	    gfillrect(xd->gawin, xd->outcolor, getrect(xd->gawin));
-	    gfillrect(xd->bm, LightGray, getrect(xd->bm));
+	    gfillrect(xd->bm, xd->outcolor, getrect(xd->bm));
+	}
+    }
+}
 	/********************************************************/
 	    xd->needsave = FALSE;
 	else
 	    xd->needsave = TRUE;
+    }
     xd->bg = dd->dp.bg;
-    xd->bgcolor = rgb(R_RED(xd->bg),
+    if (!R_OPAQUE(xd->bg))
-		      R_GREEN(xd->bg),
+	xd->bgcolor = xd->canvascolor;
+    else
-		      R_BLUE(xd->bg));
+	xd->bgcolor = GArgb(xd->bg, dd->gp.gamma);
-    if (xd->kind!=SCREEN) {
+    if (xd->kind != SCREEN) {
 	xd->needsave = TRUE;
 	xd->clip = getrect(xd->gawin);
-	if(xd->bg != R_RGB(255,255,255))
+	if(R_OPAQUE(xd->bg) || xd->kind == PNG ||
+	   xd->kind == BMP || xd->kind == JPEG )
 	    DRAW(gfillrect(_d, xd->bgcolor, xd->clip));
     } else {
 	xd->clip = getregion(xd);
 	DRAW(gfillrect(_d, xd->bgcolor, xd->clip));
+    }
 	tmp = y0;
 	y0 = y1;
 	y1 = tmp;
+    }
     r = rect((int) x0, (int) y0, (int) x1 - (int) x0, (int) y1 - (int) y0);
-    if (bg != NA_INTEGER) {
+    if (R_OPAQUE(bg)) {
 	SetColor(bg, dd);
 	DRAW(gfillrect(_d, xd->fgcolor, r));
+    }
-    if (fg != NA_INTEGER) {
+    if (R_OPAQUE(fg)) {
 	SetColor(fg, dd);
 	SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
 	DRAW(gdrawrect(_d, xd->lwd, xd->lty, xd->fgcolor, r, 0));
+    }
+}
     GConvert(&x, &y, coords, DEVICE, dd);
     ix = (int) x;
     iy = (int) y;
     rr = rect(ix - ir, iy - ir, 2 * ir, 2 * ir);
-    if (col != NA_INTEGER) {
+    if (R_ALPHA(col)) {
 	SetColor(col, dd);
 	DRAW(gfillellipse(_d, xd->fgcolor, rr));
+    }
-    if (border != NA_INTEGER) {
+    if (R_OPAQUE(border)) {
 	SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
 	SetColor(border, dd);
 	DRAW(gdrawellipse(_d, xd->lwd, xd->fgcolor, rr, 0));
+    }
+}
     xx2 = (int) x2;
     yy2 = (int) y2;
     SetColor(dd->gp.col, dd),
     SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
+    if (R_OPAQUE(xd->fgcolor))
-    DRAW(gdrawline(_d, xd->lwd, xd->lty, xd->fgcolor,
+	DRAW(gdrawline(_d, xd->lwd, xd->lty, xd->fgcolor,
-		   pt(xx1, yy1), pt(xx2, yy2), 0));
+		       pt(xx1, yy1), pt(xx2, yy2), 0));
+}
 	/********************************************************/
 	/* device_Polyline should have the side-effect that a	*/
 	/* series of line segments are drawn using the given x	*/
 	devy = y[i];
 	GConvert(&devx, &devy, coords, DEVICE, dd);
 	p[i].x = (int) devx;
 	p[i].y = (int) devy;
+    }
-    SetColor(dd->gp.col, dd),
+    SetColor(dd->gp.col, dd);
-	SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
+    SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
+    if (R_OPAQUE(xd->fgcolor))
-    DRAW(gdrawpolyline(_d, xd->lwd, xd->lty, xd->fgcolor, p, n, 0, 0));
+	DRAW(gdrawpolyline(_d, xd->lwd, xd->lty, xd->fgcolor, p, n, 0, 0));
     vmaxset(vmax);
+}
 	/********************************************************/
 	/* device_Polygon should have the side-effect that a 	*/
 	devy = y[i];
 	GConvert(&devx, &devy, coords, DEVICE, dd);
 	points[i].x = (int) (devx);
 	points[i].y = (int) (devy);
+    }
-    if (bg != NA_INTEGER) {
+    if (R_OPAQUE(bg)) {
 	SetColor(bg, dd);
 	DRAW(gfillpolygon(_d, xd->fgcolor, points, n));
+    }
-    if (fg != NA_INTEGER) {
+    if (R_OPAQUE(fg)) {
 	SetColor(fg, dd);
 	SetLinetype(dd->gp.lty, dd->gp.lwd, dd);
 	DRAW(gdrawpolygon(_d, xd->lwd, xd->lty, xd->fgcolor, points, n, 0 ));
+    }
     vmaxset(vmax);
     rot1 = rot * DEG2RAD;
     x += -xl * cos(rot1) + yl * sin(rot1);
     y -= -xl * sin(rot1) - yl * cos(rot1);
     SetFont(dd->gp.font, size, rot, dd);
     SetColor(dd->gp.col, dd);
+    if (R_OPAQUE(xd->fgcolor)) {
 #ifdef NOCLIPTEXT
-    gsetcliprect(xd->gawin, getrect(xd->gawin));
+	gsetcliprect(xd->gawin, getrect(xd->gawin));
-    gdrawstr1(xd->gawin, xd->font, xd->fgcolor, pt(x, y), str, hadj);
+	gdrawstr1(xd->gawin, xd->font, xd->fgcolor, pt(x, y), str, hadj);
-    if (xd->kind==SCREEN) {
+	if (xd->kind==SCREEN) {
-	gsetcliprect(xd->bm, getrect(xd->bm));
+	    gsetcliprect(xd->bm, getrect(xd->bm));
-	gdrawstr1(xd->bm, xd->font, xd->fgcolor, pt(x, y), str, hadj);
+	    gdrawstr1(xd->bm, xd->font, xd->fgcolor, pt(x, y), str, hadj);
-    }
+	}
 #else
-    DRAW(gdrawstr1(_d, xd->font, xd->fgcolor, pt(x, y), str, hadj));
+	DRAW(gdrawstr1(_d, xd->font, xd->fgcolor, pt(x, y), str, hadj));
 #endif
+    }
+}
 	/********************************************************/
 	/* device_Locator should return the location of the next*/
 	/* mouse click (in DEVICE coordinates;  GLocator is	*/
 Rboolean GADeviceDriver(DevDesc *dd, char *display, double width,
 			double height, double pointsize,
-			Rboolean recording, int resize)
+			Rboolean recording, int resize, int canvas)
+{
     /* if need to bail out with some sort of "error" then */
     /* must free(dd) */
     int   ps;
     dd->dp.font = 1;
     dd->dp.ps = ps;
     /* Start the Device Driver and Hardcopy.  */
-    if (!GA_Open(dd, xd, display, width, height, recording, resize)) {
+    if (!GA_Open(dd, xd, display, width, height, recording, resize,
+		 GArgb(canvas, dd->gp.gamma))) {
 	free(xd);
 	return FALSE;
+    }
     dd->deviceSpecific = (void *) xd;
     /* Set up Data Structures  */
     } else if (!strcmp(tp, "wmf")) {
 	sprintf(display, "win.metafile:%s", fn);
 	SaveAsWin(dd, display);
     } else if (!strcmp(tp, "ps")) {
 	SaveAsPostscript(dd, fn);
+    } else if (!strcmp(tp, "pdf")) {
+	SaveAsPDF(dd, fn);
     } else
 	errorcall(call, "unknown type");
     return R_NilValue;
+}
     gadesc *xd = (gadesc *) dd->deviceSpecific;
     r = ggetcliprect(xd->gawin);
     gsetcliprect(xd->gawin, getrect(xd->gawin));
     if (xd->kind==PNG)
 	R_SaveAsPng(xd->gawin, xd->windowWidth, xd->windowHeight,
-		    privategetpixel, 0, xd->fp) ;
+		    privategetpixel, 0, xd->fp,
+		    R_OPAQUE(xd->bg) ? 0 : xd->canvascolor) ;
     else if (xd->kind==JPEG)
 	R_SaveAsJpeg(xd->gawin, xd->windowWidth, xd->windowHeight,
 		     privategetpixel, 0, xd->quality, xd->fp) ;
     else
 	R_SaveAsBmp(xd->gawin, xd->windowWidth, xd->windowHeight,
     gadesc *xd = (gadesc *) dd->deviceSpecific;
     if (!Load_Rbitmap_Dll()) {
 	R_ShowMessage("Impossible to load Rbitmap.dll");
 	return;
+    }
-    if ((fp=fopen(fn,"wb")) == NULL) {
+    if ((fp=fopen(fn, "wb")) == NULL) {
 	char msg[MAX_PATH+32];
-	strcpy(msg,"Impossible to open ");
+	strcpy(msg, "Impossible to open ");
 	strncat(msg, fn, MAX_PATH);
 	R_ShowMessage(msg);
 	return;
+    }
     r = ggetcliprect(xd->bm);
     gsetcliprect(xd->bm, getrect(xd->bm));
     R_SaveAsPng(xd->bm, xd->windowWidth, xd->windowHeight,
-		privategetpixel, 0, fp) ;
+		privategetpixel, 0, fp, 0) ;
+    /* R_OPAQUE(xd->bg) ? 0 : xd->canvascolor) ; */
     gsetcliprect(xd->bm, r);
     fclose(fp);
+}
 static void SaveAsJpeg(DevDesc *dd,int quality,char *fn)

The R Project SVN R

(root)/branches/R-NaString/src/gnuwin32/devga.c @ 28362 – Rev 15394 → 15641