xemacs-beta: src/glyphs-x.c comparison

comparison src/glyphs-x.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	e121b013d1f0
children	169c0442b401

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 /* Original author: Jamie Zawinski for 19.8
 font-truename stuff added by Jamie Zawinski for 19.10
 subwindow support added by Chuck Thompson
 additional XPM support added by Chuck Thompson
 initial X-Face support added by Stig
 rewritten/restructured by Ben Wing for 19.12/19.13
 GIF/JPEG support added by Ben Wing for 19.14
 PNG support added by Bill Perry for 19.14
 Improved GIF/JPEG support added by Bill Perry for 19.14
 Cleanup/simplification of error handling by Ben Wing for 19.14
 Pointer/icon overhaul, more restructuring by Ben Wing for 19.14
 #include "opaque.h"
 #include "sysfile.h"
 #ifdef HAVE_PNG
+#ifdef __cplusplus
+extern "C" {
+#endif
 #include <png.h>
+#ifdef __cplusplus
+}
+#endif
 #else
 #include <setjmp.h>
 #endif
 #define LISP_DEVICE_TO_X_SCREEN(dev)					\
 static void
 x_initialize_pixmap_image_instance (struct Lisp_Image_Instance *ii,
 				    enum image_instance_type type)
 {
-ii->data = malloc_type_and_zero (struct x_image_instance_data);
+ii->data = xnew_and_zero (struct x_image_instance_data);
 IMAGE_INSTANCE_TYPE (ii) = type;
 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = Qnil;
 IMAGE_INSTANCE_PIXMAP_MASK_FILENAME (ii) = Qnil;
 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = Qnil;
 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = Qnil;
 {
 Lisp_Object file;
 Lisp_Object data;
 assert (VECTORP (instantiator));
 data = find_keyword_in_vector (instantiator, data_keyword);
 file = find_keyword_in_vector (instantiator, file_keyword);
 if (!NILP (file) && NILP (data))
 {
 {
 /* This function can call lisp */
 Lisp_Object file = Qnil;
 struct gcpro gcpro1, gcpro2;
 Lisp_Object alist = Qnil;
 GCPRO2 (file, alist);
 /* Now, convert any file data into inline data.  At the end of this,
 `data' will contain the inline data (if any) or Qnil, and `file'
 will contain the name this data was derived from (if known) or
 write_lisp_string_to_temp_file (Lisp_Object string, char *filename_out)
 {
 Extbyte *bytes;
 Extcount len;
 FILE *stream;
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Need to be able to convert and
 write out to a file. */
 GET_STRING_BINARY_DATA_ALLOCA (string, bytes, len);
 else
 {
 xfg->pixel = 0;
 xfg->red = xfg->green = xfg->blue = 0;
 }
 if (!NILP (*background) && !COLOR_INSTANCEP (*background))
 *background =
 Fmake_color_instance (*background, device,
 			    encode_error_behavior_flag (ERROR_ME));
 if (COLOR_INSTANCEP (*background))
 d = RootWindowOfScreen (xs);
 if (!(dest_mask & IMAGE_COLOR_PIXMAP_MASK))
 incompatible_image_types (instantiator, dest_mask,
 			      IMAGE_COLOR_PIXMAP_MASK);
 pixmap = XCreatePixmap (dpy, d, ximage->width,
 			  ximage->height, ximage->depth);
 if (!pixmap)
 signal_simple_error ("Unable to create pixmap", instantiator);
 if (!gc)
 {
 XFreePixmap (dpy, pixmap);
 signal_simple_error ("Unable to create GC", instantiator);
 }
 XPutImage (dpy, pixmap, gc, ximage, 0, 0, 0, 0,
 	     ximage->width, ximage->height);
 XFreeGC (dpy, gc);
 x_initialize_pixmap_image_instance (ii, IMAGE_COLOR_PIXMAP);
 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) =
 find_keyword_in_vector (instantiator, Q_file);
 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap;
 IMAGE_INSTANCE_X_MASK (ii) = 0;
 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = ximage->width;
 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = ximage->height;
 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = ximage->depth;
 -- if OK_IF_DATA_INVALID is set and the data was invalid,
 return Qt.
 -- maybe return an error, or return Qnil.
 */
 static Lisp_Object
 bitmap_to_lisp_data (Lisp_Object name, int *xhot, int *yhot,
 		     int ok_if_data_invalid)
 {
 xbm_normalize (Lisp_Object inst, Lisp_Object console_type)
 {
 Lisp_Object file = Qnil, mask_file = Qnil;
 struct gcpro gcpro1, gcpro2, gcpro3;
 Lisp_Object alist = Qnil;
 GCPRO3 (file, mask_file, alist);
 /* Now, convert any file data into inline data for both the regular
 data and the mask data.  At the end of this, `data' will contain
 the inline data (if any) or Qnil, and `file' will contain
 /**********************************************************************
 *                             JPEG                                   *
 **********************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
 #include <jpeglib.h>
 #include <jerror.h>
+#ifdef __cplusplus
+}
+#endif
 /* The in-core jpeg code doesn't work, so I'm avoiding it for now.  -sb  */
 /* Late-breaking update, we're going to give it a try, I think it's */
 /* fixed now -sb */
 /*#define USE_TEMP_FILES_FOR_JPEG_IMAGES 1*/
 static void
 jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, unsigned int len)
 {
 struct jpeg_source_mgr *src = NULL;
 if (cinfo->src == NULL) {	/* first time for this JPEG object? */
 cinfo->src = (struct jpeg_source_mgr *)
 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
 				  sizeof(our_jpeg_source_mgr));
 src = (struct jpeg_source_mgr *) cinfo->src;
 if ((unwind.instream = fopen (unwind.tempfile, "r")) == NULL)
 report_file_error ("Opening JPEG temp file",
 			 list1 (build_string (unwind.tempfile)));
 }
 #endif
 /* Step 1: allocate and initialize JPEG decompression object */
 /* We set up the normal JPEG error routines, then override error_exit. */
 cinfo.err = jpeg_std_error (&jerr.pub);
 jerr.pub.error_exit = my_jpeg_error_exit;
 */
 {
 	Lisp_Object errstring;
 	char buffer[JMSG_LENGTH_MAX];
 	/* Create the message */
 	(*cinfo.err->format_message) ((j_common_ptr) &cinfo, buffer);
 	errstring = build_string (buffer);
 	signal_simple_error_2 ("JPEG decoding error",
 			       errstring, instantiator);
 }
 }
 #else
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 Extbyte *bytes;
 Extcount len;
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Need to be able to convert and
 write out to a file. */
 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 jpeg_memory_src (&cinfo, bytes, len);
 {
 int i;
 /* Just in case the image contains out-of-range pixels, we go
 ahead and allocate space for all of them. */
-unwind.pixels = (unsigned long *) xmalloc (256 * sizeof (unsigned long));
+unwind.pixels = xnew_array (unsigned long, 256);
 unwind.npixels = cinfo.actual_number_of_colors;
 for (i = 0; i < 256; i++)
 unwind.pixels[i] = 0;   /* Use a reasonable color for out of range. */
 {
 int height = cinfo.output_height;
 int width = cinfo.output_width;
 int depth;
 int bitmap_pad;
 depth = DefaultDepthOfScreen (scr);
 /* first get bitmap_pad (from XPM) */
-if (depth > 16)
+bitmap_pad = ((depth > 16) ? 32 :
-bitmap_pad = 32;
+		  (depth >  8) ? 16 :
-else if (depth > 8)
+		  8);
-bitmap_pad = 16;
-else
-bitmap_pad = 8;
 unwind.ximage = XCreateImage (dpy, DefaultVisualOfScreen (scr),
 				  depth, ZPixmap, 0, 0, width, height,
 				  bitmap_pad, 0);
 if (!unwind.ximage)
 /* We may need to do some setup of our own at this point before reading
 * the data.  After jpeg_start_decompress() we have the correct scaled
 * output image dimensions available, as well as the output colormap
 * if we asked for color quantization.
 * In this example, we need to make an output work buffer of the right size.
 */
 /* JSAMPLEs per row in output buffer.
 Since we asked for quantized output, cinfo.output_components
 will always be 1. */
 row_stride = cinfo.output_width * cinfo.output_components;
 /* Make a one-row-high sample array that will go away when done
 with image */
 row_buffer = ((*cinfo.mem->alloc_sarray)
 		  ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1));
 /* Here we use the library's state variable cinfo.output_scanline as the
 * loop counter, so that we don't have to keep track ourselves.
 */
 while (cinfo.output_scanline < cinfo.output_height)
 {
 static int InterlacedJumps[] = { 8, 8, 4, 2 };
 GifPixelType *ScreenBuffer =
 (GifPixelType *) xmalloc (GifFile->SHeight * GifFile->SWidth *
 			      sizeof (GifPixelType));
-GifFile->SavedImages = (SavedImage *) xmalloc (sizeof(SavedImage));
+GifFile->SavedImages = xnew (SavedImage);
 for (i = 0; i < GifFile->SHeight * GifFile->SWidth; i++)
 ScreenBuffer[i] = GifFile->SBackGroundColor;
 /* Scan the content of the GIF file and load the image(s) in: */
 	      GifFile->Image.Top + GifFile->Image.Height > GifFile->SHeight)
 	    return -1;
 	  sp->RasterBits = (GifPixelType*) xmalloc(Width * Height *
 						   sizeof (GifPixelType));
 	  if (GifFile->Image.Interlace)
 	    {
 	      /* Need to perform 4 passes on the images: */
 	      for (Count = i = 0; i < 4; i++)
 		for (j = Row + InterlacedOffset[i]; j < Row + Height;
 }
 #if 0
 if (our_own_dgif_slurp_from_gif2x11_c(unwind.giffile) != GIF_OK)
 #else
 /* DGifSlurp() doesn't handle interlaced files. */
 /* Actually, it does, sort of.  It just sets the Interlace flag
 and stores RasterBits in interlaced order.  We handle that below. */
 if (DGifSlurp (unwind.giffile) != GIF_OK)
 #endif
 goto gif_decode_error;
 }
 {
 int i;
 ColorMapObject *cmap = unwind.giffile->SColorMap;
 /* Just in case the image contains out-of-range pixels, we go
 ahead and allocate space for all of them. */
-unwind.pixels = (unsigned long *) xmalloc (256 * sizeof (unsigned long));
+unwind.pixels = xnew_array (unsigned long, 256);
 unwind.npixels = cmap->ColorCount;
 for (i = 0; i < 256; i++)
 unwind.pixels[i] = 0;   /* Use a reasonable color for out of range. */
 /* interlaced gifs have rows in this order:
 0, 8, 16, ..., 4, 12, 20, ..., 2, 6, 10, ..., 1, 3, 5, ...  */
 static int InterlacedOffset[] = { 0, 4, 2, 1 };
 static int InterlacedJumps[] = { 8, 8, 4, 2 };
 depth = DefaultDepthOfScreen (scr);
 /* first get bitmap_pad (from XPM) */
-if (depth > 16)
+bitmap_pad = ((depth > 16) ? 32 :
-bitmap_pad = 32;
+		  (depth >  8) ? 16 :
-else if (depth > 8)
+		  8);
-bitmap_pad = 16;
-else
-bitmap_pad = 8;
 unwind.ximage = XCreateImage (dpy, DefaultVisualOfScreen (scr),
 				  depth, ZPixmap, 0, 0, width, height,
 				  bitmap_pad, 0);
 if (!unwind.ximage)
 stuff; but it's doubtful that this will be faster in the
 long run, what with all the XPM overhead.  If this proves
 to be a bottleneck here, maybe we should just copy the
 optimization routines from XPM (they're in turn mostly
 copied from the Xlib source code). */
 /* Note: We just use the first image in the file and ignore the rest.
 We check here that that image covers the full "screen" size.
 	     I don't know whether that's always the case.
 -dkindred@cs.cmu.edu  */
 if (unwind.giffile->SavedImages[0].ImageDesc.Height != height
 	|| unwind.giffile->SavedImages[0].ImageDesc.Width != width
 signal_simple_error ("Not an X device", device);
 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
 scr = DefaultScreenOfDisplay (dpy);
-png_ptr = (png_struct *) xmalloc (sizeof (png_struct));
+png_ptr  = xnew (png_struct);
-info_ptr = (png_info *) xmalloc (sizeof (png_info));
+info_ptr = xnew (png_info);
 memset (&unwind, 0, sizeof (unwind));
 unwind.png_ptr = png_ptr;
 unwind.info_ptr = info_ptr;
 unwind.dpy = dpy;
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 Extbyte *bytes;
 Extcount len;
 struct png_memory_storage tbr; /* Data to be read */
 assert (!NILP (data));
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Need to be able to convert and
 write out to a file. */
 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 tbr.bytes = bytes;
 png_byte *png_pixels;
 png_byte **row_pointers;
 png_color static_color_cube[216];
 /* Wow, allocate all the memory.  Truly, exciting. */
-unwind.pixels = (unsigned long *) xmalloc (256 * sizeof (unsigned long));
+unwind.pixels = xnew_array (unsigned long, 256);
-png_pixels = (png_byte *) xmalloc (linesize * height * sizeof (png_byte*));
+png_pixels    = xnew_array (png_byte, linesize * height);
-row_pointers = (png_byte **) xmalloc (height * sizeof (png_byte *));
+row_pointers  = xnew_array (png_byte *, height);
 for (y = 0; y < 256; y++)
 unwind.pixels[y] = 0;
 for (y = 0; y < height; y++)
 row_pointers[y] = png_pixels + (linesize * y);
 	  {
 	    png_set_dither (png_ptr, info_ptr->palette, info_ptr->num_palette,
 			    info_ptr->num_palette, info_ptr->hist, 1);
 	  }
 }
 png_read_image (png_ptr, row_pointers);
 png_read_end (png_ptr, info_ptr);
 /* Ok, now we go and allocate all the colors */
 if (info_ptr->valid & PNG_INFO_PLTE)
 	}
 }
 #endif
 /* Now create the image */
 depth = DefaultDepthOfScreen (scr);
 /* first get bitmap_pad (from XPM) */
