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

comparison src/glyphs-x.c @ 70:131b0175ea99 r20-0b30

Import from CVS: tag r20-0b30

author	cvs
date	Mon, 13 Aug 2007 09:02:59 +0200
parents	2e6f5e180fb8
children	54cc21c15cbb

comparison

equal deleted inserted replaced

-:804d1389bcd6
+:131b0175ea99
 #include "insdel.h"
 #include "opaque.h"
 #include "sysfile.h"
-#ifdef HAVE_PNG
-#include <png.h>
-#else
 #include <setjmp.h>
-#endif
 #define LISP_DEVICE_TO_X_SCREEN(dev)					\
 XDefaultScreenOfDisplay (DEVICE_X_DISPLAY (XDEVICE (dev)))
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (xbm);
 static void cursor_font_instantiate (Lisp_Object image_instance,
 				     Lisp_Object instantiator,
 				     Lisp_Object pointer_fg,
 				     Lisp_Object pointer_bg,
-				     int dest_mask,
+				     int dest_mask);
-				     Lisp_Object domain);
 #include "bitmaps.h"
 /************************************************************************/
 	  sprintf (buf, "/0x%lx", (unsigned long) IMAGE_INSTANCE_X_MASK (p));
 	  write_c_string (buf, printcharfun);
 	}
 write_c_string (")", printcharfun);
 break;
-#if HAVE_SUBWINDOWS
 case IMAGE_SUBWINDOW:
 /* #### implement me */
-#endif
 default:
 break;
 }
 }
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 if (IMAGE_INSTANCE_X_NPIXELS (p1) != IMAGE_INSTANCE_X_NPIXELS (p2))
 	return 0;
 break;
-#if HAVE_SUBWINDOWS
 case IMAGE_SUBWINDOW:
 /* #### implement me */
 break;
-#endif
 default:
 break;
 }
 return 1;
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 return IMAGE_INSTANCE_X_NPIXELS (p);
-#if HAVE_SUBWINDOWS
 case IMAGE_SUBWINDOW:
 /* #### implement me */
 return 0;
-#endif
 default:
 return 0;
 }
 }
 Display *display;
 /* Check non-absolute pathnames with a directory component relative to
 the search path; that's the way Xt does it. */
 /* #### Unix-specific */
-if (XSTRING_BYTE (name, 0) == '/' ||
+if (string_byte (XSTRING (name), 0) == '/' ||
-(XSTRING_BYTE (name, 0) == '.' &&
+(string_byte (XSTRING (name), 0) == '.' &&
-(XSTRING_BYTE (name, 1) == '/' ||
+(string_byte (XSTRING (name), 1) == '/' ||
-	(XSTRING_BYTE (name, 1) == '.' &&
+	(string_byte (XSTRING (name), 1) == '.' &&
-	 (XSTRING_BYTE (name, 2) == '/')))))
+	 (string_byte (XSTRING (name), 2) == '/')))))
 {
 if (!NILP (Ffile_readable_p (name)))
 	return name;
 else
 	return Qnil;
 static Lisp_Object
 simple_image_type_normalize (Lisp_Object inst, Lisp_Object console_type,
 			     Lisp_Object image_type_tag)
 {
-/* This function can call lisp */
 Lisp_Object file = Qnil;
 struct gcpro gcpro1, gcpro2;
 Lisp_Object alist = Qnil;
 GCPRO2 (file, alist);
 abort ();
 }
 }
 static int
-xbm_possible_dest_types (void)
+xbm_possible_dest_types ()
 {
-return
+return IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK |
-IMAGE_MONO_PIXMAP_MASK  |
-IMAGE_COLOR_PIXMAP_MASK |
 IMAGE_POINTER_MASK;
 }
 static void
 xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator,
 /* Instantiate method for XBM's. */
 static void
 xbm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		 int dest_mask, Lisp_Object domain)
+		 int dest_mask)
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 CONST char *gcc_go_home;
 assert (!NILP (data));
 **********************************************************************/
 #include "jpeglib.h"
 #include "jerror.h"
-/* 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_validate (Lisp_Object instantiator)
 {
 file_or_data_must_be_present (instantiator);
 }
 {
 return simple_image_type_normalize (inst, console_type, Qjpeg);
 }
 static int
-jpeg_possible_dest_types (void)
+jpeg_possible_dest_types ()
 {
 return IMAGE_COLOR_PIXMAP_MASK;
 }
 /* To survive the otherwise baffling complexity of making sure
 METHODDEF(boolean)
 #else
 METHODDEF boolean
 #endif
 our_fill_input_buffer (j_decompress_ptr cinfo) {
-/* Insert a fake EOI marker */
+ERREXIT(cinfo,JERR_INPUT_EOF);
-struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
+return FALSE;
-static JOCTET buffer[2];
-buffer[0] = (JOCTET) 0xFF;
-buffer[1] = (JOCTET) JPEG_EOI;
-src->next_input_byte = buffer;
-src->bytes_in_buffer = 2;
-return TRUE;
 }
 #if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
 METHODDEF(void)
 #else
 METHODDEF void
 #endif
 our_skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
