The R Project SVN – R – Diff – /trunk/src/modules/gnome/devGNOME.c


/*
 *  R : A Computer Language for Statistical Data Analysis
 *  Copyright (C) 1998-2002   Lyndon Drake
 *                            and the R Development Core Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
 
/* Avoid braced-groups warning from -Wall */
#define G_STMT_START do
#define G_STMT_END   while(0)
 
#include <gnome.h>
#include <math.h>
 
#include "Defn.h"
#include "Graphics.h"
#include "Rdevices.h"
#include "devGNOME.h"
#include "terminal.h"
#include "terminal-functions.h"
 
#define CURSOR		GDK_CROSSHAIR		/* Default cursor */
#define MM_PER_INCH	25.4			/* mm -> inch conversion */
 
/* routines from here */
 
/* Device driver actions */
static void GNOME_Activate(NewDevDesc *dd);
static void GNOME_Circle(double x, double y, double r,
			 R_GE_gcontext *gc,
			 NewDevDesc *dd);
static void GNOME_Clip(double x0, double x1, double y0, double y1, 
		     NewDevDesc *dd);
static void GNOME_Close(NewDevDesc *dd);
static void GNOME_Deactivate(NewDevDesc *dd);
static void GNOME_Hold(NewDevDesc *dd);
static Rboolean GNOME_Locator(double *x, double *y, NewDevDesc *dd);
static void GNOME_Line(double x1, double y1, double x2, double y2,
		       R_GE_gcontext *gc,
		       NewDevDesc *dd);
static void GNOME_MetricInfo(int c,
			     R_GE_gcontext *gc,
			     double* ascent, double* descent,
			     double* width, NewDevDesc *dd);
static void GNOME_Mode(int mode, NewDevDesc *dd);
static void GNOME_NewPage(R_GE_gcontext *gc, NewDevDesc *dd);
static void GNOME_Polygon(int n, double *x, double *y, 
			  R_GE_gcontext *gc,
			  NewDevDesc *dd);
static void GNOME_Polyline(int n, double *x, double *y, 
			   R_GE_gcontext *gc,
			   NewDevDesc *dd);
static void GNOME_Rect(double x0, double y0, double x1, double y1,
		       R_GE_gcontext *gc,
		       NewDevDesc *dd);
static void GNOME_Resize(NewDevDesc *dd);
static void GNOME_Size(double *left, double *right,
		     double *bottom, double *top,
		     NewDevDesc *dd);
static double GNOME_StrWidth(char *str, 
			     R_GE_gcontext *gc,
			     NewDevDesc *dd);
static void GNOME_Text(double x, double y, char *str, 
		       double rot, double hadj, 
		       R_GE_gcontext *gc,
		       NewDevDesc *dd);
static Rboolean GNOME_Open(NewDevDesc*, gnomeDesc*, char*, double, double);
 
			/* Pixel Dimensions (Inches) */
 
static double pixelWidth(void)
{
    double width, widthMM;
    width = gdk_screen_width();
    widthMM = gdk_screen_width_mm();
    return ((double)widthMM / (double)width) / MM_PER_INCH;
}
 
static double pixelHeight(void)
{
    double height, heightMM;
    height = gdk_screen_height();
    heightMM = gdk_screen_height_mm();
    return ((double)heightMM / (double)height) / MM_PER_INCH;
}
 
/* font stuff */
 
static char *fontname_R6 = "-adobe-helvetica-%s-%s-*-*-*-%d-*-*-*-*-*-*";
static char *symbolname = "-adobe-symbol-*-*-*-*-*-%d-*-*-*-*-*-*";
static char *fixedname = "fixed";
 
static char *slant[] = {"r", "o"};
static char *weight[] = {"medium", "bold"};
 
static char *fontname = NULL;
static GHashTable *font_htab = NULL;
 
static int RDeviceNumber(NewDevDesc *dd)
{
    return devNumber((DevDesc*) dd) + 1;
}
 
static GdkFont *RGTKLoadFont(char *font)
{
  GdkFont *tmp_font;
  
  g_return_val_if_fail(font_htab, NULL);
  tmp_font = g_hash_table_lookup(font_htab, (gpointer) font);
 
  if(!tmp_font)
    {
      if((tmp_font = gdk_font_load(font)))
	{
	  g_hash_table_insert(font_htab, (gpointer) g_strdup(font),
			      (gpointer) tmp_font);
	}
    }
 
  return tmp_font;
}
 
static gboolean SetBaseFont (gnomeDesc *gd)
{
  gd->fontface = 1;
  gd->fontsize = 12;
  gd->usefixed = 0;
  
  if (font_htab == NULL)
    {
      font_htab = g_hash_table_new(g_str_hash, g_str_equal);
    }
 
  fontname = g_strdup_printf(fontname_R6, weight[0], slant[0], 
			     gd->fontsize * 10);
  gd->font = RGTKLoadFont(fontname);
  g_free(fontname);
 
  if(gd->font)
    return TRUE;
 
  gd->usefixed = 1;
  gd->font = RGTKLoadFont(fixedname);
 
  if(gd->font)
    return TRUE;
  
  return FALSE;
}
 
#define SMALLEST 8
#define LARGEST 24
 
static void SetFont(NewDevDesc *dd, gint face, gint size)
{
  GdkFont *tmp_font;
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
 
  if (face < 1 || face > 5)
    face = 1;
  
  size = 2 * size / 2;
  if (size < SMALLEST)
    size = SMALLEST;
  else if (size > LARGEST)
    size = LARGEST;
  
  if (!gd->usefixed)
    {
      if (face == 5)
	fontname = g_strdup_printf(symbolname, 10 * size);
      else
	fontname = g_strdup_printf(fontname_R6,
				   weight[(face-1)%2],
				   slant[((face-1)/2)%2],
				   10 * size);
      
      tmp_font = RGTKLoadFont(fontname);
      g_free(fontname);
 
      if (tmp_font)
	{
	  gd->font = tmp_font;
	  gd->fontface = face;
	  gd->fontsize = size;
	}
      else
	{
	  error("gdk font at size %d could not be loaded", size);
	}
    }
}
 
/* Get GNOME color specification from R color  */
static guint32 Color_RGBA(int color)
{
  int red, green, blue, alpha;
  
  red = R_RED(color);
  green = R_GREEN(color);
  blue = R_BLUE(color);
  alpha = 255 - R_ALPHA(color);
 
  return GNOME_CANVAS_COLOR_A(red, green, blue, alpha);
}
 
/* line type 
   fixme: not currently used 
static void SetLineType(NewDevDesc *dd, int newlty, int newlwd)
{
  static gchar dashlist[8];
  gint i, j;
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
  
  if (newlty != gd->lty || newlwd != gd->lwd)
    {
      if (newlty == 0)
	{
	  if(newlwd <= 1)
	    newlwd = 0;
	  
	  gdk_gc_set_line_attributes(gd->wgc, newlwd,
				     GDK_LINE_SOLID,
				     GDK_CAP_BUTT,
				     GDK_JOIN_ROUND);
	}
      else
	{
	  if (newlwd < 1)
	    newlwd = 1;
 
	  for(i = 0; (i < 8) && (newlty != 0); i++) {
	    j = newlty & 15;
	    if(j == 0) j = 1;
	    j = j * newlwd;
	    if(j > 255) j = 255;
	    dashlist[i] = j;
	    newlty = newlty >> 4;
	  }
 
	  // set dashes
	  gdk_gc_set_dashes(gd->wgc, 0, dashlist, i);
	  gdk_gc_set_line_attributes(gd->wgc, newlwd,
				     GDK_LINE_ON_OFF_DASH,
				     GDK_CAP_BUTT,
				     GDK_JOIN_ROUND);
	}
    }
}
*/
 
/* signal functions */
 
static gint configure_event(GtkWidget *widget, GdkEventConfigure *event,
			    gpointer data) 
{
  NewDevDesc *dd;
  gnomeDesc *gd;
 
  dd = (NewDevDesc *) data;
  g_return_val_if_fail(dd != NULL, FALSE);
 
  gd = (gnomeDesc *) dd->deviceSpecific;
  g_return_val_if_fail(gd != NULL, FALSE);
  g_return_val_if_fail(gd->canvas != NULL, FALSE);
  g_return_val_if_fail(GNOME_IS_CANVAS(gd->canvas), FALSE);
 
  if((gd->windowWidth != gd->canvas->allocation.width) ||
     (gd->windowHeight != gd->canvas->allocation.height))
    {
      gd->windowWidth = gd->canvas->allocation.width;
      gd->windowHeight = gd->canvas->allocation.height;
      gd->resize = TRUE;
    }
 
  return FALSE;
}
 
static gint expose_event(GtkWidget *widget, GdkEventExpose *event,
			 gpointer data)
{
  NewDevDesc *dd;
  gnomeDesc *gd;
 
  dd = (NewDevDesc *) data;
  g_return_val_if_fail(dd, FALSE);
  gd = (gnomeDesc *) dd->deviceSpecific;
 
  if (gd->resize)
    {
      GNOME_Resize(dd); 
    }
  
  GEplayDisplayList((GEDevDesc*) GetDevice(devNumber((DevDesc*)dd)));
 
  return FALSE;
}
 
static gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) 
{
    NewDevDesc *dd;
    gchar *cmd;
 
    dd = (NewDevDesc *) data;
    g_return_val_if_fail(dd != NULL, FALSE);
 
    cmd = g_strdup_printf("dev.off(%d)\n", RDeviceNumber(dd));
    R_gtk_terminal_run(cmd);
    g_free(cmd);
 
    return TRUE;
}
 
static void toolbar_activate_cb(GtkWidget *widget, gpointer data) 
{
    NewDevDesc *dd;
    gchar *cmd;
 
    g_return_if_fail(data);
    dd = (NewDevDesc *) data;
 
    cmd = g_strdup_printf("dev.set(%d)\n", RDeviceNumber(dd));
    R_gtk_terminal_run(cmd);
    g_free(cmd);
}
 
static void toolbar_close_cb(GtkWidget *widget, gpointer data) 
{
    NewDevDesc *dd;
    gchar *cmd;
 
    g_return_if_fail(data);
 
    dd = (NewDevDesc *) data;
    cmd = g_strdup_printf("dev.off(%d)\n", RDeviceNumber(dd));
    R_gtk_terminal_run(cmd);
    g_free(cmd);
}
 
static void
save_ok (GtkWidget *ok_button, gpointer data)
{
    NewDevDesc *dd;
    GtkFileSelection *fsel = GTK_FILE_SELECTION(data);
    char *filename = gtk_file_selection_get_filename(fsel);
    char *cmd;
 
    if (!filename)
	return;
    
    dd = gtk_object_get_user_data(GTK_OBJECT(fsel));
    cmd = g_strdup_printf("dev.set(%d)\ndev.print(file=\"%s\")\n",
			  RDeviceNumber(dd), filename);
    R_gtk_terminal_run(cmd);
    
    g_free(cmd);
    gtk_widget_destroy (GTK_WIDGET(fsel));
 
}
 
 
static void toolbar_save_as_cb(GtkWidget *widget, gpointer data)
{
    NewDevDesc *dd = (NewDevDesc*) data;
    gnomeDesc *gd = (gnomeDesc*) dd->deviceSpecific;
 
    GtkFileSelection *fsel = 
	GTK_FILE_SELECTION(gtk_file_selection_new("Save as PostScript"));
 
    gtk_object_set_user_data(GTK_OBJECT(fsel), dd);
    gtk_file_selection_set_filename(fsel, "Rplots.ps");
  
    gtk_signal_connect(GTK_OBJECT(fsel->ok_button), "clicked",
		       GTK_SIGNAL_FUNC(save_ok), fsel);
    gtk_signal_connect_object(GTK_OBJECT(fsel->cancel_button), "clicked",
			      GTK_SIGNAL_FUNC(gtk_widget_destroy),
			      GTK_OBJECT(fsel));
 
 
    gtk_window_position(GTK_WINDOW(fsel), GTK_WIN_POS_MOUSE);
    gtk_window_set_transient_for(GTK_WINDOW(fsel), GTK_WINDOW(gd->window));
    gtk_widget_show(GTK_WIDGET(fsel));
}
 
static void toolbar_print_cb (GtkWidget *widget, gpointer data)
{
    NewDevDesc *dd = (NewDevDesc*) data;
    gchar *cmd;
 
    cmd = g_strdup_printf("dev.set(%d)\ndev.print()",
			  RDeviceNumber(dd));
    R_gtk_terminal_run(cmd);
    g_free(cmd);
}
 
static GnomeUIInfo graphics_toolbar[] =
{
    { GNOME_APP_UI_ITEM, "Activate", "Make this window the current device",
      (gpointer) toolbar_activate_cb, NULL, NULL, GNOME_APP_PIXMAP_STOCK,
      GNOME_STOCK_PIXMAP_JUMP_TO, 0, (GdkModifierType) 0, NULL },
    GNOMEUIINFO_SEPARATOR,
    { GNOME_APP_UI_ITEM, "Save As", "Save as a PostScript file", 
      (gpointer) toolbar_save_as_cb, NULL, NULL, 
      GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_SAVE_AS, 0, 
      (GdkModifierType) 0, NULL },
    { GNOME_APP_UI_ITEM, "Print", "Print graphics", 
      (gpointer) toolbar_print_cb, NULL, NULL, 
      GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_PRINT, 0, 
      (GdkModifierType) 0, NULL },
    GNOMEUIINFO_SEPARATOR,
    { GNOME_APP_UI_ITEM, "Close", "Close this graphics device",
      (gpointer) toolbar_close_cb, NULL, NULL,
      GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_CLOSE, 0, 
      (GdkModifierType) 0, NULL },
    GNOMEUIINFO_END
};
 
static void GNOME_NewPage(R_GE_gcontext *gc,
			  NewDevDesc *dd)
{
  GnomeCanvasItem *group;
  gnomeDesc *gd = (gnomeDesc*) dd->deviceSpecific;
 
  g_return_if_fail(gd->canvas);
 
  if (gd->group)
    {
      gtk_object_destroy(GTK_OBJECT(gd->group));
      gd->plotarea = NULL;
    }
  
  /* create group for plotting objects */
  group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(gd->canvas)),
				 gnome_canvas_group_get_type(),
				 "x", (double) 0.0,
				 "y", (double) 0.0,
				 NULL);
  gd->group = GNOME_CANVAS_GROUP(group);
  
  /* create plotting area */
  gd->plotarea = 
    gnome_canvas_item_new (gd->group,
			   gnome_canvas_rect_get_type(),
			   "x1", (double) 0.0,
			   "y1", (double) 0.0,
			   "x2", (double) gd->windowWidth,
			   "y2", (double) gd->windowHeight,
			   NULL);
 
  if (R_OPAQUE(gc->fill))
    {
      gnome_canvas_item_set(gd->plotarea,
			    "fill_color_rgba", Color_RGBA(gc->fill),
			    NULL);
    }
  else
    {
      gnome_canvas_item_set(gd->plotarea,
			    "fill_color", "white",
			    NULL);
    }
}
 
/* create window etc */
static Rboolean
GNOME_Open(NewDevDesc *dd, gnomeDesc *gd, char *dsp, double w, double h)
{
    gint iw, ih;
    R_GE_gcontext gc;
 
    /*gdk_rgb_set_install(TRUE); */
    /* gdk_rgb_set_verbose(TRUE);*/
    gdk_rgb_init();
    gtk_widget_push_visual(gdk_rgb_get_visual());
    gtk_widget_push_colormap(gdk_rgb_get_cmap());
 
    /* initialise pointers */
    gd->canvas = NULL;
    gd->group = NULL;
    gd->plotarea = NULL;
 
    if(!SetBaseFont(gd))
      {
	Rprintf("can't find X11 font\n");
	return FALSE;
      }
 
    /* create window etc */
    gd->windowWidth = iw = w / pixelWidth();
    gd->windowHeight = ih = h / pixelHeight();
 
    gd->window = gnome_app_new("R.gnome.graphics", "R Graphics");
 
    gtk_window_set_policy(GTK_WINDOW(gd->window), TRUE, TRUE, FALSE);
    gtk_widget_realize(gd->window);
 
    /* create toolbar */
    gnome_app_create_toolbar_with_data(GNOME_APP(gd->window), graphics_toolbar,
				       (gpointer) dd);
 
    /* create canvas */
    gd->canvas = gnome_canvas_new_aa();
    gtk_widget_set_usize(gd->canvas, iw, ih);
    gnome_canvas_set_scroll_region(GNOME_CANVAS(gd->canvas), 0, 0, iw, ih);
 
    /* create new plot area on canvas */
    /* FIXME: We should have a canvas color argument */
    /* gamma is defaulted to 1 here */
    /* 
     * WARNING: Many graphical parameters are unset - if GNOME_NewPage
     * starts to make use of more than fill and gamma then more 
     * parameters need setting here.
     */
    gc.fill = R_RGB(255,255,255);
    gc.gamma = 1;
    GNOME_NewPage(&gc, dd);
 
    /* place and realize the canvas */
    gnome_app_set_contents(GNOME_APP(gd->window), gd->canvas);
    gtk_widget_realize(gd->canvas);
 
    /* same as XSynch() */
    gdk_flush();
 
    /* set the cursor */
    gd->gcursor = gdk_cursor_new(GDK_CROSSHAIR);
    gdk_window_set_cursor(gd->canvas->window, gd->gcursor);
    
    /* connect to delete signal handler, etc */
    gtk_signal_connect(GTK_OBJECT(gd->window), "configure_event",
		       (GtkSignalFunc) configure_event, (gpointer) dd);
    gtk_signal_connect(GTK_OBJECT(gd->canvas), "expose_event",
		       (GtkSignalFunc) expose_event, (gpointer) dd);
    gtk_signal_connect(GTK_OBJECT(gd->window), "delete_event",
		       (GtkSignalFunc) delete_event, (gpointer) dd);
 
    /* show everything */
    gtk_widget_show_all(gd->window);
 
    /* let other widgets use the default settings */
    gtk_widget_pop_visual();
    gtk_widget_pop_colormap();
 
    /* we made it! */
    return TRUE;
}
 