-if (depth > 16)
+bitmap_pad = ((depth > 16) ? 32 :
-bitmap_pad = 32;
+		  (depth >  8) ? 16 :
-else if (depth > 8)
+		  8);
-bitmap_pad = 16;
-else
-bitmap_pad = 8;
 unwind.ximage = XCreateImage (dpy, DefaultVisualOfScreen (scr),
 				  depth, ZPixmap, 0, 0, width, height,
 				  bitmap_pad, 0);
 if (!unwind.ximage)
 for (i = 0; i < height; i++)
 	for (j = 0; j < width; j++)
 	  XPutPixel (unwind.ximage, j, i,
 		     unwind.pixels[png_pixels[i * width + j]]);
 }
 xfree (row_pointers);
 xfree (png_pixels);
 }
 init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
 static void
 check_valid_xpm_color_symbols (Lisp_Object data)
 {
 Lisp_Object rest;
 for (rest = data; !NILP (rest); rest = XCDR (rest))
 {
 if (!CONSP (rest) ||
 	  !CONSP (XCAR (rest)) ||
 	  !STRINGP (XCAR (XCAR (rest))) ||
 {
 Lisp_Object file = Qnil;
 Lisp_Object color_symbols;
 struct gcpro gcpro1, gcpro2;
 Lisp_Object alist = Qnil;
 GCPRO2 (file, alist);
 /* Now, convert any file data into inline data.  At the end of this,
 `data' will contain the inline data (if any) or Qnil, and
 `file' will contain the name this data was derived from (if
 }
 UNGCPRO;			/* no more evaluation */
 if (i == 0) return 0;
-symbols = (XpmColorSymbol *) xmalloc (i * sizeof (XpmColorSymbol));
+symbols = xnew_array (XpmColorSymbol, i);
 xpmattrs->valuemask |= XpmColorSymbols;
 xpmattrs->colorsymbols = symbols;
 xpmattrs->numsymbols = i;
 while (--i >= 0)
 else
 {
 xpmattrs.closeness = 65535;
 xpmattrs.valuemask |= XpmCloseness;
 }
 color_symbols = extract_xpm_color_names (&xpmattrs, device, domain,
 					   color_symbol_alist);
 result = XpmCreatePixmapFromBuffer (dpy,
 				      RootWindowOfScreen (xs),
 w = xpmattrs.width;
 h = xpmattrs.height;
 {
 int npixels = xpmattrs.npixels;
-Pixel *pixels = 0;
+Pixel *pixels;
 if (npixels != 0)
 {
-	pixels = xmalloc (npixels * sizeof (Pixel));
+	pixels = xnew_array (Pixel, npixels);
 	memcpy (pixels, xpmattrs.pixels, npixels * sizeof (Pixel));
 }
 else
-pixels = 0;
+pixels = NULL;
 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap;
 IMAGE_INSTANCE_X_MASK (ii) = mask;
 IMAGE_INSTANCE_X_PIXELS (ii) = pixels;
 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels;
 	  {
 	    /* With an XBM file, it's obvious which bit is foreground
 	       and which is background, or rather, it's implicit: in
 	       an XBM file, a 1 bit is foreground, and a 0 bit is
 	       background.
 	       XCreatePixmapCursor() assumes this property of the
 	       pixmap it is called with as well; the `foreground'
 	       color argument is used for the 1 bits.
 	       With an XPM file, it's tricker, since the elements of
 	       pixel values.  So we need to figure out which of those
 	       pixels is the foreground color and which is the
 	       background.  We do it by comparing RGB and assuming
 	       that the darker color is the foreground.  This works
 	       with the result of xbmtopbm|ppmtoxpm, at least.
 	       It might be nice if there was some way to tag the
 	       colors in the XPM file with whether they are the
 	       foreground - perhaps with logical color names somehow?
 	       Once we have decided which color is the foreground, we
 	       need to ensure that that color corresponds to a `1' bit
 	       in the Pixmap.  The XPM library wrote into the (1-bit)
 	       pixmap with XPutPixel, which will ignore all but the
 	       least significant bit.
 	       This means that a 1 bit in the image corresponds to
 	       `fg' only if `fg.pixel' is odd.
 	       (This also means that the image will be all the same
 	       color if both `fg' and `bg' are odd or even, but we can
 	       safely assume that that won't happen if the XPM file is
 	       sensible I think.)
 	       The desired result is that the image use `1' to
 	       represent the foreground color, and `0' to represent
 	       the background color.  So, we may need to invert the
 	       image to accomplish this; we invert if fg is
 	       odd. (Remember that WhitePixel and BlackPixel are not
 		  swap = fg;
 		  fg = bg;
 		  bg = swap;
 		}
 	    }
 	    /* If the fg pixel corresponds to a `0' in the bitmap, invert it.
 	       (This occurs (only?) on servers with Black=0, White=1.)
 	       */
 	    if ((fg.pixel & 1) == 0)
 	      {
 break;
 default:
 abort ();
 }
 xpm_free (&xpmattrs);	/* after we've read pixels and hotspot */
 }
 #endif /* HAVE_XPM */
 {
 /* This funcation can call lisp */
 Lisp_Object file = Qnil, mask_file = Qnil;
 struct gcpro gcpro1, gcpro2, gcpro3;
 Lisp_Object alist = Qnil;
 GCPRO3 (file, mask_file, alist);
 /* Now, convert any file data into inline data for both the regular
 data and the mask data.  At the end of this, `data' will contain
 the inline data (if any) or Qnil, and `file' will contain
 #undef EXTERN
 #endif
 /* We have to define SYSV32 so that compface.h includes string.h
 instead of strings.h. */
 #define SYSV32
+#ifdef __cplusplus
+extern "C" {
+#endif
 #include <compface.h>
+#ifdef __cplusplus
+}
+#endif
 /* JMP_BUF cannot be used here because if it doesn't get defined
 to jmp_buf we end up with a conflicting type error with the
 definition in compface.h */
 extern jmp_buf comp_env;
 #undef SYSV32
 /* #### Apparently some versions of XpmReadFileToData, which is
 	 called by pixmap_to_lisp_data, don't return an error value
 	 if the given file is not a valid XPM file.  Instead, they
 	 just seg fault.  It is definitely caused by passing a
 	 bitmap.  To try and avoid this we check for bitmaps first.  */
 data = bitmap_to_lisp_data (filename, &xhot, &yhot, 1);
 if (!EQ (data, Qt))
 	{
 	  alist = remassq_no_quit (Q_data, alist);
 write_c_string (buf, printcharfun);
 /* This is stolen from frame.c.  Subwindows are strange in that they
 are specific to a particular frame so we want to print in their
 description what that frame is. */
 write_c_string (" on #<", printcharfun);
 if (!FRAME_LIVE_P (frm))
 write_c_string ("dead", printcharfun);
 else if (FRAME_TTY_P (frm))
 write_c_string ("tty", printcharfun);
 ih = XINT (height);
 if (ih < 1) ih = 1;
 }
 {
-struct Lisp_Subwindow *sw = alloc_lcrecord (sizeof (struct Lisp_Subwindow),
+struct Lisp_Subwindow *sw =
-						lrecord_subwindow);
+alloc_lcrecord_type (struct Lisp_Subwindow, lrecord_subwindow);
 Lisp_Object val;
 sw->frame = frame;
 sw->xscreen = xs;
 sw->parent_window = pw;
 sw->height = ih;
 IIFORMAT_HAS_METHOD (png, instantiate);
 IIFORMAT_VALID_KEYWORD (png, Q_data, check_valid_string);
 IIFORMAT_VALID_KEYWORD (png, Q_file, check_valid_string);
 #endif
 #ifdef HAVE_TIFF
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (tiff, "tiff");
 IIFORMAT_HAS_METHOD (tiff, validate);
 IIFORMAT_HAS_METHOD (tiff, normalize);
 IIFORMAT_VALID_KEYWORD (xface, Q_file, check_valid_string);
 IIFORMAT_VALID_KEYWORD (xface, Q_hotspot_x, check_valid_int);
 IIFORMAT_VALID_KEYWORD (xface, Q_hotspot_y, check_valid_int);
 IIFORMAT_VALID_KEYWORD (xface, Q_foreground, check_valid_string);
 IIFORMAT_VALID_KEYWORD (xface, Q_background, check_valid_string);
 #endif
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (autodetect,
 					"autodetect");
 IIFORMAT_HAS_METHOD (autodetect, validate);
 #endif
 #ifdef HAVE_PNG
 Fprovide (Qpng);
 #endif
 #ifdef HAVE_TIFF
 Fprovide (Qtiff);
 #endif
 #ifdef HAVE_XPM
 The default value of this variable defines the logical color names
 \"foreground\" and \"background\" to be the colors of the `default' face.
 */ );
 Vxpm_color_symbols = Qnil; /* initialized in x-faces.el */
 #endif
 #ifdef HAVE_XFACE
 Fprovide (Qxface);
 #endif
 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path /*
 A list of the directories in which X bitmap files may be found.
-If nil, this is initialized from the \"*bitmapFilePath\" resource.
+If nil, this is initialized from the "*bitmapFilePath" resource.
 This is used by the `make-image-instance' function (however, note that if
 the environment variable XBMLANGPATH is set, it is consulted first).
 */ );
 Vx_bitmap_file_path = Qnil;
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs-x.c @ 185:3d6bfa290dbd r20-3b19