-struct jpeg_source_mgr *src = NULL;
-src = (struct jpeg_source_mgr *) cinfo->src;
-if (!src) {
-return;
-} else if (num_bytes > src->bytes_in_buffer) {
-ERREXIT(cinfo, JERR_INPUT_EOF);
-/*NOTREACHED*/
-}
-src->bytes_in_buffer -= num_bytes;
-src->next_input_byte += num_bytes;
 }
 #if defined(JPEG_LIB_VERSION) && (JPEG_LIB_VERSION >= 61)
 METHODDEF(void)
 #else
 /* The code in this routine is based on example.c from the JPEG library
 source code and from gif_instantiate() */
 static void
 jpeg_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		  int dest_mask, Lisp_Object domain)
+		  int dest_mask)
 {
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 Display *dpy;
 Screen *scr;
 memset (&unwind, 0, sizeof (unwind));
 unwind.dpy = dpy;
 record_unwind_protect (jpeg_instantiate_unwind, make_opaque_ptr (&unwind));
-#ifdef USE_TEMP_FILES_FOR_JPEG_IMAGES
+#ifdef USE_TEMP_FILES_FOR_IMAGES
 /* Step 0: Write out to a temp file.
 The JPEG routines require you to read from a file unless
 you provide your own special input handlers, which I don't
 feel like doing. */
 jpeg_create_decompress (&cinfo);
 unwind.cinfo_ptr = &cinfo;
 /* Step 2: specify data source (eg, a file) */
-#ifdef USE_TEMP_FILES_FOR_JPEG_IMAGES
+#ifdef USE_FILEIO_FOR_IMAGES
 jpeg_stdio_src (&cinfo, unwind.instream);
 #else
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 Extbyte *bytes;
 {
 return simple_image_type_normalize (inst, console_type, Qgif);
 }
 static int
-gif_possible_dest_types (void)
+gif_possible_dest_types ()
 {
 return IMAGE_COLOR_PIXMAP_MASK;
 }
 /* To survive the otherwise baffling complexity of making sure
 }
 return Qnil;
 }
-#if 0
 /* We provide our own version of DGifSlurp() because the standardly
 provided one doesn't handle interlaced GIFs.  This is based on
 code in gif2x11.c. */
 /* Return value is GIF_ERROR, GIF_OK, or -1.
 				   &sp->RasterBits[(Row++) * Width + Col],
 				   Width) == GIF_ERROR)
 		    return GIF_ERROR;
 		}
 	    }
-	  /* Only get 1 image from animated gifs. */
-	  /* #### if the rest of the file was bad, we still return
-	     GIF_OK, since we don't even bother looking at it.  Should
-	     probably check for ImageCount == 1 above too, hmm. */
-	  goto done;
 	  break;
 	case EXTENSION_RECORD_TYPE:
 	  /* Skip any extension blocks in file: */
 	  if (DGifGetExtension (GifFile, &ExtCode, &Extension) == GIF_ERROR)
 	  break;
 	}
 }
 while (RecordType != TERMINATE_RECORD_TYPE);
-done:
 return GIF_OK;
 }
-#endif
 static void
 gif_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		 int dest_mask, Lisp_Object domain)