static double GNOME_StrWidth(char *str, 
			     R_GE_gcontext *gc,
			     NewDevDesc *dd)
{
  int size;
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
 
  size = gc->cex * gc->ps + 0.5;
  SetFont(dd, gc->fontface, size);
 
  return (double) gdk_string_width(gd->font, str);
}
 
static void GNOME_MetricInfo(int c, 
			     R_GE_gcontext *gc,
			     double* ascent, double* descent,
			     double* width, NewDevDesc *dd)
{
  gint size;
  gint lbearing, rbearing, iascent, idescent, iwidth;
  gint maxwidth;
  gchar tmp[2];
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
 
  size = gc->cex * gc->ps + 0.5;
  SetFont(dd, gc->fontface, size);
 
  if(c == 0) {
    maxwidth = 0;
 
    for(c = 0; c <= 255; c++) {
      g_snprintf(tmp, 2, "%c", (gchar) c);
      iwidth = gdk_string_width(gd->font, tmp);
      if (iwidth > maxwidth)
	maxwidth = iwidth;
    }
 
    *ascent = (double) gd->font->ascent;
    *descent = (double) gd->font->descent;
    *width = (double) maxwidth;
  }
  else {
    g_snprintf(tmp, 2, "%c", (gchar) c);
    gdk_string_extents(gd->font, tmp,
		       &lbearing, &rbearing,
		       &iwidth, &iascent, &idescent);
 
    *ascent = (double) iascent;
    *descent = (double) idescent;
    *width = (double) (lbearing+rbearing);
  }
}
 
static void GNOME_Resize(NewDevDesc *dd)
{
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
 
  if (gd->resize) {
    dd->left = 0.0;
    dd->right =  gd->windowWidth;
    dd->bottom = gd->windowHeight;
    dd->top = 0.0;
    gd->resize = FALSE;
 
    gtk_widget_set_usize(gd->canvas, gd->windowWidth, gd->windowHeight);
    gnome_canvas_set_scroll_region(GNOME_CANVAS(gd->canvas), 0, 0,
				   gd->windowWidth, gd->windowHeight);
    gnome_canvas_item_set(gd->plotarea,
			  "x2", (double) gd->windowWidth,
			  "y2", (double) gd->windowHeight,
			  NULL);
  }
}
 
static void GNOME_Clip(double x0, double x1, double y0, double y1, NewDevDesc *dd)
{
  /* 
     Clipping is theoretically possible: there is an implementation of
     it in gnome-print-preview, which has a class called clipped-group. As
     the name suggests, this is a canvas group which defines a
     clipping path for the items it contains.  The notes say that this
     will be folded into the standard GnomeCanvasGroup, so I'm waiting
     for this to happen instead of duplicating it here. MTP 6/9/2001
  */
}
 
static void GNOME_Size(double *left, double *right,
		     double *bottom, double *top,
		     NewDevDesc *dd)
{
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
 
    *left = 0.0;
    *right =  gd->windowWidth;
    *bottom = gd->windowHeight;
    *top = 0.0;
}
 
 
/* kill off the window etc */
static void GNOME_Close(NewDevDesc *dd)
{
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
 
    gtk_widget_destroy(gd->window);
 
    free(gd);
}
 
#define title_text_inactive "R graphics device %d"
#define title_text_active "R graphics device %d - Active"
 
static void GNOME_Activate(NewDevDesc *dd)
{
    gnomeDesc *gd;
    gint devnum, numdigits;
    gchar *title_text;
    gint text_len;
 
    text_len = strlen(title_text_active);
 
    gd = (gnomeDesc *) dd->deviceSpecific;
 
    g_return_if_fail(gd != NULL);
 
    devnum = devNumber((DevDesc*)dd);
    devnum++;
    numdigits = floor(R_Log10(devnum)) + 1;
    title_text = g_malloc(text_len + numdigits + 1);
 
    g_return_if_fail(title_text != NULL);
 
    g_snprintf(title_text, text_len + numdigits + 1, title_text_active, devnum);
    *(title_text + text_len + numdigits) = '\0';
 
    gtk_window_set_title(GTK_WINDOW(gd->window), title_text);
 
    g_free(title_text);
}
 
static void GNOME_Deactivate(NewDevDesc *dd)
{
    gnomeDesc *gd;
    gint devnum, numdigits;
    gchar *title_text;
    gint text_len;
 
    text_len = strlen(title_text_inactive);
 
    gd = (gnomeDesc *) dd->deviceSpecific;
 
    g_return_if_fail(gd != NULL);
 
    devnum = devNumber((DevDesc*)dd);
    devnum++;
    numdigits = floor(R_Log10(devnum)) + 1;
    title_text = g_malloc(text_len + numdigits + 1);
 
    g_return_if_fail(title_text != NULL);
 
    g_snprintf(title_text, text_len + numdigits + 1, title_text_inactive, devnum);
    *(title_text + text_len + numdigits) = '\0';
 
    gtk_window_set_title(GTK_WINDOW(gd->window), title_text);
 
    g_free(title_text);
}
 
/* drawing stuff */
 
static void GNOME_Rect(double x0, double y0, double x1, double y1,
		       R_GE_gcontext *gc,
		       NewDevDesc *dd)
{
    double tmp;
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
    GnomeCanvasItem *item;
 
    if(x0 > x1) {
	tmp = x0;
	x0 = x1;
	x1 = tmp;
    }
    if(y0 > y1) {
	tmp = y0;
	y0 = y1;
	y1 = tmp;
    }
 
    item = gnome_canvas_item_new(gd->group,
				 gnome_canvas_rect_get_type(),
				 "x1", x0,
				 "y1", y0,
				 "x2", x1,
				 "y2", y1,
				 "width_units", (double) gc->lwd,
				 NULL);
 
    if(gc->fill != NA_INTEGER) {
	gnome_canvas_item_set(item,
			      "fill_color_rgba", Color_RGBA(gc->fill),
			      NULL);
    }
    if(gc->col != NA_INTEGER) {
	gnome_canvas_item_set(item,
			      "outline_color_rgba", Color_RGBA(gc->col),
			      NULL);
    }
}
 
static void GNOME_Circle(double x, double y, double r,
			 R_GE_gcontext *gc,
			 NewDevDesc *dd)
{
    double x1, y1, x2, y2;
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
    GnomeCanvasItem *item;
 
    x1 = x - r;  y1 = y - r;
    x2 = x + r;  y2 = y + r;
 
    item = gnome_canvas_item_new(gd->group,
				 gnome_canvas_ellipse_get_type(),
				 "x1", x1,
				 "y1", y1,
				 "x2", x2,
				 "y2", y2,
				 "width_units", (double) gc->lwd,
				 NULL);
 
    if(gc->fill != NA_INTEGER) {
	gnome_canvas_item_set(item,
			      "fill_color_rgba", Color_RGBA(gc->fill),
			      NULL);
    }
    if(gc->col != NA_INTEGER) {
	gnome_canvas_item_set(item,
			      "outline_color_rgba", Color_RGBA(gc->col),
			      NULL);
    }
}
 
static void GNOME_Line(double x1, double y1, double x2, double y2,
		       R_GE_gcontext *gc,
		       NewDevDesc *dd)
{
    GnomeCanvasPoints *points;
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
    GnomeCanvasItem *item;
 
    points = gnome_canvas_points_new(2);
    points->coords[0] = x1;
    points->coords[1] = y1;
    points->coords[2] = x2;
    points->coords[3] = y2;
 
    item = gnome_canvas_item_new(gd->group,
				 gnome_canvas_line_get_type(),
				 "points", points,
				 "width_units", (double) gc->lwd,
				 NULL);
 
    if(gc->col != NA_INTEGER) {
	if(gc->lty != 0) {
	    /*SetLineType(GNOME_CANVAS_LINE(item)->gc, lty, lwd);*/
	    gnome_canvas_item_set(item,
				  "line_style", GDK_LINE_ON_OFF_DASH,
				  NULL);
	}
	gnome_canvas_item_set(item,
			      "fill_color_rgba", Color_RGBA(gc->col),
			      NULL);
    }
 
    gnome_canvas_points_free(points);
}
 
static void GNOME_Polyline(int n, double *x, double *y, 
			   R_GE_gcontext *gc,
			   NewDevDesc *dd)
{
    int i;
    GnomeCanvasPoints *points;
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
    GnomeCanvasItem *item;
 
    points = gnome_canvas_points_new(n);
 
    for(i = 0; i < n; i++) {
	points->coords[i * 2] = x[i];
	points->coords[i * 2 + 1] = y[i];
    }
 
    item = gnome_canvas_item_new(gd->group,
				 gnome_canvas_line_get_type(),
				 "points", points,
				 "width_units", (double) gc->lwd,
				 NULL);
 
    if(gc->col != NA_INTEGER) {
	if(gc->lty != 0) {
	  /*
	    SetLineType(&stipple, lty, lwd);
	    gnome_canvas_item_set(item,
				  "fill_stipple", &stipple,
				  NULL);
	    */
	    gnome_canvas_item_set(item,
				  "line_style", GDK_LINE_ON_OFF_DASH,
				  NULL);
	}
	gnome_canvas_item_set(item,
			      "fill_color_rgba", Color_RGBA(gc->col),
			      NULL);
    }
 
    gnome_canvas_points_free(points);
}
 
