emacs: src/macfns.c comparison

comparison src/macfns.c @ 47278:fc811b81d1a3

(Fx_server_max_request_size): Fix spacing.

author	Juanma Barranquero <lekktu@gmail.com>
date	Fri, 06 Sep 2002 09:04:22 +0000
parents	e92a6d6dd53f
children	755c4233cfba

comparison

equal deleted inserted replaced

-:8a4e82b00f6f
+:fc811b81d1a3
 	(insert (substring (car symbol-list) 1))
 	(subst-char-in-region start (point) ?_ ?-))
 (insert (format "\");\n  staticpro (&%s);\n" (car symbol-list)))
 (setq symbol-list (cdr symbol-list)))))
 */
 /*&&& symbols declared here &&&*/
 Lisp_Object Qauto_raise;
 Lisp_Object Qauto_lower;
 Lisp_Object Qborder_color;
 error ("Mac OS not in use or not initialized");
 }
 /* Nonzero if we can use mouse menus.
 You should not call this unless HAVE_MENUS is defined.  */
 int
 have_menus_p ()
 {
 return mac_in_use;
 }
 }
 if (NILP (frame))
 {
 struct frame *sf = XFRAME (selected_frame);
 if (FRAME_MAC_P (sf) && FRAME_LIVE_P (sf))
 	return FRAME_MAC_DISPLAY_INFO (sf);
 else
 	return &one_mac_display_info;
 }
 int id;
 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
 id = x_allocate_bitmap_record (f);
 if (width % 16 != 0)
 return -1;
 dpyinfo->bitmaps[id - 1].bitmap_data = (char *) xmalloc (height * width);
 if (! dpyinfo->bitmaps[id - 1].bitmap_data)
 hinst = LoadLibraryEx (filename, NULL, LOAD_LIBRARY_AS_DATAFILE);
 if (hinst == NULL)
 return -1;
 result = XReadBitmapFile (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
 			    filename, &width, &height, &bitmap, &xhot, &yhot);
 if (result != BitmapSuccess)
 return -1;
 height = FRAME_HEIGHT (f);
 /* Process foreground_color and background_color before anything else.
 They are independent of other properties, but other properties (e.g.,
 cursor_color) are dependent upon them.  */
 for (p = 0; p < i; p++)
 {
 Lisp_Object prop, val;
 prop = parms[p];
 val = values[p];
 GrafPtr oldport;
 #ifdef TARGET_API_MAC_CARBON
 {
 Rect r;
 GetWindowPortBounds (f->output_data.mac->mWP, &r);
 SetPt (&pt, r.left, r.top);
 }
 #else /* not TARGET_API_MAC_CARBON */
 SetPt (&pt,
 	 f->output_data.mac->mWP->portRect.top);
 #endif /* not TARGET_API_MAC_CARBON */
 GetPort (&oldport);
 LocalToGlobal (&pt);
 SetPort (oldport);
 *xptr = pt.h;
 *yptr = pt.v;
 }
 /* Insert a description of internally-recorded parameters of frame X
 store_in_alist (alistptr, Qdisplay,
 		  XCAR (FRAME_MAC_DISPLAY_INFO (f)->name_list_element));
 }
 /* The default colors for the Mac color map */
 typedef struct colormap_t
 {
 unsigned long color;
 char *name;
 } colormap_t;
 colormap_t mac_color_map[] =
 {
 { RGB_TO_ULONG(255, 250, 250), "snow" },
 { RGB_TO_ULONG(248, 248, 255), "ghost white" },
 { RGB_TO_ULONG(248, 248, 255), "GhostWhite" },
 { RGB_TO_ULONG(245, 245, 245), "white smoke" },
 { RGB_TO_ULONG(193, 255, 193), "DarkSeaGreen1" },
 { RGB_TO_ULONG(180, 238, 180), "DarkSeaGreen2" },
 { RGB_TO_ULONG(155, 205, 155), "DarkSeaGreen3" },
 { RGB_TO_ULONG(105, 139, 105), "DarkSeaGreen4" },
 { RGB_TO_ULONG(84 , 255, 159), "SeaGreen1" },
 { RGB_TO_ULONG(78 , 238, 148), "SeaGreen2" },
 { RGB_TO_ULONG(67 , 205, 128), "SeaGreen3" },
 { RGB_TO_ULONG(46 , 139, 87 ), "SeaGreen4" },
 { RGB_TO_ULONG(154, 255, 154), "PaleGreen1" },
 { RGB_TO_ULONG(144, 238, 144), "PaleGreen2" },
 { RGB_TO_ULONG(124, 205, 124), "PaleGreen3" },
 {
 Lisp_Object ret = Qnil;
 int i;
 BLOCK_INPUT;
 for (i = 0; i < sizeof (mac_color_map) / sizeof (mac_color_map[0]); i++)
 if (stricmp (colorname, mac_color_map[i].name) == 0)
 {
 ret = mac_color_map[i].color;
 break;
 UNBLOCK_INPUT;
 return ret;
 }
 Lisp_Object
 x_to_mac_color (colorname)
 char * colorname;
 {
 register Lisp_Object tail, ret = Qnil;
 BLOCK_INPUT;
 if (colorname[0] == '#')
 {
 /* Could be an old-style RGB Device specification.  */
 char *color;
 int size;
 color = colorname + 1;
 size = strlen(color);
 if (size == 3 || size == 6 || size == 9 || size == 12)
 	{
 	  unsigned long colorval;
 	  int i, pos;
 	  pos = 0;
 	  size /= 3;
 	  colorval = 0;
 	  for (i = 0; i < 3; i++)
 	    {
 	      char *end;
 	      char t;
 	      unsigned long value;
 color = colorname + 4;
 for (i = 0; i < 3; i++)
 	{
 	  char *end;
 	  unsigned long value;
 	  /* The check for 'x' in the following conditional takes into
 	     account the fact that strtol allows a "0x" in front of
 	     our numbers, and we don't.  */
 	  if (!isxdigit(color[0]) || color[1] == 'x')
 	    break;
 	  color = end + 1;
 	}
 }
 ret = mac_color_map_lookup (colorname);
 UNBLOCK_INPUT;
 return ret;
 }
 /* Gamma-correct COLOR on frame F.  */
 register Lisp_Object tem;
 unsigned long mac_color_ref;
 tem = x_to_mac_color (color);
 if (!NILP (tem))
 {
 if (f)
 {
 /* Apply gamma correction.  */
 mac_color_ref = XUINT (tem);
 color_def->green = GREEN_FROM_ULONG (mac_color_ref);
 color_def->blue = BLUE_FROM_ULONG (mac_color_ref);
 return 1;
 }
 else
 {
 return 0;
 }
 }
 					    XINT (Vx_hourglass_pointer_shape));
 }
 else
 hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_watch);
 x_check_errors (FRAME_W32_DISPLAY (f), "bad busy pointer cursor: %s");
 x_check_errors (FRAME_W32_DISPLAY (f), "bad nontext pointer cursor: %s");
 if (!EQ (Qnil, Vx_mode_pointer_shape))
 {
 CHECK_NUMBER (Vx_mode_pointer_shape);
 mode_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
 if (mode_cursor != f->output_data.w32->modeline_cursor
 && f->output_data.w32->modeline_cursor != 0)
 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->modeline_cursor);
 f->output_data.w32->modeline_cursor = mode_cursor;
 if (cross_cursor != f->output_data.w32->cross_cursor
 && f->output_data.w32->cross_cursor != 0)
 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->cross_cursor);
 f->output_data.w32->cross_cursor = cross_cursor;
 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
 				 WHITE_PIX_DEFAULT (f));
 else
 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
 f->output_data.mac->cursor_pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
 /* Make sure that the cursor color differs from the background color.  */
 if (f->output_data.mac->cursor_pixel == FRAME_BACKGROUND_PIXEL (f))
 {
 f->output_data.mac->cursor_pixel = f->output_data.mac->mouse_pixel;
 if (f->output_data.mac->cursor_pixel == fore_pixel)
 int result;
 if (NILP (arg) && NILP (oldval))
 return;
 if (STRINGP (arg) && STRINGP (oldval)
 && EQ (Fstring_equal (oldval, arg), Qt))
 return;
 if (SYMBOLP (arg) && SYMBOLP (oldval) && EQ (arg, oldval))
 return;
 BLOCK_INPUT;
 result = (STRINGP (fontset_name)
 ? x_new_fontset (f, SDATA (fontset_name))
 : x_new_font (f, SDATA (arg)));
 UNBLOCK_INPUT;
 if (EQ (result, Qnil))
 error ("Font `%s' is not defined", SDATA (arg));
 else if (EQ (result, Qt))
 error ("The characters of the given font have varying widths");
 else if (STRINGP (result))
 x_set_name (f, name, explicit)
 struct frame *f;
 Lisp_Object name;
 int explicit;
 {
 /* Make sure that requests from lisp code override requests from
 Emacs redisplay code.  */
 if (explicit)
 {
 /* If we're switching from explicit to implicit, we had better
 	 update the mode lines and thereby update the title.  */
 #else
 return;
 #endif
 BLOCK_INPUT;
 {
 	Str255 windowTitle;
 	if (strlen (SDATA (name)) < 255)
 	  {
 	    strcpy (windowTitle, SDATA (name));
 {
 FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
 	= (NILP (arg)
 	   ? vertical_scroll_bar_none
 	   : EQ (Qright, arg)
 	     ? vertical_scroll_bar_right
 	     : vertical_scroll_bar_left);
 /* We set this parameter before creating the window for the
 	 frame, so we can get the geometry right from the start.
 	 However, if the window hasn't been created yet, we shouldn't
 wid - 1) / wid;
 #else /* not MAC_OSX */
 /* Make the actual width at least 14 pixels and a multiple of a
 	 character width.  */
 FRAME_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
 /* Use all of that space (aside from required margins) for the
 	 scroll bar.  */
 FRAME_SCROLL_BAR_PIXEL_WIDTH (f) = 0;
 #endif /* not MAC_OSX */
 if (FRAME_MAC_WINDOW (f))
 	x_set_window_size (f, 0, FRAME_WIDTH (f), FRAME_HEIGHT (f));
 do_pending_window_change (0);
 }
 change_frame_size (f, 0, FRAME_WIDTH (f), 0, 0, 0);
 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
 }
 /* Subroutines of creating an frame.  */
 /* Make sure that Vx_resource_name is set to a reasonable value.
 	    case RES_TYPE_BOOLEAN:
 	      tem = Fdowncase (tem);
 	      if (!strcmp (SDATA (tem), "on")
 		  || !strcmp (SDATA (tem), "true"))
 		return Qt;
 	      else
 		return Qnil;
 	    case RES_TYPE_STRING:
 	      return tem;
 *   Example:  "=80x24+300-49"
 *   The equal sign is optional.
 *   It returns a bitmask that indicates which of the four values
 *   were actually found in the string.  For each value found,
 *   the corresponding argument is updated;  for each value
 *   not found, the corresponding argument is left unchanged.
 */
 static int
 read_integer (string, NextString)
 register char *string;
 char **NextString;
 {
 register int Result = 0;
 int Sign = 1;
 if (*string == '+')
 string++;
 else if (*string == '-')
 {
 string++;
 return (Result);
 else
 return (-Result);
 }
 int
 XParseGeometry (string, x, y, width, height)
 char *string;
 int *x, *y;
 unsigned int *width, *height;    /* RETURN */
 {
 int mask = NoValue;
 register char *strind;
 unsigned int tempWidth, tempHeight;
 int tempX, tempY;
 char *nextCharacter;
 if ((string == NULL) || (*string == '\0')) return (mask);
 if (*string == '=')
 string++;  /* ignore possible '=' at beg of geometry spec */
 strind = (char *)string;
 if (*strind != '+' && *strind != '-' && *strind != 'x')
 {
 tempWidth = read_integer (strind, &nextCharacter);
 if (strind == nextCharacter)
 	return (0);
 strind = nextCharacter;
 mask |= WidthValue;
 }
 if (*strind == 'x' || *strind == 'X')
 {
 strind++;
 tempHeight = read_integer (strind, &nextCharacter);
 if (strind == nextCharacter)
 	return (0);
 strind = nextCharacter;
 mask |= HeightValue;
 }
 if ((*strind == '+') || (*strind == '-'))
 {
 if (*strind == '-')
 	{
 	  strind++;
 	  tempX = -read_integer (strind, &nextCharacter);
 	  if (strind == nextCharacter)
 	    return (0);
 	  strind = nextCharacter;
 	  mask |= XNegative;
 	}
 else
 	{
 	  strind++;
 	  tempX = read_integer (strind, &nextCharacter);
 	  if (strind == nextCharacter)
 	    return (0);
 	  strind = nextCharacter;
 	}
 mask |= XValue;
 if ((*strind == '+') || (*strind == '-'))
 	{
 	  if (*strind == '-')
 	    {
 	      strind++;
 	      tempY = -read_integer (strind, &nextCharacter);
 	      if (strind == nextCharacter)
 		return (0);
 	      strind = nextCharacter;
 	    }
 	  mask |= YValue;
 	}
 }
 /* If strind isn't at the end of the string the it's an invalid
 geometry specification. */
 if (*strind != '\0') return (0);
 if (mask & XValue)
 *x = tempX;
 if (mask & YValue)
 *y = tempY;
 if (mask & WidthValue)
 /* Use the resource name as the top-level window name
 for looking up resources.  Make a non-Lisp copy
 for the window manager, so GC relocation won't bother it.
 Elsewhere we specify the window name for the window manager.  */
 {
 char *str = (char *) SDATA (Vx_resource_name);
 f->namebuf = (char *) xmalloc (strlen (str) + 1);
 strcpy (f->namebuf, str);
 }
 font = x_new_font (f, "-*-courier-*-10-*-mac-roman");
 if (! STRINGP (font))
 error ("Cannot find any usable font");
 UNBLOCK_INPUT;
 x_default_parameter (f, parms, Qfont, font,
 			 "font", "Font", RES_TYPE_STRING);
 }
 x_default_parameter (f, parms, Qborder_width, make_number (0),
 		       "borderwidth", "BorderWidth", RES_TYPE_NUMBER);
 which calls change_frame_size, which calls Fset_window_buffer,
 which runs hooks, which call Fvertical_motion.  At the end, we
 end up in init_iterator with a null face cache, which should not
 happen.  */
 init_frame_faces (f);
 x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
 		       "menuBar", "MenuBar", RES_TYPE_NUMBER);
 x_default_parameter (f, parms, Qtool_bar_lines, make_number (0),
 "toolBar", "ToolBar", RES_TYPE_NUMBER);
 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
 else
 	/* Must have been Qnil.  */
 	;
 }
 UNGCPRO;
 /* Make sure windows on this frame appear in calls to next-window
 and similar functions.  */
 Vwindow_list = Qnil;
 return unbind_to (count, frame);
 }
 /* FRAME is used only to get a handle on the X display.  We don't pass the
 display info directly because we're called from frame.c, which doesn't
 If omitted or nil, that stands for the selected frame's display.  */)
 (display)
 Lisp_Object display;
 {
 struct mac_display_info *dpyinfo = check_x_display_info (display);
 /* MAC_TODO: check whether this is right */
 return make_number ((unsigned long) (pow (2, dpyinfo->n_cbits)));
 }
 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
 Sx_server_max_request_size,
 0, 1, 0,
 doc: /* Returns the maximum request size of the server of display DISPLAY.
 The optional argument DISPLAY specifies which display to ask about.
 DISPLAY should be either a frame or a display name (a string).
-If omitted or nil, that stands for the selected frame's display.   */)
+If omitted or nil, that stands for the selected frame's display.  */)
 (display)
 Lisp_Object display;
 {
 struct mac_display_info *dpyinfo = check_x_display_info (display);
 int mac_major_version, mac_minor_version;
 SInt32 response;
 if (Gestalt (gestaltSystemVersion, &response) != noErr)
 error ("Cannot get Mac OS version");
 mac_major_version = (response >> 8) & 0xf;
 mac_minor_version = (response >> 4) & 0xf;
 return Fcons (make_number (mac_major_version),
 		Fcons (make_number (mac_minor_version), Qnil));
 DISPLAY should be either a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
 (display)
 Lisp_Object display;
 {
 /* MAC_TODO: this is an approximation, and only of the main display */
 struct mac_display_info *dpyinfo = check_x_display_info (display);
 short h, v;
 ScreenRes (&h, &v);
 return make_number ((int) (v / 72.0 * 25.4));
 }
 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
 doc: /* Return the width in millimeters of the X display DISPLAY.
 DISPLAY should be either a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
 (display)
 Lisp_Object display;
 {
 /* MAC_TODO: this is an approximation, and only of the main display */
 struct mac_display_info *dpyinfo = check_x_display_info (display);
 short h, v;
 ScreenRes (&h, &v);
 return make_number ((int) (h / 72.0 * 25.4));
 }
 DEFUN ("x-display-backing-store", Fx_display_backing_store,
 Sx_display_backing_store, 0, 1, 0,
 int
 valid_image_p (object)
 Lisp_Object object;
 {
 int valid_p = 0;
 if (CONSP (object) && EQ (XCAR (object), Qimage))
 {
 Lisp_Object symbol = Fplist_get (XCDR (object), QCtype);
 struct image_type *type = lookup_image_type (symbol);
 if (type)
 	valid_p = type->valid_p (object);
 }
 return valid_p;
 /* Record that we recognized the keyword.  If a keywords
 	 was found more than once, it's an error.  */
 keywords[i].value = value;
 ++keywords[i].count;
 if (keywords[i].count > 1)
 	return 0;
 /* Check type of value against allowed type.  */
 switch (keywords[i].type)
 	case IMAGE_DONT_CHECK_VALUE_TYPE:
 	  break;
 	case IMAGE_FUNCTION_VALUE:
 	  value = indirect_function (value);
 	  if (SUBRP (value)
 	      || COMPILEDP (value)
 	      || (CONSP (value) && EQ (XCAR (value), Qlambda)))
 	    break;
 	  return 0;
 image_spec_value (spec, key, found)
 Lisp_Object spec, key;
 int *found;
 {
 Lisp_Object tail;
 xassert (valid_image_p (spec));
 for (tail = XCDR (spec);
 CONSP (tail) && CONSP (XCDR (tail));
 tail = XCDR (XCDR (tail)))
 	  if (found)
 	    *found = 1;
 	  return XCAR (XCDR (tail));
 	}
 }
 if (found)
 *found = 0;
 return Qnil;
 }
 /***********************************************************************
 		 Image type independent image structures
 make_image (spec, hash)
 Lisp_Object spec;
 unsigned hash;
 {
 struct image *img = (struct image *) xmalloc (sizeof *img);
 xassert (valid_image_p (spec));
 bzero (img, sizeof *img);
 img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
 xassert (img->type != NULL);
 img->spec = spec;
 /* If IMG doesn't have a pixmap yet, load it now, using the image
 type dependent loader function.  */
 if (img->pixmap == 0 && !img->load_failed_p)
 img->load_failed_p = img->type->load (f, img) == 0;
 }
 /* Value is the number of pixels for the ascent of image IMG when
 drawn in face FACE.  */
 int
 }
 if (img->ncolors)
 {
 int class = FRAME_W32_DISPLAY_INFO (f)->visual->class;
 /* If display has an immutable color map, freeing colors is not
 	 necessary and some servers don't allow it.  So don't do it.  */
 if (class != StaticColor
 	  && class != StaticGray
 	  && class != TrueColor)
 	  cmap = DefaultColormapOfScreen (FRAME_W32_DISPLAY_INFO (f)->screen);
 	  XFreeColors (FRAME_W32_DISPLAY (f), cmap, img->colors,
 		       img->ncolors, 0);
 	  UNBLOCK_INPUT;
 	}
 xfree (img->colors);
 img->colors = NULL;
 img->ncolors = 0;
 }
 #endif /* MAC_TODO */
 struct image_cache *
 make_image_cache ()
 {
 struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
 int size;
 bzero (c, sizeof *c);
 c->size = 50;
 c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
 size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
 c->buckets = (struct image **) xmalloc (size);
 {
 int i;
 /* Cache should not be referenced by any frame when freed.  */
 xassert (c->refcount == 0);
 for (i = 0; i < c->used; ++i)
 	free_image (f, c->images[i]);
 xfree (c->images);
 xfree (c->buckets);
 xfree (c);
 unsigned long old;
 int i, any_freed_p = 0;
 EMACS_GET_TIME (t);
 old = EMACS_SECS (t) - XFASTINT (Vimage_cache_eviction_delay);
 for (i = 0; i < c->used; ++i)
 	{
 	  struct image *img = c->images[i];
 	  if (img != NULL
 	      && (force_p
 Lisp_Object frame;
 {
 if (EQ (frame, Qt))
 {
 Lisp_Object tail;
 FOR_EACH_FRAME (tail, frame)
 	if (FRAME_MAC_P (XFRAME (frame)))
 	  clear_image_cache (XFRAME (frame), 1);
 }
 else
 /* F must be a window-system frame, and SPEC must be a valid image
 specification.  */
 xassert (FRAME_WINDOW_P (f));
 xassert (valid_image_p (spec));
 GCPRO1 (spec);
 /* Look up SPEC in the hash table of the image cache.  */
 hash = sxhash (spec, 0);
 i = hash % IMAGE_CACHE_BUCKETS_SIZE;
 	      if (XINT (XCAR (margin)) > 0)
 		img->hmargin = XFASTINT (XCAR (margin));
 	      if (XINT (XCDR (margin)) > 0)
 		img->vmargin = XFASTINT (XCDR (margin));
 	    }
 	  relief = image_spec_value (spec, QCrelief, NULL);
 	  if (INTEGERP (relief))
 	    {
 	      img->relief = XINT (relief);
 	      img->hmargin += abs (img->relief);
 }
 /* We're using IMG, so set its timestamp to `now'.  */
 EMACS_GET_TIME (now);
 img->timestamp = EMACS_SECS (now);
 UNGCPRO;
 /* Value is the image id.  */
 return img->id;
 }
 struct frame *f;
 XImage *ximg;
 Pixmap pixmap;
 {
 GC gc;
 xassert (interrupt_input_blocked);
 gc = XCreateGC (NULL, pixmap, 0, NULL);
 XPutImage (NULL, pixmap, gc, ximg, 0, 0, 0, 0, width, height);
 XFreeGC (NULL, gc);
 }
 search_path = Fcons (Vdata_directory, Vx_bitmap_file_path);
 GCPRO2 (file_found, search_path);
 /* Try to find FILE in data-directory, then x-bitmap-file-path.  */
 fd = openp (search_path, file, Qnil, &file_found, Qnil);
 if (fd < 0)
 file_found = Qnil;
 else
 close (fd);
 {
 XBM_TK_IDENT = 256,
 XBM_TK_NUMBER
 };
 /* Return non-zero if OBJECT is a valid XBM-type image specification.
 A valid specification is a list starting with the symbol `image'
 The rest of the list is a property list which must contain an
 entry `:type xbm..
 static int
 xbm_image_p (object)
 Lisp_Object object;
 {
 struct image_keyword kw[XBM_LAST];
 bcopy (xbm_format, kw, sizeof kw);
 if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
 return 0;
 xassert (EQ (kw[XBM_TYPE].value, Qxbm));
 	return 0;
 data = kw[XBM_DATA].value;
 width = XFASTINT (kw[XBM_WIDTH].value);
 height = XFASTINT (kw[XBM_HEIGHT].value);
 /* Check type of data, and width and height against contents of
 	 data.  */
 if (VECTORP (data))
 	{
 	  int i;
 	  /* Number of elements of the vector must be >= height.  */
 	  if (XVECTOR (data)->size < height)
 	    return 0;
 	  /* Each string or bool-vector in data must be large enough
 /* Baseline must be a value between 0 and 100 (a percentage).  */
 if (kw[XBM_ASCENT].count
 && XFASTINT (kw[XBM_ASCENT].value) > 100)
 return 0;
 return 1;
 }
 /* Scan a bitmap file.  FP is the stream to read from.  Value is
 FILE *fp;
 char *sval;
 int *ival;
 {
 int c;
 /* Skip white space.  */
 while ((c = fgetc (fp)) != EOF && isspace (c))
 ;
 if (c == EOF)
 c = 0;
 else if (isdigit (c))
 {
 int value = 0, digit;
 if (c == '0')
 	{
 	  c = fgetc (fp);
 	  if (c == 'x' || c == 'X')
 	    {
 #define expect(TOKEN)		\
 if (LA1 != (TOKEN)) 	\
 goto failure;		\
 else			\
 match ()
 #define expect_ident(IDENT)					\
 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0)	\
 match ();						\
 else							\
 expect_ident ("static");
 if (LA1 == XBM_TK_IDENT)
 {
 if (strcmp (buffer, "unsigned") == 0)
 	{
 	  match ();
 	  expect_ident ("char");
 	}
 else if (strcmp (buffer, "short") == 0)
 	{
 	  match ();
 else if (strcmp (buffer, "char") == 0)
 	match ();
 else
 	goto failure;
 }
 else
 goto failure;
 expect (XBM_TK_IDENT);
 expect ('[');
 expect (']');
 nbytes = bytes_per_line * *height;
 p = *data = (char *) xmalloc (nbytes);
 if (v10)
 {
 for (i = 0; i < nbytes; i += 2)
 	{
 	  int val = value;
 	  expect (XBM_TK_NUMBER);
 	  *p++ = val;
 	  if (!padding_p || ((i + 2) % bytes_per_line))
 	    *p++ = value >> 8;
 	  if (LA1 == ',' || LA1 == '}')
 	    match ();
 	  else
 	    goto failure;
 	}
 {
 for (i = 0; i < nbytes; ++i)
 	{
 	  int val = value;
 	  expect (XBM_TK_NUMBER);
 	  *p++ = val;
 	  if (LA1 == ',' || LA1 == '}')
 	    match ();
 	  else
 	    goto failure;
 	}
 fclose (fp);
 return 1;
 failure:
 fclose (fp);
 if (*data)
 {
 xfree (*data);
 *data = NULL;
 int rc;
 unsigned char *data;
 int success_p = 0;
 Lisp_Object file;
 struct gcpro gcpro1;
 xassert (STRINGP (specified_file));
 file = Qnil;
 GCPRO1 (file);
 file = x_find_image_file (specified_file);
 {
 image_error ("Cannot find image file `%s'", specified_file, Qnil);
 UNGCPRO;
 return 0;
 }
 rc = xbm_read_bitmap_file_data (SDATA (file), &img->width,
 				  &img->height, &data);
 if (rc)
 {
 int depth = one_mac_display_info.n_cbits;
 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
 Lisp_Object value;
 xassert (img->width > 0 && img->height > 0);
 /* Get foreground and background colors, maybe allocate colors.  */
 value = image_spec_value (img->spec, QCforeground, NULL);
 if (!NILP (value))
 	foreground = x_alloc_image_color (f, img, value, foreground);
 value = image_spec_value (img->spec, QCbackground, NULL);
 if (!NILP (value))
 	background = x_alloc_image_color (f, img, value, background);
 #if 0 /* MAC_TODO : Port image display to Mac */
 	  x_clear_image (f, img);
 	  image_error ("Unable to create X pixmap for `%s'", file, Qnil);
 	}
 else
 	success_p = 1;
 UNBLOCK_INPUT;
 #endif /* MAC_TODO */
 }
 else
 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
 img->width = XFASTINT (fmt[XBM_WIDTH].value);
 img->height = XFASTINT (fmt[XBM_HEIGHT].value);
 xassert (img->width > 0 && img->height > 0);
 BLOCK_INPUT;
 if (fmt[XBM_ASCENT].count)
 	img->ascent = XFASTINT (fmt[XBM_ASCENT].value);
 /* Get foreground and background colors, maybe allocate colors.  */
 if (fmt[XBM_FOREGROUND].count)
 if (VECTORP (data))
 	{
 	  int i;
 	  char *p;
 	  int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
 	  p = bits = (char *) alloca (nbytes * img->height);
 	  for (i = 0; i < img->height; ++i, p += nbytes)
 	    {
 	      Lisp_Object line = XVECTOR (data)->contents[i];
 	      if (STRINGP (line))
 UNBLOCK_INPUT;
 }
 return success_p;
 }
 /***********************************************************************
 			      XPM images
 ***********************************************************************/
 #if HAVE_XPM
 static int xpm_image_p P_ ((Lisp_Object object));
 static int xpm_load P_ ((struct frame *f, struct image *img));
 static int xpm_valid_color_symbols_p P_ ((Lisp_Object));
 if (CONSP (color_symbols))
 {
 Lisp_Object tail;
 XpmColorSymbol *xpm_syms;
 int i, size;
 attrs.valuemask |= XpmColorSymbols;
 /* Count number of symbols.  */
 attrs.numsymbols = 0;
 for (tail = color_symbols; CONSP (tail); tail = XCDR (tail))
 	{
 	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
 UNBLOCK_INPUT;
 	  return 0;
 	}
 rc = XpmReadFileToPixmap (NULL, FRAME_W32_WINDOW (f),
 				SDATA (file), &img->pixmap, &img->mask,
 				&attrs);
 }
 else
 switch (rc)
 	{
 	case XpmOpenFailed:
 	  image_error ("Error opening XPM file (%s)", img->spec, Qnil);
 	  break;
 	case XpmFileInvalid:
 	  image_error ("Invalid XPM file (%s)", img->spec, Qnil);
 	  break;
 	case XpmNoMemory:
 	  image_error ("Out of memory (%s)", img->spec, Qnil);
 	  break;
 	case XpmColorFailed:
 	  image_error ("Color allocation error (%s)", img->spec, Qnil);
 	  break;
 	default:
 	  image_error ("Unknown error (%s)", img->spec, Qnil);
 	  break;
 	}
 }
 XColor color;
 Colormap cmap;
 int rc;
 BLOCK_INPUT;
 cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
 color.pixel = pixel;
 XQueryColor (NULL, cmap, &color);
 rc = x_alloc_nearest_color (f, cmap, &color);
 UNBLOCK_INPUT;
 if (rc)
 	{
 	  ++ct_colors_allocated;
 	  p = (struct ct_color *) xmalloc (sizeof *p);
 	  p->r = color.red;
 	  p->g = color.green;
 	  p->b = color.blue;
 	  p->pixel = pixel;
 else
 {
 colors = (unsigned long *) xmalloc (ct_colors_allocated
 					  * sizeof *colors);
 *n = ct_colors_allocated;
 for (i = j = 0; i < CT_SIZE; ++i)
 	for (p = ct_table[i]; p; p = p->next)
 	  colors[j++] = p->pixel;
 }
 int width;
 XImage *ximg;
 int y;
 {
 int x;
 for (x = 0; x < width; ++x)
 XPutPixel (ximg, x, y, pixels[x]);
 }
 #endif /* MAC_TODO */
 for (x = 0; x < img->width - 2; ++x)
 	{
 	  int r = in[rowa][x].red + mv2 - in[rowb][x + 2].red;
 	  int g = in[rowa][x].green + mv2 - in[rowb][x + 2].green;
 	  int b = in[rowa][x].blue + mv2 - in[rowb][x + 2].blue;
 	  out[x + 1] = lookup_rgb_color (f, r & 0xffff, g & 0xffff,
 					 b & 0xffff);
 	}
 x_laplace_write_row (f, out, img->width, oimg, out_y++);
 x_laplace_write_row (f, out, img->width, oimg, out_y);
 /* Free the input image, and free resources of IMG.  */
 XDestroyImage (ximg);
 x_clear_image (f, img);
 /* Put the output image into pixmap, and destroy it.  */
 x_put_x_image (f, oimg, pixmap, img->width, img->height);
 x_destroy_x_image (oimg);
 /* Remember new pixmap and colors in IMG.  */
 XImage *ximg, *mask_img;
 int x, y, rc, look_at_corners_p;
 unsigned long bg;
 BLOCK_INPUT;
 /* Create an image and pixmap serving as mask.  */
 rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
 				    &mask_img, &img->mask);
 if (!rc)
 {
 /* Determine the background color of ximg.  If HOW is `(R G B)'
 take that as color.  Otherwise, try to determine the color
 heuristically. */
 look_at_corners_p = 1;
 if (CONSP (how))
 {
 int rgb[3], i = 0;
 while (i < 3
 	  char color_name[30];
 	  XColor exact, color;
 	  Colormap cmap;
 	  sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
 	  cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
 	  if (XLookupColor (dpy, cmap, color_name, &exact, &color))
 	    {
 	      bg = color.pixel;
 	      look_at_corners_p = 0;
 	    }
 	}
 }
 if (look_at_corners_p)
 {
 unsigned long corners[4];
 int i, best_count;
 /* Choose the most frequently found color as background.  */
 for (i = best_count = 0; i < 4; ++i)
 	{
 	  int j, n;
 	  for (j = n = 0; j < 4; ++j)
 	    if (corners[i] == corners[j])
 	      ++n;
 	  if (n > best_count)
 /* Put mask_img into img->mask.  */
 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
 x_destroy_x_image (mask_img);
 XDestroyImage (ximg);
 UNBLOCK_INPUT;
 #endif /* MAC_TODO */
 return 1;
 }
 static int
 pbm_image_p (object)
 Lisp_Object object;
 {
 struct image_keyword fmt[PBM_LAST];
 bcopy (pbm_format, fmt, sizeof fmt);
 if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm)
 || (fmt[PBM_ASCENT].count
 	  && XFASTINT (fmt[PBM_ASCENT].value) > 100))
 return 0;
 /* Must specify either :data or :file.  */
 return fmt[PBM_DATA].count + fmt[PBM_FILE].count == 1;
 	{
 	  xfree (buf);
 	  buf = NULL;
 	}
 }
 return buf;
 }
 /* Load PBM image IMG for use on frame F.  */
 static int
 pbm_load (f, img)
 struct frame *f;
 struct image *img;
 {
 int raw_p, x, y;
 switch (*p++)
 {
 case '1':
 raw_p = 0, type = PBM_MONO;
 break;
 case '2':
 raw_p = 0, type = PBM_GRAY;
 break;
 case '3':
 break;
 case '4':
 raw_p = 1, type = PBM_MONO;
 break;
 case '5':
 raw_p = 1, type = PBM_GRAY;
 break;
 case '6':
 raw_p = 1, type = PBM_COLOR;
 break;
 default:
 {
 max_color_idx = pbm_scan_number (&p, end);
 if (raw_p && max_color_idx > 255)
 	max_color_idx = 255;
 }
 if (width < 0
 || height < 0
 || (type != PBM_MONO && max_color_idx < 0))
 goto error;
 				    &ximg, &img->pixmap))
 {
 UNBLOCK_INPUT;
 goto error;
 }
 /* Initialize the color hash table.  */
 init_color_table ();
 if (type == PBM_MONO)
 {
 int c = 0, g;
 for (y = 0; y < height; ++y)
 	for (x = 0; x < width; ++x)
 	  {
 	    if (raw_p)
 	      {
 {
 for (y = 0; y < height; ++y)
 	for (x = 0; x < width; ++x)
 	  {
 	    int r, g, b;
 	    if (type == PBM_GRAY)
 	      r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
 	    else if (raw_p)
 	      {
 		r = *p++;
 	      {
 		r = pbm_scan_number (&p, end);
 		g = pbm_scan_number (&p, end);
 		b = pbm_scan_number (&p, end);
 	      }
 	    if (r < 0 || g < 0 || b < 0)
 	      {
 		xfree (ximg->data);
 		ximg->data = NULL;
 		XDestroyImage (ximg);
 		UNBLOCK_INPUT;
 		image_error ("Invalid pixel value in image `%s'",
 			     img->spec, Qnil);
 goto error;
 	      }
 	    /* RGB values are now in the range 0..max_color_idx.
 	       Scale this to the range 0..0xffff supported by X.  */
 	    r = (double) r * 65535 / max_color_idx;
 	    g = (double) g * 65535 / max_color_idx;
 	    b = (double) b * 65535 / max_color_idx;
 	    XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
 	  }
 }
 /* Store in IMG->colors the colors allocated for the image, and
 free the color table.  */
 img->colors = colors_in_color_table (&img->ncolors);
 free_color_table ();
 /* Put the image into a pixmap.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 UNBLOCK_INPUT;
 img->width = width;
 img->height = height;
 UNGCPRO;
 xfree (contents);
 png_image_p (object)
 Lisp_Object object;
 {
 struct image_keyword fmt[PNG_LAST];
 bcopy (png_format, fmt, sizeof fmt);
 if (!parse_image_spec (object, fmt, PNG_LAST, Qpng)
 || (fmt[PNG_ASCENT].count
 	  && XFASTINT (fmt[PNG_ASCENT].value) > 100))
 return 0;
 /* Must specify either the :data or :file keyword.  */
 return fmt[PNG_FILE].count + fmt[PNG_DATA].count == 1;
 struct png_memory_storage *tbr
 = (struct png_memory_storage *) png_get_io_ptr (png_ptr);
 if (length > tbr->len - tbr->index)
 png_error (png_ptr, "Read error");
 bcopy (tbr->bytes + tbr->index, data, length);
 tbr->index = tbr->index + length;
 }
 /* Load PNG image IMG for use on frame F.  Value is non-zero if
 png_set_sig_bytes (png_ptr, sizeof sig);
 png_read_info (png_ptr, info_ptr);
 png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
 	        &interlace_type, NULL, NULL);
 /* If image contains simply transparency data, we prefer to
 construct a clipping mask.  */
 if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
 transparent_p = 1;
 else
 transparent_p = 0;
 /* This function is easier to write if we only have to handle
 one data format: RGB or RGBA with 8 bits per channel.  Let's
 transform other formats into that format.  */
 /* Strip more than 8 bits per channel.  */
 if (bit_depth == 16)
 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
 if available.  */
 png_set_expand (png_ptr);
 /* Convert grayscale images to RGB.  */
 if (color_type == PNG_COLOR_TYPE_GRAY
 || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 png_set_gray_to_rgb (png_ptr);
 /* The value 2.2 is a guess for PC monitors from PNG example.c.  */
 gamma_str = getenv ("SCREEN_GAMMA");
 if (!transparent_p)
 {
 png_color_16 *image_background;
 if (png_get_bKGD (png_ptr, info_ptr, &image_background))
 	/* Image contains a background color with which to
 	   combine the image.  */
 	png_set_background (png_ptr, image_background,
 			    PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 else
 	{
 	  /* Image does not contain a background color with which
 	     to combine the image data via an alpha channel.  Use
 	     the frame's background instead.  */
 	  XColor color;
 	  Colormap cmap;
 	  png_color_16 frame_background;
 				    &img->pixmap))
 {
 UNBLOCK_INPUT;
 goto error;
 }
 /* Create an image and pixmap serving as mask if the PNG image
 contains an alpha channel.  */
 if (channels == 4
 && !transparent_p
 && !x_create_x_image_and_pixmap (f, width, height, 1,
 	  g = *p++ << 8;
 	  b = *p++ << 8;
 	  XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
 	  /* An alpha channel, aka mask channel, associates variable
 	     transparency with an image.  Where other image formats
 	     support binary transparency---fully transparent or fully
 	     opaque---PNG allows up to 254 levels of partial transparency.
 	     The PNG library implements partial transparency by combining
 	     the image with a specified background color.
 	     I'm not sure how to handle this here nicely: because the
 	     background on which the image is displayed may change, for
 	     real alpha channel support, it would be necessary to create
 	     a new image for each possible background.
 	     What I'm doing now is that a mask is created if we have
 	     boolean transparency information.  Otherwise I'm using
 	     the frame's background color to combine the image with.  */
 static int
 jpeg_image_p (object)
 Lisp_Object object;
 {
 struct image_keyword fmt[JPEG_LAST];
 bcopy (jpeg_format, fmt, sizeof fmt);
 if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg)
 || (fmt[JPEG_ASCENT].count
 	  && XFASTINT (fmt[JPEG_ASCENT].value) > 100))
 return 0;
 /* Must specify either the :data or :file keyword.  */
 return fmt[JPEG_FILE].count + fmt[JPEG_DATA].count == 1;
 if (src)
 {
 if (num_bytes > src->bytes_in_buffer)
 	ERREXIT (cinfo, JERR_INPUT_EOF);
 src->bytes_in_buffer -= num_bytes;
 src->next_input_byte += num_bytes;
 }
 }
 	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
 				    sizeof (struct jpeg_source_mgr));
 src = (struct jpeg_source_mgr *) cinfo->src;
 src->next_input_byte = data;
 }
 src = (struct jpeg_source_mgr *) cinfo->src;
 src->init_source = our_init_source;
 src->fill_input_buffer = our_fill_input_buffer;
 src->skip_input_data = our_skip_input_data;
 src->resync_to_restart = jpeg_resync_to_restart; /* Use default method.  */
 /* Load image IMG for use on frame F.  Patterned after example.c
 from the JPEG lib.  */
 static int
 jpeg_load (f, img)
 struct frame *f;
 struct image *img;
 {
 struct jpeg_decompress_struct cinfo;
 {
 image_error ("Cannot find image file `%s'", specified_file, Qnil);
 UNGCPRO;
 return 0;
 }
 fp = fopen (SDATA (file), "r");
 if (fp == NULL)
 {
 image_error ("Cannot open `%s'", file, Qnil);
 UNGCPRO;
 return 0;
 }
 }
 /* Customize libjpeg's error handling to call my_error_exit when an
 error is detected. This function will perform a longjmp. */
 mgr.pub.error_exit = my_error_exit;
 cinfo.err = jpeg_std_error (&mgr.pub);
 if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
 {
 if (rc == 1)
 	{
 	  /* Called from my_error_exit.  Display a JPEG error.  */
 	  char buffer[JMSG_LENGTH_MAX];
 	  cinfo.err->format_message ((j_common_ptr) &cinfo, buffer);
 	  image_error ("Error reading JPEG image `%s': %s", img->spec,
 		       build_string (buffer));
 	}
 /* Close the input file and destroy the JPEG object.  */
 if (fp)
 fclose (fp);
 jpeg_destroy_decompress (&cinfo);
 BLOCK_INPUT;
 /* If we already have an XImage, free that.  */
 x_destroy_x_image (ximg);
 /* Free pixmap and colors.  */
 x_clear_image (f, img);
 UNBLOCK_INPUT;
 UNGCPRO;
 return 0;
 }
 a default color, and we don't have to care about which colors
 can be freed safely, and which can't.  */
 init_color_table ();
 colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
 				       * sizeof *colors);
 for (i = 0; i < cinfo.actual_number_of_colors; ++i)
 {
 	/* Multiply RGB values with 255 because X expects RGB values
 	   in the range 0..0xffff.  */
 	int r = cinfo.colormap[ir][i] << 8;
 /* Clean up.  */
 jpeg_finish_decompress (&cinfo);
 jpeg_destroy_decompress (&cinfo);
 if (fp)
 fclose (fp);
 /* Put the image into the pixmap.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 UNBLOCK_INPUT;
 UNGCPRO;
 tiff_image_p (object)
 Lisp_Object object;
 {
 struct image_keyword fmt[TIFF_LAST];
 bcopy (tiff_format, fmt, sizeof fmt);
 if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff)
 || (fmt[TIFF_ASCENT].count
 	  && XFASTINT (fmt[TIFF_ASCENT].value) > 100))
 return 0;
 /* Must specify either the :data or :file keyword.  */
 return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
 }
 switch (whence)
 {
 case SEEK_SET:		/* Go from beginning of source.  */
 idx = off;
 break;
 case SEEK_END:		/* Go from end of source.  */
 idx = src->len + off;
 break;
 case SEEK_CUR:		/* Go from current position.  */
 idx = src->index + off;
 break;
-default:			/* Invalid `whence'.   */
+default:			/* Invalid `whence'.  */
 return -1;
 }
 if (idx > src->len || idx < 0)
 return -1;
 src->index = idx;
 return src->index;
 }
 static int
 {
 image_error ("Cannot find image file `%s'", file, Qnil);
 UNGCPRO;
 return 0;
 }
 /* Try to open the image file.  */
 tiff = TIFFOpen (SDATA (file), "r");
 if (tiff == NULL)
 {
 image_error ("Cannot open `%s'", file, Qnil);
 /* Get width and height of the image, and allocate a raster buffer
 of width x height 32-bit values.  */
 TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
 TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
 buf = (uint32 *) xmalloc (width * height * sizeof *buf);
 rc = TIFFReadRGBAImage (tiff, width, height, buf, 0);
 TIFFClose (tiff);
 if (!rc)
 {
 image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
 /* Process the pixel raster.  Origin is in the lower-left corner.  */
 for (y = 0; y < height; ++y)
 {
 uint32 *row = buf + y * width;
 for (x = 0; x < width; ++x)
 	{
 	  uint32 abgr = row[x];
 	  int r = TIFFGetR (abgr) << 8;
 	  int g = TIFFGetG (abgr) << 8;
 	  int b = TIFFGetB (abgr) << 8;
 	  XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
 	}
 }
 /* Remember the colors allocated for the image.  Free the color table.  */
 img->colors = colors_in_color_table (&img->ncolors);
 /* Put the image into the pixmap, then free the X image and its buffer.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 xfree (buf);
 UNBLOCK_INPUT;
 img->width = width;
 img->height = height;
 UNGCPRO;
 return 1;
 gif_image_p (object)
 Lisp_Object object;
 {
 struct image_keyword fmt[GIF_LAST];
 bcopy (gif_format, fmt, sizeof fmt);
 if (!parse_image_spec (object, fmt, GIF_LAST, Qgif)
 || (fmt[GIF_ASCENT].count
 	  && XFASTINT (fmt[GIF_ASCENT].value) > 100))
 return 0;
 /* Must specify either the :data or :file keyword.  */
 return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
 }
 /* Reading a GIF image from memory
 {
 image_error ("Cannot find image file `%s'", specified_file, Qnil);
 UNGCPRO;
 return 0;
 }
 /* Open the GIF file.  */
 gif = DGifOpenFileName (SDATA (file));
 if (gif == NULL)
 {
 image_error ("Cannot open `%s'", file, Qnil);
 UNBLOCK_INPUT;
 DGifCloseFile (gif);
 UNGCPRO;
 return 0;
 }
 /* Allocate colors.  */
 gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
 if (!gif_color_map)
 gif_color_map = gif->SColorMap;
 init_color_table ();
 bzero (pixel_colors, sizeof pixel_colors);
 for (i = 0; i < gif_color_map->ColorCount; ++i)
 {
 int r = gif_color_map->Colors[i].Red << 8;
 int g = gif_color_map->Colors[i].Green << 8;
 int b = gif_color_map->Colors[i].Blue << 8;
 img->colors = colors_in_color_table (&img->ncolors);
 free_color_table ();
 /* Clear the part of the screen image that are not covered by
 the image from the GIF file.  Full animated GIF support
 requires more than can be done here (see the gif89 spec,
 disposal methods).  Let's simply assume that the part
 not covered by a sub-image is in the frame's background color.  */
 image_top = gif->SavedImages[ino].ImageDesc.Top;
 image_left = gif->SavedImages[ino].ImageDesc.Left;
 	    {
 	      row = interlace_start[++pass];
 	      while (row >= image_height)
 		row = interlace_start[++pass];
 	    }
 	  for (x = 0; x < image_width; x++)
 	    {
 	      int i = raster[(y * image_width) + x];
 	      XPutPixel (ximg, x + image_left, row + image_top,
 			 pixel_colors[i]);
 	    }
 	  row += interlace_increment[pass];
 	}
 }
 else
 {
 	  {
 	    int i = raster[y* image_width + x];
 	    XPutPixel (ximg, x + image_left, y + image_top, pixel_colors[i]);
 	  }
 }
 DGifCloseFile (gif);
 /* Put the image into the pixmap, then free the X image and its buffer.  */
 x_put_x_image (f, ximg, img->pixmap, width, height);
 x_destroy_x_image (ximg);
 UNBLOCK_INPUT;
 UNGCPRO;
 return 1;
 }
 #endif /* HAVE_GIF != 0 */
 Lisp_Object object;
 {
 struct image_keyword fmt[GS_LAST];
 Lisp_Object tem;
 int i;
 bcopy (gs_format, fmt, sizeof fmt);
 if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript)
 || (fmt[GS_ASCENT].count
 	  && XFASTINT (fmt[GS_ASCENT].value) > 100))
 return 0;
 /* Bounding box must be a list or vector containing 4 integers.  */
 tem = fmt[GS_BOUNDING_BOX].value;
 if (!img->pixmap)
 {
 image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
 return 0;
 }
 /* Call the loader to fill the pixmap.  It returns a process object
 if successful.  We do not record_unwind_protect here because
 other places in redisplay like calling window scroll functions
 don't either.  Let the Lisp loader use `unwind-protect' instead.  */
 GCPRO2 (window_and_pixmap_id, pixel_colors);
 sprintf (buffer, "%lu %lu",
 	   (unsigned long) FRAME_W32_WINDOW (f),
 	   (unsigned long) img->pixmap);
 window_and_pixmap_id = build_string (buffer);
 sprintf (buffer, "%lu %lu",
 	   FRAME_FOREGROUND_PIXEL (f),
 	   FRAME_BACKGROUND_PIXEL (f));
 pixel_colors = build_string (buffer);
 XSETFRAME (frame, f);
 loader = image_spec_value (img->spec, QCloader, NULL);
 if (NILP (loader))
 loader = intern ("gs-load-image");
 ximg = XGetImage (FRAME_W32_DISPLAY (f), img->pixmap,
 			0, 0, img->width, img->height, ~0, ZPixmap);
 if (ximg)
 	{
 	  int x, y;
 	  /* Initialize the color table.  */
 	  init_color_table ();
 	  /* For each pixel of the image, look its color up in the
 	     color table.  After having done so, the color table will
 	     contain an entry for each color used by the image.  */
 	  for (y = 0; y < img->height; ++y)
 	    for (x = 0; x < img->width; ++x)
 #endif
 	}
 else
 	image_error ("Cannot get X image of `%s'; colors will not be freed",
 		     img->spec, Qnil);
 UNBLOCK_INPUT;
 }
 }
 #endif /* HAVE_GHOSTSCRIPT */
 tmp_data = NULL;
 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
 			       prop_atom, 0, bytes_remaining,
 			       False, XA_STRING,
 			       &actual_type, &actual_format,
 			       &actual_size, &bytes_remaining,
 			       (unsigned char **) &tmp_data);
 if (rc == Success)
 	prop_value = make_string (tmp_data, size);
 XFree (tmp_data);
 start_hourglass ()
 {
 #if 0 /* MAC_TODO: cursor shape changes.  */
 EMACS_TIME delay;
 int secs, usecs = 0;
 cancel_hourglass ();
 if (INTEGERP (Vhourglass_delay)
 && XINT (Vhourglass_delay) > 0)
 secs = XFASTINT (Vhourglass_delay);
 secs = XFASTINT (tem);
 usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
 }
 else
 secs = DEFAULT_HOURGLASS_DELAY;
 EMACS_SET_SECS_USECS (delay, secs, usecs);
 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
 				     show_hourglass, NULL);
 #endif /* MAC_TODO */
 }
 if (hourglass_atimer)
 {
 cancel_atimer (hourglass_atimer);
 hourglass_atimer = NULL;
 }
 if (hourglass_shown_p)
 hide_hourglass ();
 }
 hourglass_atimer = NULL;
 if (!hourglass_shown_p)
 {
 Lisp_Object rest, frame;
 BLOCK_INPUT;
 FOR_EACH_FRAME (rest, frame)
 	if (FRAME_W32_P (XFRAME (frame)))
 	  {
 	    struct frame *f = XFRAME (frame);
 	    f->output_data.w32->hourglass_p = 1;
 	    if (!f->output_data.w32->hourglass_window)
 	      {
 		unsigned long mask = CWCursor;
 		XSetWindowAttributes attrs;
 		attrs.cursor = f->output_data.w32->hourglass_cursor;
 		f->output_data.w32->hourglass_window
 		  = XCreateWindow (FRAME_X_DISPLAY (f),
 				   FRAME_OUTER_WINDOW (f),
 				   0, 0, 32000, 32000, 0, 0,
 				   InputOnly,
 				   CopyFromParent,
 				   mask, &attrs);
 	      }
 	    XMapRaised (FRAME_X_DISPLAY (f),
 			f->output_data.w32->hourglass_window);
 	    XFlush (FRAME_X_DISPLAY (f));
 	  }
 BLOCK_INPUT;
 FOR_EACH_FRAME (rest, frame)
 	{
 	  struct frame *f = XFRAME (frame);
 	  if (FRAME_W32_P (f)
 	      /* Watch out for newly created frames.  */
 	      && f->output_data.x->hourglass_window)
 	    {
 	      XUnmapWindow (FRAME_X_DISPLAY (f),
 				Tool tips
 ***********************************************************************/
 static Lisp_Object x_create_tip_frame P_ ((struct mac_display_info *,
 					   Lisp_Object));
 /* The frame of a currently visible tooltip, or null.  */
 Lisp_Object tip_frame;
 /* If non-nil, a timer started that hides the last tooltip when it
 	if (STRINGP (tem))
 	  font = x_new_fontset (f, SDATA (tem));
 	else
 	  font = x_new_font (f, SDATA (font));
 }
 /* Try out a font which we hope has bold and italic variations.  */
 if (!STRINGP (font))
 font = x_new_font (f, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
 if (!STRINGP (font))
 font = x_new_font (f, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
 			 "font", "Font", RES_TYPE_STRING);
 }
 x_default_parameter (f, parms, Qborder_width, make_number (2),
 		       "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
 /* This defaults to 2 in order to match xterm.  We recognize either
 internalBorderWidth or internalBorder (which is what xterm calls
 it).  */
 if (NILP (Fassq (Qinternal_border_width, parms)))
 {
 which calls change_frame_size, which calls Fset_window_buffer,
 which runs hooks, which call Fvertical_motion.  At the end, we
 end up in init_iterator with a null face cache, which should not
 happen.  */
 init_frame_faces (f);
 f->output_data.w32->parent_desc = FRAME_W32_DISPLAY_INFO (f)->root_window;
 window_prompting = x_figure_window_size (f, parms);
 if (window_prompting & XNegative)
 {
 f->output_data.w32->size_hint_flags = window_prompting;
 {
 XSetWindowAttributes attrs;
 unsigned long mask;
 BLOCK_INPUT;
 mask = CWBackPixel | CWOverrideRedirect | CWSaveUnder | CWEventMask;
 /* Window managers looks at the override-redirect flag to
 determine whether or net to give windows a decoration (Xlib
 3.2.8).  */
 int root_x, root_y, win_x, win_y;
 unsigned pmask;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 int old_windows_or_buffers_changed = windows_or_buffers_changed;
 int count = SPECPDL_INDEX ();
 specbind (Qinhibit_redisplay, Qt);
 GCPRO4 (string, parms, frame, timeout);
 CHECK_STRING (string);
 if (NILP (dx))
 dx = make_number (5);
 else
 CHECK_NUMBER (dx);
 if (NILP (dy))
 dy = make_number (-10);
 else
 CHECK_NUMBER (dy);
 if (EQ (frame, last_frame)
 	  && !NILP (Fequal (last_string, string))
 	  && !NILP (Fequal (last_parms, parms)))
 	{
 	  struct frame *f = XFRAME (tip_frame);
 	  /* Only DX and DY have changed.  */
 	  if (!NILP (tip_timer))
 	    {
 	      Lisp_Object timer = tip_timer;
 	      tip_timer = Qnil;
 	  last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
 	  row_width = row->pixel_width - last->pixel_width;
 	}
 else
 	row_width = row->pixel_width;
 height += row->height;
 width = max (width, row_width);
 }
 /* Add the frame's internal border to the width and height the X
 struct gcpro gcpro1, gcpro2;
 /* Return quickly if nothing to do.  */
 if (NILP (tip_timer) && NILP (tip_frame))
 return Qnil;
 frame = tip_frame;
 timer = tip_timer;
 GCPRO2 (frame, timer);
 tip_frame = tip_timer = deleted = Qnil;
 count = SPECPDL_INDEX ();
 specbind (Qinhibit_redisplay, Qt);
 specbind (Qinhibit_quit, Qt);
 if (!NILP (timer))
 call1 (Qcancel_timer, timer);
 if (FRAMEP (frame))
 {
 DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
 (spec)
 Lisp_Object spec;
 {
 int id = -1;
 if (valid_image_p (spec))
 id = lookup_image (SELECTED_FRAME (), spec);
 debug_print (spec);
 return make_number (id);
 Vx_hourglass_pointer_shape = Qnil;
 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
 	       doc: /* Non-zero means Emacs displays an hourglass pointer on window systems.  */);
 display_hourglass_p = 1;
 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
 	       doc: /* *Seconds to wait before displaying an hourglass pointer.
 Value must be an integer or float.  */);
 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
 #if HAVE_XPM
 Qxpm = intern ("xpm");
 staticpro (&Qxpm);
 #endif
 #if HAVE_JPEG
 Qjpeg = intern ("jpeg");
 staticpro (&Qjpeg);
 #endif
 #if HAVE_TIFF
 Qtiff = intern ("tiff");
 staticpro (&Qtiff);
 #endif
 #if HAVE_GIF
 Qgif = intern ("gif");
 staticpro (&Qgif);
 #endif
 define_image_type (&xbm_type);
 #if 0 /* NTEMACS_TODO : Image support for W32 */
 define_image_type (&gs_type);
 define_image_type (&pbm_type);
 #if HAVE_XPM
 define_image_type (&xpm_type);
 #endif
 #if HAVE_JPEG
 define_image_type (&jpeg_type);
 #endif
 #if HAVE_TIFF
 define_image_type (&tiff_type);
 #endif
 #if HAVE_GIF
 define_image_type (&gif_type);
 #endif
 #if HAVE_PNG
 define_image_type (&png_type);
 #endif
 #endif /* NTEMACS_TODO */
 }

Mercurial > emacs

comparison src/macfns.c @ 47278:fc811b81d1a3