+		 int dest_mask)
 {
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 Display *dpy;
 Screen *scr;
 {
 gif_decode_error:
 	signal_simple_error ("Unable to decode GIF",
 			     build_string (EmacsPrintGifError ()));
 }
-#if 0
+#if 1
 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 height = unwind.giffile->SHeight;
 int width = unwind.giffile->SWidth;
 int depth;
 int bitmap_pad;
-int i, j, row, pass, interlace;
+int i, j;
-/* 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)
 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
-	|| unwind.giffile->SavedImages[0].ImageDesc.Left != 0
-	|| unwind.giffile->SavedImages[0].ImageDesc.Top != 0)
-signal_simple_error ("First image in GIF file is not full size",
-			   instantiator);
-interlace = unwind.giffile->SavedImages[0].ImageDesc.Interlace;
-pass = 0;
-row = interlace ? InterlacedOffset[pass] : 0;
 for (i = 0; i < height; i++)
-{
+for (j = 0; j < width; j++)
-	if (interlace && row >= height)
+	XPutPixel (unwind.ximage, j, i,
-	  row = InterlacedOffset[++pass];
+		   unwind.pixels[(unsigned char)
+				 /* incorrect signed declaration
-	for (j = 0; j < width; j++)
+				    of RasterBits[] */
-	  XPutPixel (unwind.ximage, j, row,
+				 (unwind.giffile->SavedImages->
-		     unwind.pixels[(unsigned char)
+				  RasterBits[i * width + j])]);
-				  /* incorrect signed declaration
-				     of RasterBits[] */
-				  (unwind.giffile->SavedImages[0].
-				   RasterBits[i * width + j])]);
-	row += interlace ? InterlacedJumps[pass] : 1;
-}
 }
 /* 4. Now create the pixmap and set up the image instance */
 init_image_instance_from_x_image (ii, unwind.ximage, dest_mask,
 				    unwind.pixels, unwind.npixels,
 #endif /* HAVE_GIF */
 #ifdef HAVE_PNG
+#include <png.h>
 /**********************************************************************
 *                             PNG                                    *
 **********************************************************************/
 static void
 png_validate (Lisp_Object instantiator)
 {
 return simple_image_type_normalize (inst, console_type, Qpng);
 }
 static int
-png_possible_dest_types (void)
+png_possible_dest_types ()
 {
 return IMAGE_COLOR_PIXMAP_MASK;
 }
 #if !defined (USE_TEMP_FILES_FOR_IMAGES) && (PNG_LIBPNG_VER >= 87)
 #endif
 static void
 png_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		 int dest_mask, Lisp_Object domain)
+		 int dest_mask)
 {
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 Display *dpy;
 Screen *scr;
 signal_simple_error ("No TIFF support yet", inst);
 return Qnil;
 }
 static int
-tiff_possible_dest_types (void)
+tiff_possible_dest_types ()
 {
 return IMAGE_COLOR_PIXMAP_MASK;
 }
 static void
 tiff_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		  int dest_mask, Lisp_Object domain)
+		  int dest_mask)
 {
 abort ();
 }
 #endif /* HAVE_TIFF */
 RETURN_UNGCPRO (result);
 }
 }
 static int
-xpm_possible_dest_types (void)
+xpm_possible_dest_types ()
 {
-return
+return IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK |
-IMAGE_MONO_PIXMAP_MASK  |
-IMAGE_COLOR_PIXMAP_MASK |
 IMAGE_POINTER_MASK;
 }
 /* xpm 3.2g and better has XpmCreatePixmapFromBuffer()...
 There was no version number in xpm.h before 3.3, but this should do.
 Upgrade to version 3.2g or better or compile with --with-xpm=no.
 #endif /* !XPM_DOES_BUFFERS */
 static XpmColorSymbol *
 extract_xpm_color_names (XpmAttributes *xpmattrs, Lisp_Object device,
-			 Lisp_Object domain,
 			 Lisp_Object color_symbol_alist)
 {
 /* This function can GC */
 Screen *xs = LISP_DEVICE_TO_X_SCREEN (device);
 Display *dpy = DisplayOfScreen (xs);
 	  Fmake_color_instance
 	    (value, device, encode_error_behavior_flag (ERROR_ME_NOT));
 else
 {
 assert (COLOR_SPECIFIERP (value));
-value = Fspecifier_instance (value, domain, Qnil, Qnil);
+value = Fspecifier_instance (value, device, Qnil, Qnil);
 }
 if (NILP (value))
 continue;
 results = noseeum_cons (noseeum_cons (name, value), results);
 i++;
 }
 static void
 xpm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		 int dest_mask, Lisp_Object domain)
+		 int dest_mask)
 {
 /* This function can GC */
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 {
 xpmattrs.closeness = 65535;
 xpmattrs.valuemask |= XpmCloseness;
 }
-color_symbols = extract_xpm_color_names (&xpmattrs, device, domain,
+color_symbols = extract_xpm_color_names (&xpmattrs, device,
 					   color_symbol_alist);
 result = XpmCreatePixmapFromBuffer (dpy,
 				      RootWindowOfScreen (xs),
 				      (char *) XSTRING_DATA (data),
 }
 static Lisp_Object
 xface_normalize (Lisp_Object inst, Lisp_Object console_type)
 {
-/* 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);
 RETURN_UNGCPRO (result);
 }
 }
 static int
-xface_possible_dest_types (void)
+xface_possible_dest_types ()
 {
-return
+return IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK |
-IMAGE_MONO_PIXMAP_MASK  |
-IMAGE_COLOR_PIXMAP_MASK |
 IMAGE_POINTER_MASK;
 }
 #if defined(EXTERN)
 /* This is about to get redefined! */
 #undef SYSV32
 static void
 xface_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		   Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		   int dest_mask, Lisp_Object domain)
+		   int dest_mask)
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 int i, stattis;
 char *p, *bits, *bp;
 CONST char * volatile emsg = 0;
 RETURN_UNGCPRO (result);
 }
 }
 static int