static void GNOME_Polygon(int n, double *x, double *y, 
			  R_GE_gcontext *gc,
			  NewDevDesc *dd)
{
    int i;
    GnomeCanvasPoints *points;
    gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
    GnomeCanvasItem *item;
 
    points = gnome_canvas_points_new(n);
 
    for(i = 0; i < n; i++) {
	points->coords[i * 2] = floor(x[i]);
	points->coords[i * 2 + 1] = floor(y[i]);
    }
 
    item = gnome_canvas_item_new(gd->group,
				 gnome_canvas_polygon_get_type(),
				 "points", points,
				 "width_units", (double) 2,
				 NULL);
 
    if(gc->fill != NA_INTEGER) {
	gnome_canvas_item_set(item,
			      "fill_color_rgba", Color_RGBA(gc->fill),
			      NULL);
    }
    if(gc->col != NA_INTEGER) {
	gnome_canvas_item_set(item,
			      "outline_color_rgba", Color_RGBA(gc->col),
			      NULL);
    }
 
    gnome_canvas_points_free(points);
}
 
static void GNOME_Text(double x, double y, char *str, 
		       double rot, double hadj, 
		       R_GE_gcontext *gc,
		       NewDevDesc *dd)
{
  double affine[6] = {1, 0, 0, 1, 0, 0};
  double rrot = DEG2RAD * rot;
  GnomeCanvasItem *item;
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
  int size;
 
  size = gc->cex * gc->ps + 0.5;
  SetFont(dd, gc->fontface, size);
  
  if (rot != 0)
    {
      affine[0] = affine[3] = cos(rrot);
      affine[1] = -sin(rrot);
      affine[2] = -affine[1];
      affine[4] = x;
      affine[5] = y;
      x = y = 0.0;
    }
 
  item = gnome_canvas_item_new (gd->group,
				gnome_canvas_text_get_type(),
				"text", str,
				"anchor", GTK_ANCHOR_SOUTH_WEST,
				"x", x,
				"y", y,
				"font_gdk", gd->font,
				"fill_color_rgba", Color_RGBA(gc->col),
				NULL);
 
  if (rot != 0)
    gnome_canvas_item_affine_relative (item, affine);
}
 
/* locator */
 
static gint locator_cb (GtkWidget * canvas, GdkEventButton * event,
			gpointer data)
{
  GdkEventButton *info = (GdkEventButton*) data;
  
  *info = *event;
  gtk_main_quit();
 
  return FALSE;
}
 
static Rboolean GNOME_Locator(double *x, double *y, NewDevDesc *dd)
{
  gnomeDesc *gd = (gnomeDesc *) dd->deviceSpecific;
  GdkEventButton info;
  guint handler_id;
 
  /* Flush any pending events */
  while (gtk_events_pending())
    gtk_main_iteration();
 
  /* connect signal */
  handler_id = gtk_signal_connect (GTK_OBJECT (gd->canvas),
				   "button-press-event",
				   GTK_SIGNAL_FUNC (locator_cb), &info);
 
  /* run the handler */
  gtk_main();
 
  *x = (double) info.x;
  *y = (double) info.y;
 
  /* clean up */
  gtk_signal_disconnect(GTK_OBJECT(gd->canvas), handler_id);
 
  if (info.button == 1)
    {
      gdk_beep();
      return TRUE;
    }
  else
    return FALSE;
}
 
/* useless stuff */
 
static void GNOME_Mode(gint mode, NewDevDesc *dd)
{
}
 