-autodetect_possible_dest_types (void)
+autodetect_possible_dest_types ()
 {
-return
+return IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK |
-IMAGE_MONO_PIXMAP_MASK  |
+IMAGE_POINTER_MASK | IMAGE_TEXT_MASK;
-IMAGE_COLOR_PIXMAP_MASK |
-IMAGE_POINTER_MASK      |
-IMAGE_TEXT_MASK;
 }
 static void
 autodetect_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 			Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-			int dest_mask, Lisp_Object domain)
+			int dest_mask)
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 struct gcpro gcpro1, gcpro2, gcpro3;
 Lisp_Object alist = Qnil;
 Lisp_Object result = Qnil;
 result = alist_to_tagged_vector (Qstring, alist);
 free_alist (alist);
 if (is_cursor_font)
 cursor_font_instantiate (image_instance, result, pointer_fg,
-			     pointer_bg, dest_mask, domain);
+			     pointer_bg, dest_mask);
 else
 string_instantiate (image_instance, result, pointer_fg,
-			pointer_bg, dest_mask, domain);
+			pointer_bg, dest_mask);
 UNGCPRO;
 }
 if (XLoadFont_got_error) return 0;
 return font;
 }
 static int
-font_possible_dest_types (void)
+font_possible_dest_types ()
 {
 return IMAGE_POINTER_MASK;
 }
 static void
 font_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-		  int dest_mask, Lisp_Object domain)
+		  int dest_mask)
 {
 /* This function can GC */
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 {
 data_must_be_present (instantiator);
 }
 static int
-cursor_font_possible_dest_types (void)
+cursor_font_possible_dest_types ()
 {
 return IMAGE_POINTER_MASK;
 }
 static void
 cursor_font_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 			 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
-			 int dest_mask, Lisp_Object domain)
+			 int dest_mask)
 {
 /* This function can GC */
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 return 1;
 }
 }
-#if HAVE_SUBWINDOWS
 /************************************************************************/
 /*                               subwindows                             */
 /************************************************************************/
 Lisp_Object Qsubwindowp;
 /* #### PROBLEM: The display routines assume that the glyph is only
 being displayed in one buffer.  If it is in two different buffers
 which are both being displayed simultaneously you will lose big time.
 This can be dealt with in the new redisplay. */
-/* #### These are completely un-re-implemented in 19.16.  Get it done
+/* #### These are completely un-re-implemented in 19.14.  Get it done
-for 20.3. */
+for 19.15. */
 DEFUN ("make-subwindow", Fmake_subwindow, 0, 3, 0, /*
 Creates a new `subwindow' object of size WIDTH x HEIGHT.
 The default is a window of size 1x1, which is also the minimum allowed
 window size.  Subwindows are per-frame.  A buffer being shown in two
 struct frame *f;
 unsigned int iw, ih;
 XSetWindowAttributes xswa;
 Mask valueMask = 0;
-error ("subwindows are not functional in 19.16; perhaps some day ...");
+error ("subwindows are not functional in 19.14; they will be in 19.15");
 f = decode_x_frame (frame);
 xs = LISP_DEVICE_TO_X_SCREEN (FRAME_DEVICE (f));
 dpy = DisplayOfScreen (xs);
 XMapWindow (DisplayOfScreen (XSUBWINDOW (subwindow)->xscreen),
 	      XSUBWINDOW (subwindow)->subwindow);
 return subwindow;
 }
-#endif
 /************************************************************************/
 /*                            initialization                            */
 /************************************************************************/
 void
 syms_of_glyphs_x (void)
 {
-#if HAVE_SUBWINDOWS
 defsymbol (&Qsubwindowp, "subwindowp");
 DEFSUBR (Fmake_subwindow);
 DEFSUBR (Fchange_subwindow_property);
 DEFSUBR (Fsubwindowp);
 DEFSUBR (Fsubwindow_width);
 DEFSUBR (Fsubwindow_height);
 DEFSUBR (Fsubwindow_xid);
 DEFSUBR (Fresize_subwindow);
 DEFSUBR (Fforce_subwindow_map);
-#endif
 defkeyword (&Q_mask_file, ":mask-file");
 defkeyword (&Q_mask_data, ":mask-data");
 defkeyword (&Q_hotspot_x, ":hotspot-x");
 defkeyword (&Q_hotspot_y, ":hotspot-y");
 Qglobal, Qx, Qnil)
 BUILD_GLYPH_INST (Vtruncation_glyph, truncator);
 BUILD_GLYPH_INST (Vcontinuation_glyph, continuer);
 BUILD_GLYPH_INST (Vxemacs_logo, xemacs);
-BUILD_GLYPH_INST (Vhscroll_glyph, hscroll);
 #undef BUILD_GLYPH_INST
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs-x.c @ 70:131b0175ea99 r20-0b30