static void GNOME_Hold(NewDevDesc *dd)
{
}
 
 
/* Device driver entry point */
Rboolean GnomeDeviceDriver(DevDesc *odd, char *display, 
			   double width, double height, double pointsize)
{
    int ps;
    gnomeDesc *gd;
    NewDevDesc *dd;
 
    if(!(gd = (gnomeDesc *) malloc(sizeof(gnomeDesc))))
	return FALSE;
 
    dd = (NewDevDesc*) odd;  
    dd->deviceSpecific = (void *) gd;
 
    /* FIXME: font loading */
    ps = pointsize;
    if(ps < 6 || ps > 24) ps = 12;
    ps = 2 * (ps / 2);
    gd->fontface = -1;
    gd->fontsize = -1;
    
    dd->startfont = 1; 
    dd->startps = ps;
    dd->startcol = 0;
    dd->startfill = NA_INTEGER;
    dd->startlty = LTY_SOLID; 
    dd->startgamma = 1;
 
    /* device driver start */
    if(!GNOME_Open(dd, gd, display, width, height)) {
	free(gd);
	return FALSE;
    }
 
    dd->newDevStruct = 1;
 
    /* setup data structure */
    dd->open = GNOME_Open;
    dd->close = GNOME_Close;
    dd->activate = GNOME_Activate;
    dd->deactivate = GNOME_Deactivate;
    dd->size = GNOME_Size;
    dd->newPage = GNOME_NewPage;
    dd->clip = GNOME_Clip;
    dd->strWidth = GNOME_StrWidth;
    dd->text = GNOME_Text;
    dd->rect = GNOME_Rect;
    dd->circle = GNOME_Circle;
    dd->line = GNOME_Line;
    dd->polyline = GNOME_Polyline;
    dd->polygon = GNOME_Polygon;
    dd->locator = GNOME_Locator;
    dd->mode = GNOME_Mode;
    dd->hold = GNOME_Hold;
    dd->metricInfo = GNOME_MetricInfo;
 
    dd->left = 0;
    dd->right = gd->windowWidth;
    dd->bottom = gd->windowHeight;
    dd->top = 0;
 
    /* FIXME: nominal character sizes */
    dd->cra[0] = 10;
    dd->cra[1] = 10;
 
    /* FIXME: character addressing offsets */
    dd->xCharOffset = 0.4900;
    dd->yCharOffset = 0.3333;
    dd->yLineBias = 0.1;
 
    /* inches per raster unit */
    dd->ipr[0] = pixelWidth();
    dd->ipr[1] = pixelHeight();
 
    /* device capabilities */
    dd->canResizePlot= TRUE;
    dd->canChangeFont= FALSE; /* FIXME: surely this is possible */
    dd->canRotateText= TRUE;
    dd->canResizeText= TRUE;
    dd->canClip = FALSE;/* FIXME: really? */
    dd->canHAdj = 0;/* not better? {0, 0.5, 1} */
    dd->canChangeGamma = FALSE;
 
    /* x11 device description stuff */
    gd->cex = 1.0;
    gd->srt = 0.0;
    gd->resize = FALSE;
 
    dd->displayListOn = TRUE;
 
    /* finish */
    return TRUE;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Rev 27117	Rev 27236
1	`/*`	1	`/*`
2	`* R : A Computer Language for Statistical Data Analysis`	2	`* R : A Computer Language for Statistical Data Analysis`
3	`* Copyright (C) 1998-2002 Lyndon Drake`	3	`* Copyright (C) 1998-2002 Lyndon Drake`
4	`* and the R Development Core Team`	4	`* and the R Development Core Team`
5	`*`	5	`*`
6	`* This program is free software; you can redistribute it and/or modify`	6	`* This program is free software; you can redistribute it and/or modify`
7	`* it under the terms of the GNU General Public License as published by`	7	`* it under the terms of the GNU General Public License as published by`
8	`* the Free Software Foundation; either version 2 of the License, or`	8	`* the Free Software Foundation; either version 2 of the License, or`
9	`* (at your option) any later version.`	9	`* (at your option) any later version.`
10	`*`	10	`*`
11	`* This program is distributed in the hope that it will be useful,`	11	`* This program is distributed in the hope that it will be useful,`
12	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`	12	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
13	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	13	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14	`* GNU General Public License for more details.`	14	`* GNU General Public License for more details.`
15	`*`	15	`*`
16	`* You should have received a copy of the GNU General Public License`	16	`* You should have received a copy of the GNU General Public License`
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	`#ifdef HAVE_CONFIG_H`	21	`#ifdef HAVE_CONFIG_H`
22	`# include <config.h>`	22	`# include <config.h>`
23	`#endif`	23	`#endif`
24		24
25	`/* Avoid braced-groups warning from -Wall */`	25	`/* Avoid braced-groups warning from -Wall */`
26	`#define G_STMT_START do`	26	`#define G_STMT_START do`
27	`#define G_STMT_END while(0)`	27	`#define G_STMT_END while(0)`
28		28
29	`#include <gnome.h>`	29	`#include <gnome.h>`
30	`#include <math.h>`	30	`#include <math.h>`
31		31
32	`#include "Defn.h"`	32	`#include "Defn.h"`
33	`#include "Graphics.h"`	33	`#include "Graphics.h"`
34	`#include "Rdevices.h"`	34	`#include "Rdevices.h"`
35	`#include "devGNOME.h"`	35	`#include "devGNOME.h"`
36	`#include "terminal.h"`	36	`#include "terminal.h"`
37	`#include "terminal-functions.h"`	37	`#include "terminal-functions.h"`
38		38
39	`#define CURSOR GDK_CROSSHAIR /* Default cursor */`	39	`#define CURSOR GDK_CROSSHAIR /* Default cursor */`
40	`#define MM_PER_INCH 25.4 /* mm -> inch conversion */`	40	`#define MM_PER_INCH 25.4 /* mm -> inch conversion */`
41		41
42	`/* routines from here */`	42	`/* routines from here */`
43		43
44	`/* Device driver actions */`	44	`/* Device driver actions */`
45	`static void GNOME_Activate(NewDevDesc *dd);`	45	`static void GNOME_Activate(NewDevDesc *dd);`
46	`static void GNOME_Circle(double x, double y, double r,`	46	`static void GNOME_Circle(double x, double y, double r,`
47	`int col, int fill, double gamma, int lty, double lwd,`	47	`R_GE_gcontext *gc,`
48	`NewDevDesc *dd);`	48	`NewDevDesc *dd);`
49	`static void GNOME_Clip(double x0, double x1, double y0, double y1,`	49	`static void GNOME_Clip(double x0, double x1, double y0, double y1,`
50	`NewDevDesc *dd);`	50	`NewDevDesc *dd);`
51	`static void GNOME_Close(NewDevDesc *dd);`	51	`static void GNOME_Close(NewDevDesc *dd);`
52	`static void GNOME_Deactivate(NewDevDesc *dd);`	52	`static void GNOME_Deactivate(NewDevDesc *dd);`
53	`static void GNOME_Hold(NewDevDesc *dd);`	53	`static void GNOME_Hold(NewDevDesc *dd);`
54	`static Rboolean GNOME_Locator(double x, double y, NewDevDesc *dd);`	54	`static Rboolean GNOME_Locator(double x, double y, NewDevDesc *dd);`
55	`static void GNOME_Line(double x1, double y1, double x2, double y2,`	55	`static void GNOME_Line(double x1, double y1, double x2, double y2,`
56	`int col, double gamma, int lty, double lwd,`	56	`R_GE_gcontext *gc,`
57	`NewDevDesc *dd);`	57	`NewDevDesc *dd);`
58	`static void GNOME_MetricInfo(int c, int font, double cex, double ps,`	58	`static void GNOME_MetricInfo(int c,`
-		59	`R_GE_gcontext *gc,`
59	`double* ascent, double* descent,`	60	`double* ascent, double* descent,`
60	`double* width, NewDevDesc *dd);`	61	`double* width, NewDevDesc *dd);`
61	`static void GNOME_Mode(int mode, NewDevDesc *dd);`	62	`static void GNOME_Mode(int mode, NewDevDesc *dd);`
62	`static void GNOME_NewPage(int fill, double gamma, NewDevDesc *dd);`	63	`static void GNOME_NewPage(R_GE_gcontext gc, NewDevDesc dd);`
63	`static void GNOME_Polygon(int n, double x, double y,`	64	`static void GNOME_Polygon(int n, double x, double y,`
64	`int col, int fill, double gamma, int lty, double lwd,`	65	`R_GE_gcontext *gc,`
65	`NewDevDesc *dd);`	66	`NewDevDesc *dd);`
66	`static void GNOME_Polyline(int n, double x, double y,`	67	`static void GNOME_Polyline(int n, double x, double y,`
67	`int col, double gamma, int lty, double lwd,`	68	`R_GE_gcontext *gc,`
68	`NewDevDesc *dd);`	69	`NewDevDesc *dd);`
69	`static void GNOME_Rect(double x0, double y0, double x1, double y1,`	70	`static void GNOME_Rect(double x0, double y0, double x1, double y1,`
70	`int col, int fill, double gamma, int lty, double lwd,`	71	`R_GE_gcontext *gc,`
71	`NewDevDesc *dd);`	72	`NewDevDesc *dd);`
72	`static void GNOME_Resize(NewDevDesc *dd);`	73	`static void GNOME_Resize(NewDevDesc *dd);`
73	`static void GNOME_Size(double left, double right,`	74	`static void GNOME_Size(double left, double right,`
74	`double bottom, double top,`	75	`double bottom, double top,`
75	`NewDevDesc *dd);`	76	`NewDevDesc *dd);`
76	`static double GNOME_StrWidth(char *str, int font,`	77	`static double GNOME_StrWidth(char *str,`
-		78	`R_GE_gcontext *gc,`
77	`double cex, double ps, NewDevDesc *dd);`	79	`NewDevDesc *dd);`
78	`static void GNOME_Text(double x, double y, char *str,`	80	`static void GNOME_Text(double x, double y, char *str,`
79	`double rot, double hadj,`	81	`double rot, double hadj,`
80	`int col, double gamma, int font, double cex, double ps,`	82	`R_GE_gcontext *gc,`
81	`NewDevDesc *dd);`	83	`NewDevDesc *dd);`
82	`static Rboolean GNOME_Open(NewDevDesc, gnomeDesc, char*, double, double);`	84	`static Rboolean GNOME_Open(NewDevDesc, gnomeDesc, char*, double, double);`
83		85
84	`/* Pixel Dimensions (Inches) */`	86	`/* Pixel Dimensions (Inches) */`
85		87
86	`static double pixelWidth(void)`	88	`static double pixelWidth(void)`
87	`{`	89	`{`
88	`double width, widthMM;`	90	`double width, widthMM;`
89	`width = gdk_screen_width();`	91	`width = gdk_screen_width();`
90	`widthMM = gdk_screen_width_mm();`	92	`widthMM = gdk_screen_width_mm();`
91	`return ((double)widthMM / (double)width) / MM_PER_INCH;`	93	`return ((double)widthMM / (double)width) / MM_PER_INCH;`
92	`}`	94	`}`
93		95
94	`static double pixelHeight(void)`	96	`static double pixelHeight(void)`
95	`{`	97	`{`
96	`double height, heightMM;`	98	`double height, heightMM;`
97	`height = gdk_screen_height();`	99	`height = gdk_screen_height();`
98	`heightMM = gdk_screen_height_mm();`	100	`heightMM = gdk_screen_height_mm();`
99	`return ((double)heightMM / (double)height) / MM_PER_INCH;`	101	`return ((double)heightMM / (double)height) / MM_PER_INCH;`
100	`}`	102	`}`
101		103
102	`/* font stuff */`	104	`/* font stuff */`
103		105
104	`static char fontname_R6 = "-adobe-helvetica-%s-%s----%d------";`	106	`static char fontname_R6 = "-adobe-helvetica-%s-%s----%d------";`
105	`static char symbolname = "-adobe-symbol------%d------";`	107	`static char symbolname = "-adobe-symbol------%d------";`
106	`static char *fixedname = "fixed";`	108	`static char *fixedname = "fixed";`
107		109
108	`static char *slant[] = {"r", "o"};`	110	`static char *slant[] = {"r", "o"};`
109	`static char *weight[] = {"medium", "bold"};`	111	`static char *weight[] = {"medium", "bold"};`
110		112
111	`static char *fontname = NULL;`	113	`static char *fontname = NULL;`
112	`static GHashTable *font_htab = NULL;`	114	`static GHashTable *font_htab = NULL;`
113		115
114	`static int RDeviceNumber(NewDevDesc *dd)`	116	`static int RDeviceNumber(NewDevDesc *dd)`
115	`{`	117	`{`
116	`return devNumber((DevDesc*) dd) + 1;`	118	`return devNumber((DevDesc*) dd) + 1;`
117	`}`	119	`}`
118		120
119	`static GdkFont RGTKLoadFont(char font)`	121	`static GdkFont RGTKLoadFont(char font)`
120	`{`	122	`{`
121	`GdkFont *tmp_font;`	123	`GdkFont *tmp_font;`
122		124
123	`g_return_val_if_fail(font_htab, NULL);`	125	`g_return_val_if_fail(font_htab, NULL);`
124	`tmp_font = g_hash_table_lookup(font_htab, (gpointer) font);`	126	`tmp_font = g_hash_table_lookup(font_htab, (gpointer) font);`
125		127
126	`if(!tmp_font)`	128	`if(!tmp_font)`
127	`{`	129	`{`
128	`if((tmp_font = gdk_font_load(font)))`	130	`if((tmp_font = gdk_font_load(font)))`
129	`{`	131	`{`
130	`g_hash_table_insert(font_htab, (gpointer) g_strdup(font),`	132	`g_hash_table_insert(font_htab, (gpointer) g_strdup(font),`
131	`(gpointer) tmp_font);`	133	`(gpointer) tmp_font);`
132	`}`	134	`}`
133	`}`	135	`}`
134		136
135	`return tmp_font;`	137	`return tmp_font;`
136	`}`	138	`}`
137		139
138	`static gboolean SetBaseFont (gnomeDesc *gd)`	140	`static gboolean SetBaseFont (gnomeDesc *gd)`
139	`{`	141	`{`
140	`gd->fontface = 1;`	142	`gd->fontface = 1;`
141	`gd->fontsize = 12;`	143	`gd->fontsize = 12;`
142	`gd->usefixed = 0;`	144	`gd->usefixed = 0;`
143		145
144	`if (font_htab == NULL)`	146	`if (font_htab == NULL)`
145	`{`	147	`{`
146	`font_htab = g_hash_table_new(g_str_hash, g_str_equal);`	148	`font_htab = g_hash_table_new(g_str_hash, g_str_equal);`
147	`}`	149	`}`
148		150
149	`fontname = g_strdup_printf(fontname_R6, weight[0], slant[0],`	151	`fontname = g_strdup_printf(fontname_R6, weight[0], slant[0],`
150	`gd->fontsize * 10);`	152	`gd->fontsize * 10);`
151	`gd->font = RGTKLoadFont(fontname);`	153	`gd->font = RGTKLoadFont(fontname);`
152	`g_free(fontname);`	154	`g_free(fontname);`
153		155
154	`if(gd->font)`	156	`if(gd->font)`
155	`return TRUE;`	157	`return TRUE;`
156		158
157	`gd->usefixed = 1;`	159	`gd->usefixed = 1;`
158	`gd->font = RGTKLoadFont(fixedname);`	160	`gd->font = RGTKLoadFont(fixedname);`
159		161
160	`if(gd->font)`	162	`if(gd->font)`
161	`return TRUE;`	163	`return TRUE;`
162		164
163	`return FALSE;`	165	`return FALSE;`
164	`}`	166	`}`
165		167
166	`#define SMALLEST 8`	168	`#define SMALLEST 8`
167	`#define LARGEST 24`	169	`#define LARGEST 24`
168		170
169	`static void SetFont(NewDevDesc *dd, gint face, gint size)`	171	`static void SetFont(NewDevDesc *dd, gint face, gint size)`
170	`{`	172	`{`
171	`GdkFont *tmp_font;`	173	`GdkFont *tmp_font;`
172	`gnomeDesc gd = (gnomeDesc ) dd->deviceSpecific;`	174	`gnomeDesc gd = (gnomeDesc ) dd->deviceSpecific;`
173		175
174	`if (face < 1 \|\| face > 5)`	176	`if (face < 1 \|\| face > 5)`
175	`face = 1;`	177	`face = 1;`
176		178
177	`size = 2 * size / 2;`	179	`size = 2 * size / 2;`
178	`if (size < SMALLEST)`	180	`if (size < SMALLEST)`
179	`size = SMALLEST;`	181	`size = SMALLEST;`
180	`else if (size > LARGEST)`	182	`else if (size > LARGEST)`
181	`size = LARGEST;`	183	`size = LARGEST;`
182		184
183	`if (!gd->usefixed)`	185	`if (!gd->usefixed)`
184	`{`	186	`{`
185	`if (face == 5)`	187	`if (face == 5)`
186	`fontname = g_strdup_printf(symbolname, 10 * size);`	188	`fontname = g_strdup_printf(symbolname, 10 * size);`
187	`else`	189	`else`
188	`fontname = g_strdup_printf(fontname_R6,`	190	`fontname = g_strdup_printf(fontname_R6,`
189	`weight[(face-1)%2],`	191	`weight[(face-1)%2],`
190	`slant[((face-1)/2)%2],`	192	`slant[((face-1)/2)%2],`
191	`10 * size);`	193	`10 * size);`
192		194
193	`tmp_font = RGTKLoadFont(fontname);`	195	`tmp_font = RGTKLoadFont(fontname);`
194	`g_free(fontname);`	196	`g_free(fontname);`
195		197
196	`if (tmp_font)`	198	`if (tmp_font)`
197	`{`	199	`{`
198	`gd->font = tmp_font;`	200	`gd->font = tmp_font;`
199	`gd->fontface = face;`	201	`gd->fontface = face;`
200	`gd->fontsize = size;`	202	`gd->fontsize = size;`
201	`}`	203	`}`
202	`else`	204	`else`
203	`{`	205	`{`
204	`error("gdk font at size %d could not be loaded", size);`	206	`error("gdk font at size %d could not be loaded", size);`
205	`}`	207	`}`
206	`}`	208	`}`
207	`}`	209	`}`
208		210
209	`/* Get GNOME color specification from R color */`	211	`/* Get GNOME color specification from R color */`
210	`static guint32 Color_RGBA(int color)`	212	`static guint32 Color_RGBA(int color)`
211	`{`	213	`{`
212	`int red, green, blue, alpha;`	214	`int red, green, blue, alpha;`
213		215
214	`red = R_RED(color);`	216	`red = R_RED(color);`
215	`green = R_GREEN(color);`	217	`green = R_GREEN(color);`
216	`blue = R_BLUE(color);`	218	`blue = R_BLUE(color);`
217	`alpha = 255 - R_ALPHA(color);`	219	`alpha = 255 - R_ALPHA(color);`
218		220
219	`return GNOME_CANVAS_COLOR_A(red, green, blue, alpha);`	221	`return GNOME_CANVAS_COLOR_A(red, green, blue, alpha);`
220	`}`	222	`}`
221		223
222	`/* line type`	224	`/* line type`
223	`fixme: not currently used`	225	`fixme: not currently used`
224	`static void SetLineType(NewDevDesc *dd, int newlty, int newlwd)`	226	`static void SetLineType(NewDevDesc *dd, int newlty, int newlwd)`
225	`{`	227	`{`
226	`static gchar dashlist[8];`	228	`static gchar dashlist[8];`
227	`gint i, j;`	229	`gint i, j;`
228	`gnomeDesc gd = (gnomeDesc ) dd->deviceSpecific;`	230	`gnomeDesc gd = (gnomeDesc ) dd->deviceSpecific;`
229		231
230	`if (newlty != gd->lty \|\| newlwd != gd->lwd)`	232	`if (newlty != gd->lty \|\| newlwd != gd->lwd)`
231	`{`	233	`{`
232	`if (newlty == 0)`	234	`if (newlty == 0)`
233	`{`	235	`{`
234	`if(newlwd <= 1)`	236	`if(newlwd <= 1)`
235	`newlwd = 0;`	237	`newlwd = 0;`
236		238
237	`gdk_gc_set_line_attributes(gd->wgc, newlwd,`	239	`gdk_gc_set_line_attributes(gd->wgc, newlwd,`
238	`GDK_LINE_SOLID,`	240	`GDK_LINE_SOLID,`
239	`GDK_CAP_BUTT,`	241	`GDK_CAP_BUTT,`
240	`GDK_JOIN_ROUND);`	242	`GDK_JOIN_ROUND);`
241	`}`	243	`}`
242	`else`	244	`else`
243	`{`	245	`{`
244	`if (newlwd < 1)`	246	`if (newlwd < 1)`
245	`newlwd = 1;`	247	`newlwd = 1;`
246		248
247	`for(i = 0; (i < 8) && (newlty != 0); i++) {`	249	`for(i = 0; (i < 8) && (newlty != 0); i++) {`
248	`j = newlty & 15;`	250	`j = newlty & 15;`
249	`if(j == 0) j = 1;`	251	`if(j == 0) j = 1;`
250	`j = j * newlwd;`	252	`j = j * newlwd;`
251	`if(j > 255) j = 255;`	253	`if(j > 255) j = 255;`
252	`dashlist[i] = j;`	254	`dashlist[i] = j;`
253	`newlty = newlty >> 4;`	255	`newlty = newlty >> 4;`
254	`}`	256	`}`
255		257
256	`// set dashes`	258	`// set dashes`
257	`gdk_gc_set_dashes(gd->wgc, 0, dashlist, i);`	259	`gdk_gc_set_dashes(gd->wgc, 0, dashlist, i);`
258	`gdk_gc_set_line_attributes(gd->wgc, newlwd,`	260	`gdk_gc_set_line_attributes(gd->wgc, newlwd,`
259	`GDK_LINE_ON_OFF_DASH,`	261	`GDK_LINE_ON_OFF_DASH,`
260	`GDK_CAP_BUTT,`	262	`GDK_CAP_BUTT,`
261	`GDK_JOIN_ROUND);`	263	`GDK_JOIN_ROUND);`
262	`}`	264	`}`
263	`}`	265	`}`
264	`}`	266	`}`
265	`*/`	267	`*/`
266		268
267	`/* signal functions */`	269	`/* signal functions */`
268		270
269	`static gint configure_event(GtkWidget widget, GdkEventConfigure event,`	271	`static gint configure_event(GtkWidget widget, GdkEventConfigure event,`
270	`gpointer data)`	272	`gpointer data)`
271	`{`	273	`{`
272	`NewDevDesc *dd;`	274	`NewDevDesc *dd;`
273	`gnomeDesc *gd;`	275	`gnomeDesc *gd;`
274		276
275	`dd = (NewDevDesc *) data;`	277	`dd = (NewDevDesc *) data;`
276	`g_return_val_if_fail(dd != NULL, FALSE);`	278	`g_return_val_if_fail(dd != NULL, FALSE);`
277		279
278	`gd = (gnomeDesc *) dd->deviceSpecific;`	280	`gd = (gnomeDesc *) dd->deviceSpecific;`
279	`g_return_val_if_fail(gd != NULL, FALSE);`	281	`g_return_val_if_fail(gd != NULL, FALSE);`
280	`g_return_val_if_fail(gd->canvas != NULL, FALSE);`	282	`g_return_val_if_fail(gd->canvas != NULL, FALSE);`
281	`g_return_val_if_fail(GNOME_IS_CANVAS(gd->canvas), FALSE);`	283	`g_return_val_if_fail(GNOME_IS_CANVAS(gd->canvas), FALSE);`
282		284
283	`if((gd->windowWidth != gd->canvas->allocation.width) \|\|`	285	`if((gd->windowWidth != gd->canvas->allocation.width) \|\|`
284	`(gd->windowHeight != gd->canvas->allocation.height))`	286	`(gd->windowHeight != gd->canvas->allocation.height))`
285	`{`	287	`{`
286	`gd->windowWidth = gd->canvas->allocation.width;`	288	`gd->windowWidth = gd->canvas->allocation.width;`
287	`gd->windowHeight = gd->canvas->allocation.height;`	289	`gd->windowHeight = gd->canvas->allocation.height;`
288	`gd->resize = TRUE;`	290	`gd->resize = TRUE;`
289	`}`	291	`}`
290		292
291	`return FALSE;`	293	`return FALSE;`
292	`}`	294	`}`
293		295
294	`static gint expose_event(GtkWidget widget, GdkEventExpose event,`	296	`static gint expose_event(GtkWidget widget, GdkEventExpose event,`
295	`gpointer data)`	297	`gpointer data)`
296	`{`	298	`{`
297	`NewDevDesc *dd;`	299	`NewDevDesc *dd;`
298	`gnomeDesc *gd;`	300	`gnomeDesc *gd;`
299		301
300	`dd = (NewDevDesc *) data;`	302	`dd = (NewDevDesc *) data;`
301	`g_return_val_if_fail(dd, FALSE);`	303	`g_return_val_if_fail(dd, FALSE);`
302	`gd = (gnomeDesc *) dd->deviceSpecific;`	304	`gd = (gnomeDesc *) dd->deviceSpecific;`
303		305
304	`if (gd->resize)`	306	`if (gd->resize)`
305	`{`	307	`{`
306	`GNOME_Resize(dd);`	308	`GNOME_Resize(dd);`
307	`}`	309	`}`
308		310
309	`GEplayDisplayList((GEDevDesc) GetDevice(devNumber((DevDesc)dd)));`	311	`GEplayDisplayList((GEDevDesc) GetDevice(devNumber((DevDesc)dd)));`
310		312
311	`return FALSE;`	313	`return FALSE;`
312	`}`	314	`}`
313		315
314	`static gint delete_event(GtkWidget widget, GdkEvent event, gpointer data)`	316	`static gint delete_event(GtkWidget widget, GdkEvent event, gpointer data)`
315	`{`	317	`{`
316	`NewDevDesc *dd;`	318	`NewDevDesc *dd;`
317	`gchar *cmd;`	319	`gchar *cmd;`
318		320
319	`dd = (NewDevDesc *) data;`	321	`dd = (NewDevDesc *) data;`
320	`g_return_val_if_fail(dd != NULL, FALSE);`	322	`g_return_val_if_fail(dd != NULL, FALSE);`
321		323
322	`cmd = g_strdup_printf("dev.off(%d)\n", RDeviceNumber(dd));`	324	`cmd = g_strdup_printf("dev.off(%d)\n", RDeviceNumber(dd));`
323	`R_gtk_terminal_run(cmd);`	325	`R_gtk_terminal_run(cmd);`
324	`g_free(cmd);`	326	`g_free(cmd);`
325		327
326	`return TRUE;`	328	`return TRUE;`
327	`}`	329	`}`
328		330
329	`static void toolbar_activate_cb(GtkWidget *widget, gpointer data)`	331	`static void toolbar_activate_cb(GtkWidget *widget, gpointer data)`
330	`{`	332	`{`
331	`NewDevDesc *dd;`	333	`NewDevDesc *dd;`
332	`gchar *cmd;`	334	`gchar *cmd;`
333		335
334	`g_return_if_fail(data);`	336	`g_return_if_fail(data);`
335	`dd = (NewDevDesc *) data;`	337	`dd = (NewDevDesc *) data;`
336		338
337	`cmd = g_strdup_printf("dev.set(%d)\n", RDeviceNumber(dd));`	339	`cmd = g_strdup_printf("dev.set(%d)\n", RDeviceNumber(dd));`
338	`R_gtk_terminal_run(cmd);`	340	`R_gtk_terminal_run(cmd);`
339	`g_free(cmd);`	341	`g_free(cmd);`
340	`}`	342	`}`
341		343
342	`static void toolbar_close_cb(GtkWidget *widget, gpointer data)`	344	`static void toolbar_close_cb(GtkWidget *widget, gpointer data)`
343	`{`	345	`{`
344	`NewDevDesc *dd;`	346	`NewDevDesc *dd;`
345	`gchar *cmd;`	347	`gchar *cmd;`
346		348
347	`g_return_if_fail(data);`	349	`g_return_if_fail(data);`
348		350
349	`dd = (NewDevDesc *) data;`	351	`dd = (NewDevDesc *) data;`
350	`cmd = g_strdup_printf("dev.off(%d)\n", RDeviceNumber(dd));`	352	`cmd = g_strdup_printf("dev.off(%d)\n", RDeviceNumber(dd));`
351	`R_gtk_terminal_run(cmd);`	353	`R_gtk_terminal_run(cmd);`
352	`g_free(cmd);`	354	`g_free(cmd);`
353	`}`	355	`}`
354		356
355	`static void`	357	`static void`
356	`save_ok (GtkWidget *ok_button, gpointer data)`	358	`save_ok (GtkWidget *ok_button, gpointer data)`
357	`{`	359	`{`
358	`NewDevDesc *dd;`	360	`NewDevDesc *dd;`
359	`GtkFileSelection *fsel = GTK_FILE_SELECTION(data);`	361	`GtkFileSelection *fsel = GTK_FILE_SELECTION(data);`
360	`char *filename = gtk_file_selection_get_filename(fsel);`	362	`char *filename = gtk_file_selection_get_filename(fsel);`
361	`char *cmd;`	363	`char *cmd;`
362		364
363	`if (!filename)`	365	`if (!filename)`
364	`return;`	366	`return;`
365		367
366	`dd = gtk_object_get_user_data(GTK_OBJECT(fsel));`	368	`dd = gtk_object_get_user_data(GTK_OBJECT(fsel));`
367	`cmd = g_strdup_printf("dev.set(%d)\ndev.print(file=\"%s\")\n",`	369	`cmd = g_strdup_printf("dev.set(%d)\ndev.print(file=\"%s\")\n",`
368	`RDeviceNumber(dd), filename);`	370	`RDeviceNumber(dd), filename);`
369	`R_gtk_terminal_run(cmd);`	371	`R_gtk_terminal_run(cmd);`
370		372
371	`g_free(cmd);`	373	`g_free(cmd);`
372	`gtk_widget_destroy (GTK_WIDGET(fsel));`	374	`gtk_widget_destroy (GTK_WIDGET(fsel));`
373		375
374	`}`	376	`}`
375		377
376		378
377	`static void toolbar_save_as_cb(GtkWidget *widget, gpointer data)`	379	`static void toolbar_save_as_cb(GtkWidget *widget, gpointer data)`
378	`{`	380	`{`
379	`NewDevDesc dd = (NewDevDesc) data;`	381	`NewDevDesc dd = (NewDevDesc) data;`
380	`gnomeDesc gd = (gnomeDesc) dd->deviceSpecific;`	382	`gnomeDesc gd = (gnomeDesc) dd->deviceSpecific;`
381		383
382	`GtkFileSelection *fsel =`	384	`GtkFileSelection *fsel =`
383	`GTK_FILE_SELECTION(gtk_file_selection_new("Save as PostScript"));`	385	`GTK_FILE_SELECTION(gtk_file_selection_new("Save as PostScript"));`
384		386
385	`gtk_object_set_user_data(GTK_OBJECT(fsel), dd);`	387	`gtk_object_set_user_data(GTK_OBJECT(fsel), dd);`
386	`gtk_file_selection_set_filename(fsel, "Rplots.ps");`	388	`gtk_file_selection_set_filename(fsel, "Rplots.ps");`
387		389
388	`gtk_signal_connect(GTK_OBJECT(fsel->ok_button), "clicked",`	390	`gtk_signal_connect(GTK_OBJECT(fsel->ok_button), "clicked",`
389	`GTK_SIGNAL_FUNC(save_ok), fsel);`	391	`GTK_SIGNAL_FUNC(save_ok), fsel);`
390	`gtk_signal_connect_object(GTK_OBJECT(fsel->cancel_button), "clicked",`	392	`gtk_signal_connect_object(GTK_OBJECT(fsel->cancel_button), "clicked",`
391	`GTK_SIGNAL_FUNC(gtk_widget_destroy),`	393	`GTK_SIGNAL_FUNC(gtk_widget_destroy),`
392	`GTK_OBJECT(fsel));`	394	`GTK_OBJECT(fsel));`
393		395
394		396
395	`gtk_window_position(GTK_WINDOW(fsel), GTK_WIN_POS_MOUSE);`	397	`gtk_window_position(GTK_WINDOW(fsel), GTK_WIN_POS_MOUSE);`
396	`gtk_window_set_transient_for(GTK_WINDOW(fsel), GTK_WINDOW(gd->window));`	398	`gtk_window_set_transient_for(GTK_WINDOW(fsel), GTK_WINDOW(gd->window));`
397	`gtk_widget_show(GTK_WIDGET(fsel));`	399	`gtk_widget_show(GTK_WIDGET(fsel));`
398	`}`	400	`}`
399		401
400	`static void toolbar_print_cb (GtkWidget *widget, gpointer data)`	402	`static void toolbar_print_cb (GtkWidget *widget, gpointer data)`
401	`{`	403	`{`
402	`NewDevDesc dd = (NewDevDesc) data;`	404	`NewDevDesc dd = (NewDevDesc) data;`
403	`gchar *cmd;`	405	`gchar *cmd;`
404		406
405	`cmd = g_strdup_printf("dev.set(%d)\ndev.print()",`	407	`cmd = g_strdup_printf("dev.set(%d)\ndev.print()",`
406	`RDeviceNumber(dd));`	408	`RDeviceNumber(dd));`
407	`R_gtk_terminal_run(cmd);`	409	`R_gtk_terminal_run(cmd);`
408	`g_free(cmd);`	410	`g_free(cmd);`
409	`}`	411	`}`
410		412
411	`static GnomeUIInfo graphics_toolbar[] =`	413	`static GnomeUIInfo graphics_toolbar[] =`
412	`{`	414	`{`
413	`{ GNOME_APP_UI_ITEM, "Activate", "Make this window the current device",`	415	`{ GNOME_APP_UI_ITEM, "Activate", "Make this window the current device",`
414	`(gpointer) toolbar_activate_cb, NULL, NULL, GNOME_APP_PIXMAP_STOCK,`	416	`(gpointer) toolbar_activate_cb, NULL, NULL, GNOME_APP_PIXMAP_STOCK,`
415	`GNOME_STOCK_PIXMAP_JUMP_TO, 0, (GdkModifierType) 0, NULL },`	417	`GNOME_STOCK_PIXMAP_JUMP_TO, 0, (GdkModifierType) 0, NULL },`
416	`GNOMEUIINFO_SEPARATOR,`	418	`GNOMEUIINFO_SEPARATOR,`
417	`{ GNOME_APP_UI_ITEM, "Save As", "Save as a PostScript file",`	419	`{ GNOME_APP_UI_ITEM, "Save As", "Save as a PostScript file",`
418	`(gpointer) toolbar_save_as_cb, NULL, NULL,`	420	`(gpointer) toolbar_save_as_cb, NULL, NULL,`
419	`GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_SAVE_AS, 0,`	421	`GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_SAVE_AS, 0,`
420	`(GdkModifierType) 0, NULL },`	422	`(GdkModifierType) 0, NULL },`
421	`{ GNOME_APP_UI_ITEM, "Print", "Print graphics",`	423	`{ GNOME_APP_UI_ITEM, "Print", "Print graphics",`
422	`(gpointer) toolbar_print_cb, NULL, NULL,`	424	`(gpointer) toolbar_print_cb, NULL, NULL,`
423	`GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_PRINT, 0,`	425	`GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_PRINT, 0,`
424	`(GdkModifierType) 0, NULL },`	426	`(GdkModifierType) 0, NULL },`
425	`GNOMEUIINFO_SEPARATOR,`	427	`GNOMEUIINFO_SEPARATOR,`
426	`{ GNOME_APP_UI_ITEM, "Close", "Close this graphics device",`	428	`{ GNOME_APP_UI_ITEM, "Close", "Close this graphics device",`
427	`(gpointer) toolbar_close_cb, NULL, NULL,`	429	`(gpointer) toolbar_close_cb, NULL, NULL,`
428	`GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_CLOSE, 0,`	430	`GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_CLOSE, 0,`
429	`(GdkModifierType) 0, NULL },`	431	`(GdkModifierType) 0, NULL },`
430	`GNOMEUIINFO_END`	432	`GNOMEUIINFO_END`
431	`};`	433	`};`
432		434
433	`static void GNOME_NewPage(int fill, double gamma, NewDevDesc *dd)`	435	`static void GNOME_NewPage(R_GE_gcontext *gc,`
-		436	`NewDevDesc *dd)`
434	`{`	437	`{`
435	`GnomeCanvasItem *group;`	438	`GnomeCanvasItem *group;`
436	`gnomeDesc gd = (gnomeDesc) dd->deviceSpecific;`	439	`gnomeDesc gd = (gnomeDesc) dd->deviceSpecific;`
437		440
438	`g_return_if_fail(gd->canvas);`	441	`g_return_if_fail(gd->canvas);`
439		442
440	`if (gd->group)`	443	`if (gd->group)`
441	`{`	444	`{`
442	`gtk_object_destroy(GTK_OBJECT(gd->group));`	445	`gtk_object_destroy(GTK_OBJECT(gd->group));`
443	`gd->plotarea = NULL;`	446	`gd->plotarea = NULL;`
444	`}`	447	`}`
445		448
446	`/* create group for plotting objects */`	449	`/* create group for plotting objects */`
447	`group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(gd->canvas)),`	450	`group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(gd->canvas)),`
448	`gnome_canvas_group_get_type(),`	451	`gnome_canvas_group_get_type(),`
449	`"x", (double) 0.0,`	452	`"x", (double) 0.0,`
450	`"y", (double) 0.0,`	453	`"y", (double) 0.0,`
451	`NULL);`	454	`NULL);`
452	`gd->group = GNOME_CANVAS_GROUP(group);`	455	`gd->group = GNOME_CANVAS_GROUP(group);`
453		456
454	`/* create plotting area */`	457	`/* create plotting area */`
455	`gd->plotarea =`	458	`gd->plotarea =`
456	`gnome_canvas_item_new (gd->group,`	459	`gnome_canvas_item_new (gd->group,`
457	`gnome_canvas_rect_get_type(),`	460	`gnome_canvas_rect_get_type(),`
458	`"x1", (double) 0.0,`	461	`"x1", (double) 0.0,`
459	`"y1", (double) 0.0,`	462	`"y1", (double) 0.0,`
460	`"x2", (double) gd->windowWidth,`	463	`"x2", (double) gd->windowWidth,`
461	`"y2", (double) gd->windowHeight,`	464	`"y2", (double) gd->windowHeight,`
462	`NULL);`	465	`NULL);`
463		466
464	`if (R_OPAQUE(fill))`	467	`if (R_OPAQUE(gc->fill))`
465	`{`	468	`{`
466	`gnome_canvas_item_set(gd->plotarea,`	469	`gnome_canvas_item_set(gd->plotarea,`
467	`"fill_color_rgba", Color_RGBA(fill),`	470	`"fill_color_rgba", Color_RGBA(gc->fill),`
468	`NULL);`	471	`NULL);`
469	`}`	472	`}`
470	`else`	473	`else`
471	`{`	474	`{`
472	`gnome_canvas_item_set(gd->plotarea,`	475	`gnome_canvas_item_set(gd->plotarea,`
473	`"fill_color", "white",`	476	`"fill_color", "white",`
474	`NULL);`	477	`NULL);`
475	`}`	478	`}`
476	`}`	479	`}`
477		480
478	`/* create window etc */`	481	`/* create window etc */`
479	`static Rboolean`	482	`static Rboolean`
480	`GNOME_Open(NewDevDesc dd, gnomeDesc gd, char *dsp, double w, double h)`	483	`GNOME_Open(NewDevDesc dd, gnomeDesc gd, char *dsp, double w, double h)`
481	`{`	484	`{`
482	`gint iw, ih;`	485	`gint iw, ih;`
-		486	`R_GE_gcontext gc;`
483		487
484	`/gdk_rgb_set_install(TRUE); /`	488	`/gdk_rgb_set_install(TRUE); /`
485	`/* gdk_rgb_set_verbose(TRUE);*/`	489	`/* gdk_rgb_set_verbose(TRUE);*/`
486	`gdk_rgb_init();`	490	`gdk_rgb_init();`
487	`gtk_widget_push_visual(gdk_rgb_get_visual());`	491	`gtk_widget_push_visual(gdk_rgb_get_visual());`
488	`gtk_widget_push_colormap(gdk_rgb_get_cmap());`	492	`gtk_widget_push_colormap(gdk_rgb_get_cmap());`
489		493
490	`/* initialise pointers */`	494	`/* initialise pointers */`
491	`gd->canvas = NULL;`	495	`gd->canvas = NULL;`
492	`gd->group = NULL;`	496	`gd->group = NULL;`
493	`gd->plotarea = NULL;`	497	`gd->plotarea = NULL;`
494		498
495	`if(!SetBaseFont(gd))`	499	`if(!SetBaseFont(gd))`
496	`{`	500	`{`

The R Project SVN R

(root)/trunk/src/modules/gnome/devGNOME.c @ 28362 – Rev 27117 → 27236