xemacs-beta: src/glyphs.c comparison

comparison src/glyphs.c @ 440:8de8e3f6228a r21-2-28

Import from CVS: tag r21-2-28

author	cvs
date	Mon, 13 Aug 2007 11:33:38 +0200
parents	84b14dcb0985
children	abe6d1db359e

comparison

equal deleted inserted replaced

-:357dd071b03c
+:8de8e3f6228a
 	  Lisp_Object d = Dynarr_at (the_image_instantiator_format_entry_dynarr, i).
 	    device;
 	  if ((NILP (d) && NILP (device))
 	      ||
 	      (!NILP (device) &&
 	       EQ (CONSOLE_TYPE (XCONSOLE
 				 (DEVICE_CONSOLE (XDEVICE (device)))), d)))
 	    return Dynarr_at (the_image_instantiator_format_entry_dynarr, i).meths;
 	}
 }
 {
 struct gcpro gcpro1;
 struct image_instantiator_methods *meths;
 GCPRO1 (instantiator);
 meths = decode_image_instantiator_format (XVECTOR_DATA (instantiator)[0],
 					      ERROR_ME);
 RETURN_UNGCPRO (IIFORMAT_METH_OR_GIVEN (meths, normalize,
 					    (instantiator, contype),
 					    instantiator));
 meths = decode_image_instantiator_format (XVECTOR_DATA (instantiator)[0],
 					    ERROR_ME);
 methp = (int)HAS_IIFORMAT_METH_P (meths, instantiate);
 MAYBE_IIFORMAT_METH (meths, instantiate, (ii, instantiator, pointer_fg,
 					    pointer_bg, dest_mask, domain));
 /* now do device specific instantiation */
 meths = decode_device_ii_format (device, XVECTOR_DATA (instantiator)[0],
 				   ERROR_ME_NOT);
 if (!methp && (!meths || !HAS_IIFORMAT_METH_P (meths, instantiate)))
 Lisp_Object Qimage_instancep;
 static Lisp_Object
 mark_image_instance (Lisp_Object obj)
 {
-struct Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
+Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
 mark_object (i->name);
 /* We don't mark the glyph reference since that would create a
 circularity preventing GC. */
 switch (IMAGE_INSTANCE_TYPE (i))
 mark_object (IMAGE_INSTANCE_PIXMAP_FG (i));
 mark_object (IMAGE_INSTANCE_PIXMAP_BG (i));
 break;
 case IMAGE_WIDGET:
+case IMAGE_LAYOUT:
 mark_object (IMAGE_INSTANCE_WIDGET_TYPE (i));
 mark_object (IMAGE_INSTANCE_WIDGET_PROPS (i));
 mark_object (IMAGE_INSTANCE_WIDGET_FACE (i));
 mark_object (IMAGE_INSTANCE_WIDGET_ITEMS (i));
 case IMAGE_SUBWINDOW:
 mark_object (IMAGE_INSTANCE_SUBWINDOW_FRAME (i));
 break;
-case IMAGE_LAYOUT:
-mark_object (IMAGE_INSTANCE_LAYOUT_CHILDREN (i));
-mark_object (IMAGE_INSTANCE_LAYOUT_BORDER (i));
-mark_object (IMAGE_INSTANCE_SUBWINDOW_FRAME (i));
-break;
 default:
 break;
 }
 MAYBE_DEVMETH (XDEVICE (i->device), mark_image_instance, (i));
 static void
 print_image_instance (Lisp_Object obj, Lisp_Object printcharfun,
 		      int escapeflag)
 {
 char buf[100];
-struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (obj);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (obj);
 if (print_readably)
 error ("printing unreadable object #<image-instance 0x%x>",
 ii->header.uid);
 write_c_string ("#<image-instance (", printcharfun);
 	 description what that frame is. */
 write_c_string (" on #<", printcharfun);
 {
 	struct frame* f  = XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii));
 	if (!FRAME_LIVE_P (f))
 	  write_c_string ("dead", printcharfun);
 	else
 	  write_c_string (DEVICE_TYPE_NAME (XDEVICE (FRAME_DEVICE (f))),
 			  printcharfun);
 	write_c_string ("-frame ", printcharfun);
 }
 write_c_string (">", printcharfun);
 sprintf (buf, " 0x%p", IMAGE_INSTANCE_SUBWINDOW_ID (ii));
 write_c_string (buf, printcharfun);
 break;
 default:
 abort ();
 }
 }
 static void
 finalize_image_instance (void *header, int for_disksave)
 {
-struct Lisp_Image_Instance *i = (struct Lisp_Image_Instance *) header;
+Lisp_Image_Instance *i = (Lisp_Image_Instance *) header;
 if (IMAGE_INSTANCE_TYPE (i) == IMAGE_NOTHING)
 /* objects like this exist at dump time, so don't bomb out. */
 return;
 if (for_disksave) finalose (i);
 /* do this so that the cachels get reset */
 if (IMAGE_INSTANCE_TYPE (i) == IMAGE_WIDGET
 ||
 IMAGE_INSTANCE_TYPE (i) == IMAGE_SUBWINDOW)
 {
 MARK_FRAME_SUBWINDOWS_CHANGED
 	(XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (i)));
 }
 MAYBE_DEVMETH (XDEVICE (i->device), finalize_image_instance, (i));
 }
 static int
 image_instance_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
-struct Lisp_Image_Instance *i1 = XIMAGE_INSTANCE (obj1);
+Lisp_Image_Instance *i1 = XIMAGE_INSTANCE (obj1);
-struct Lisp_Image_Instance *i2 = XIMAGE_INSTANCE (obj2);
+Lisp_Image_Instance *i2 = XIMAGE_INSTANCE (obj2);
 struct device *d1 = XDEVICE (i1->device);
 struct device *d2 = XDEVICE (i2->device);
 if (d1 != d2)
 return 0;
 			    depth + 1)))
 	return 0;
 break;
 case IMAGE_WIDGET:
+case IMAGE_LAYOUT:
 if (!(EQ (IMAGE_INSTANCE_WIDGET_TYPE (i1),
 		IMAGE_INSTANCE_WIDGET_TYPE (i2))
 	    && IMAGE_INSTANCE_SUBWINDOW_ID (i1) ==
 	    IMAGE_INSTANCE_SUBWINDOW_ID (i2)
 	    && internal_equal (IMAGE_INSTANCE_WIDGET_ITEMS (i1),
 			       IMAGE_INSTANCE_WIDGET_PROPS (i2),
 			       depth + 1)
 	    ))
 	return 0;
 break;
-case IMAGE_LAYOUT:
-if (IMAGE_INSTANCE_TYPE (i1) == IMAGE_LAYOUT
-	  &&
-	  !(EQ (IMAGE_INSTANCE_LAYOUT_BORDER (i1),
-		IMAGE_INSTANCE_LAYOUT_BORDER (i2))
-	    &&
-	    internal_equal (IMAGE_INSTANCE_LAYOUT_CHILDREN (i1),
-			    IMAGE_INSTANCE_LAYOUT_CHILDREN (i2),
-			    depth + 1)))
-	return 0;
-break;
 case IMAGE_SUBWINDOW:
 if (!(IMAGE_INSTANCE_SUBWINDOW_ID (i1) ==
 	    IMAGE_INSTANCE_SUBWINDOW_ID (i2)))
 	return 0;
 break;
 }
 static unsigned long
 image_instance_hash (Lisp_Object obj, int depth)
 {
-struct Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
+Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
 struct device *d = XDEVICE (i->device);
 unsigned long hash = HASH3 ((unsigned long) d,
 			      IMAGE_INSTANCE_WIDTH (i),
 			      IMAGE_INSTANCE_HEIGHT (i));
 		    internal_hash (IMAGE_INSTANCE_PIXMAP_FILENAME (i),
 				   depth + 1));
 break;
 case IMAGE_WIDGET:
-hash = HASH4 (hash,
+case IMAGE_LAYOUT:
+hash = HASH4 (hash,
 		    internal_hash (IMAGE_INSTANCE_WIDGET_TYPE (i), depth + 1),
 		    internal_hash (IMAGE_INSTANCE_WIDGET_PROPS (i), depth + 1),
 		    internal_hash (IMAGE_INSTANCE_WIDGET_ITEMS (i), depth + 1));
 case IMAGE_SUBWINDOW:
 hash = HASH2 (hash, (int) IMAGE_INSTANCE_SUBWINDOW_ID (i));
 break;
-case IMAGE_LAYOUT:
-hash = HASH3 (hash,
-		    internal_hash (IMAGE_INSTANCE_LAYOUT_BORDER (i), depth + 1),
-		    internal_hash (IMAGE_INSTANCE_LAYOUT_CHILDREN (i),
-				   depth + 1));
-break;
 default:
 abort ();
 }
 return HASH2 (hash, DEVMETH_OR_GIVEN (d, image_instance_hash, (i, depth),
 DEFINE_LRECORD_IMPLEMENTATION ("image-instance", image_instance,
 			       mark_image_instance, print_image_instance,
 			       finalize_image_instance, image_instance_equal,
 			       image_instance_hash, 0,
-			       struct Lisp_Image_Instance);
+			       Lisp_Image_Instance);
 static Lisp_Object
 allocate_image_instance (Lisp_Object device, Lisp_Object glyph)
 {
-struct Lisp_Image_Instance *lp =
+Lisp_Image_Instance *lp =
-alloc_lcrecord_type (struct Lisp_Image_Instance, &lrecord_image_instance);
+alloc_lcrecord_type (Lisp_Image_Instance, &lrecord_image_instance);
 Lisp_Object val;
 zero_lcrecord (lp);
 lp->device = device;
 lp->type = IMAGE_NOTHING;
 If DEST-TYPES is omitted, all possible types are allowed.
 NO-ERROR controls what happens when the image cannot be generated.
 If nil, an error message is generated.  If t, no messages are
 generated and this function returns nil.  If anything else, a warning
 message is generated and this function returns nil.
 */
 (data, device, dest_types, no_error))
 {
 Error_behavior errb = decode_error_behavior_flag (no_error);
 else
 return Qnil;
 }
 DEFUN ("image-instance-property", Fimage_instance_property, 2, 2, 0, /*
 Return the given property of the given image instance.
 Returns nil if the property or the property method do not exist for
 the image instance in the domain.
 */
 (image_instance, prop))
 {
-struct Lisp_Image_Instance* ii;
+Lisp_Image_Instance* ii;
 Lisp_Object type, ret;
 struct image_instantiator_methods* meths;
 CHECK_IMAGE_INSTANCE (image_instance);
 CHECK_SYMBOL (prop);
 ii = XIMAGE_INSTANCE (image_instance);
 /* ... then try device specific methods ... */
 type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii),
 				   type, ERROR_ME_NOT);
 if (meths && HAS_IIFORMAT_METH_P (meths, property)
 &&
 !UNBOUNDP (ret =  IIFORMAT_METH (meths, property, (image_instance, prop))))
 {
 return ret;
 }
 /* ... then format specific methods ... */
 /* ... then fail */
 return Qnil;
 }
 DEFUN ("set-image-instance-property", Fset_image_instance_property, 3, 3, 0, /*
 Set the given property of the given image instance.
 Does nothing if the property or the property method do not exist for
 the image instance in the domain.
 */
 (image_instance, prop, val))
 {
-struct Lisp_Image_Instance* ii;
+Lisp_Image_Instance* ii;
 Lisp_Object type, ret;
 struct image_instantiator_methods* meths;
 CHECK_IMAGE_INSTANCE (image_instance);
 CHECK_SYMBOL (prop);
 ii = XIMAGE_INSTANCE (image_instance);
 type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
 /* try device specific methods first ... */
 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii),
 				   type, ERROR_ME_NOT);
 if (meths && HAS_IIFORMAT_METH_P (meths, set_property)
 &&
 !UNBOUNDP (ret =
 		 IIFORMAT_METH (meths, set_property, (image_instance, prop, val))))
 {
 val = ret;
 }
 else
 {
 /* ... then format specific methods ... */
 meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
 if (meths && HAS_IIFORMAT_METH_P (meths, set_property)
 	  &&
 	  !UNBOUNDP (ret =
 		     IIFORMAT_METH (meths, set_property, (image_instance, prop, val))))
 	{
 	  val = ret;
 	}
 else
 	{
 	  val = Qnil;
 	}
 }
-/* Make sure the image instance gets redisplayed. */
+/* Make sure the image instance gets redisplayed.
+### This currently does not change the dirty state of an
+enclosing layout which may be bad. */
 MARK_IMAGE_INSTANCE_CHANGED (ii);
 MARK_SUBWINDOWS_STATE_CHANGED;
 MARK_GLYPHS_CHANGED;
 return val;
 return XIMAGE_INSTANCE_PIXMAP_FG (image_instance);
 case IMAGE_WIDGET:
 return FACE_FOREGROUND (
 			      XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
 			      XIMAGE_INSTANCE_SUBWINDOW_FRAME
 			      (image_instance));
 default:
 return Qnil;
 }
 return XIMAGE_INSTANCE_PIXMAP_BG (image_instance);
 case IMAGE_WIDGET:
 return FACE_BACKGROUND (
 			      XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
 			      XIMAGE_INSTANCE_SUBWINDOW_FRAME
 			      (image_instance));
 default:
 return Qnil;
 }
 /************************************************************************/
 /* Find out desired geometry of the image instance. If there is no
 special function then just return the width and / or height. */
 void
 image_instance_query_geometry (Lisp_Object image_instance,
 			       unsigned int* width, unsigned int* height,
 			       enum image_instance_geometry disp,
 			       Lisp_Object domain)
 {
-struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object type;
 struct image_instantiator_methods* meths;
 type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
 meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
 if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry))
 {
 IIFORMAT_METH (meths, query_geometry, (image_instance, width, height,
 					     disp, domain));
 }
 else
 {
 if (width)
 function relatively simple to take account of that. An alternative
 approach is to consider separately the two cases, one where you
 don't mind what size you have (normal widgets) and one where you
 want to specifiy something (layout widgets). */
 void
 image_instance_layout (Lisp_Object image_instance,
 		       unsigned int width, unsigned int height,
 		       Lisp_Object domain)
 {
-struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object type;
 struct image_instantiator_methods* meths;
 type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
 meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
 unsigned int dwidth, dheight;
 /* Get the desired geometry. */
 if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry))
 	{
 	  IIFORMAT_METH (meths, query_geometry, (image_instance, &dwidth, &dheight,
 						 IMAGE_DESIRED_GEOMETRY,
 						 domain));
 	}
 else
 	{
 	  dwidth = IMAGE_INSTANCE_WIDTH (ii);
 /* At this point width and height should contain sane values. Thus
 we set the glyph geometry and lay it out. */
 IMAGE_INSTANCE_WIDTH (ii) = width;
 IMAGE_INSTANCE_HEIGHT (ii) = height;
 if (meths && HAS_IIFORMAT_METH_P (meths, layout))
 {
 IIFORMAT_METH (meths, layout, (image_instance, width, height, domain));
 }
 /* else no change to the geometry. */
+XIMAGE_INSTANCE_DIRTYP (image_instance) = 0;
+}
+/*
+* Mark image instance in W as dirty if (a) W's faces have changed and
+* (b) GLYPH_OR_II instance in W is a string.
+*
+* Return non-zero if instance has been marked dirty.
+*/
+int
+invalidate_glyph_geometry_maybe (Lisp_Object glyph_or_ii, struct window* w)
+{
+if (XFRAME(WINDOW_FRAME(w))->faces_changed)
+{
+Lisp_Object image = glyph_or_ii;
+if (GLYPHP (glyph_or_ii))
+	{
+	  Lisp_Object window;
+	  XSETWINDOW (window, w);
+	  image = glyph_image_instance (glyph_or_ii, window, ERROR_ME_NOT, 1);
+	}
+if (TEXT_IMAGE_INSTANCEP (image))
+	{
+	  XIMAGE_INSTANCE_DIRTYP (image) = 1;
+	  if (GLYPHP (glyph_or_ii))
+	    XGLYPH_DIRTYP (glyph_or_ii) = 1;
+	  return 1;
+	}
+}
+return 0;
 }
 /************************************************************************/
 /*                              error helpers                           */
 static void
 nothing_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		     Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		     int dest_mask, Lisp_Object domain)
 {
-struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 if (dest_mask & IMAGE_NOTHING_MASK)
 IMAGE_INSTANCE_TYPE (ii) = IMAGE_NOTHING;
 else
 incompatible_image_types (instantiator, dest_mask, IMAGE_NOTHING_MASK);
 string_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		    Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		    int dest_mask, Lisp_Object domain)
 {
 Lisp_Object string = find_keyword_in_vector (instantiator, Q_data);
-struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 /* Should never get here with a domain other than a window. */
 assert (!NILP (string) && WINDOWP (domain));
 if (dest_mask & IMAGE_TEXT_MASK)
 {
 IMAGE_INSTANCE_TYPE (ii) = IMAGE_TEXT;
 everything. Note that the following methods are for text not string
 since that is what the instantiated type is. The first method is a
 helper that is used elsewhere for calculating text geometry. */
 void
 query_string_geometry (Lisp_Object string, Lisp_Object face,
 		       unsigned int* width, unsigned int* height,
 		       unsigned int* descent, Lisp_Object domain)
 {
 struct font_metric_info fm;
 unsigned char charsets[NUM_LEADING_BYTES];
 struct face_cachel frame_cachel;
 {
 /* Compute string metric info */
 find_charsets_in_bufbyte_string (charsets,
 				       XSTRING_DATA   (string),
 				       XSTRING_LENGTH (string));
 /* Fallback to the default face if none was provided. */
 if (!NILP (face))
 	{
 	  reset_face_cachel (&frame_cachel);
 	  update_face_cachel_data (&frame_cachel, frame, face);
 	}
 else
 	{
 	  cachel = WINDOW_FACE_CACHEL (XWINDOW (domain), DEFAULT_INDEX);
 	}
 ensure_face_cachel_complete (cachel, domain, charsets);
 face_cachel_charset_font_metric_info (cachel, charsets, &fm);
 *height = fm.ascent + fm.descent;
 /* #### descent only gets set if we query the height as well. */
 if (descent)
 	*descent = fm.descent;
 }
 /* Compute width */
 if (width)
 {
 if (!NILP (face))
 	*width = redisplay_frame_text_width_string (XFRAME (frame),
 /* Compute string font info */
 find_charsets_in_bufbyte_string (charsets,
 				   XSTRING_DATA   (string),
 				   XSTRING_LENGTH (string));
 reset_face_cachel (&frame_cachel);
 update_face_cachel_data (&frame_cachel, frame, face);
 cachel = &frame_cachel;
 ensure_face_cachel_complete (cachel, domain, charsets);
 for (i = 0; i < NUM_LEADING_BYTES; i++)
 {
 if (charsets[i])
 	{
 	  return FACE_CACHEL_FONT (cachel,
 				   CHARSET_BY_LEADING_BYTE (i +
 							    MIN_LEADING_BYTE));
 	}
 }
 return Qnil;			/* NOT REACHED */
 }
 static void
 text_query_geometry (Lisp_Object image_instance,
 		     unsigned int* width, unsigned int* height,
 		     enum image_instance_geometry disp, Lisp_Object domain)
 {
-struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 unsigned int descent = 0;
 query_string_geometry (IMAGE_INSTANCE_TEXT_STRING (ii),
 			 IMAGE_INSTANCE_FACE (ii),
 			 width, height, &descent, domain);
 /* set the properties of a string */
 static Lisp_Object
 text_set_property (Lisp_Object image_instance, Lisp_Object prop,
 		   Lisp_Object val)
 {
-struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 if (EQ (prop, Q_data))
 {
 CHECK_STRING (val);
 IMAGE_INSTANCE_TEXT_STRING (ii) = val;
 {
 /* #### implement this */
 warn_when_safe (Qunimplemented, Qnotice,
 		  "`formatted-string' not yet implemented; assuming `string'");
 string_instantiate (image_instance, instantiator,
 		      pointer_fg, pointer_bg, dest_mask, domain);
 }
 /************************************************************************/
 unsigned int w, h;
 Extbyte *data;
 int result;
 CONST char *filename_ext;
-GET_C_STRING_FILENAME_DATA_ALLOCA (name, filename_ext);
+TO_EXTERNAL_FORMAT (LISP_STRING, name,
+		      C_STRING_ALLOCA, filename_ext,
+		      Qfile_name);
 result = read_bitmap_data_from_file (filename_ext, &w, &h,
 				       &data, xhot, yhot);
 if (result == BitmapSuccess)
 {
 Lisp_Object retval;
 int len = (w + 7) / 8 * h;
 retval = list3 (make_int (w), make_int (h),
-		      make_ext_string (data, len, FORMAT_BINARY));
+		      make_ext_string (data, len, Qbinary));
 XFree ((char *) data);
 return retval;
 }
 switch (result)
 pixmap_to_lisp_data (Lisp_Object name, int ok_if_data_invalid)
 {
 char **data;
 int result;
 char *fname = 0;
-GET_C_STRING_FILENAME_DATA_ALLOCA (name, fname);
+TO_EXTERNAL_FORMAT (LISP_STRING, name,
+		      C_STRING_ALLOCA, fname,
+		      Qfile_name);
 result = XpmReadFileToData (fname, &data);
 if (result == XpmSuccess)
 {
 Lisp_Object retval = Qnil;
 DEFINE_SPECIFIER_TYPE (image);
 static void
 image_create (Lisp_Object obj)
 {
-struct Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
+Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
 IMAGE_SPECIFIER_ALLOWED (image) = ~0; /* all are allowed */
 IMAGE_SPECIFIER_ATTACHEE (image) = Qnil;
 IMAGE_SPECIFIER_ATTACHEE_PROPERTY (image) = Qnil;
 }
 static void
 image_mark (Lisp_Object obj)
 {
-struct Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
+Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
 mark_object (IMAGE_SPECIFIER_ATTACHEE (image));
 mark_object (IMAGE_SPECIFIER_ATTACHEE_PROPERTY (image));
 }
 if (UNBOUNDP (subtable))
 	{
 	  /* For the image instance cache, we do comparisons with EQ rather
 	     than with EQUAL, as we do for color and font names.
 	     The reasons are:
 	     1) pixmap data can be very long, and thus the hashing and
 	     comparing will take awhile.
 	     2) It's not so likely that we'll run into things that are EQUAL
 	     but not EQ (that can happen a lot with faces, because their
 	     specifiers are copied around); but pixmaps tend not to be
 	     will occur most of the time so this probably slows things
 	     down. But with the current design I don't see anyway
 	     round it. */
 	  if (UNBOUNDP (instance)
 	      &&
 	      dest_mask & (IMAGE_SUBWINDOW_MASK
 			   | IMAGE_WIDGET_MASK
 			   | IMAGE_TEXT_MASK))
 	    {
 	      if (!WINDOWP (domain))
 		signal_simple_error ("Can't instantiate text or subwindow outside a window",
 				     instantiator);
 	      instance = Fgethash (instantiator,
 				   XWINDOW (domain)->subwindow_instance_cache,
 				   Qunbound);
 	    }
 	}
 if (UNBOUNDP (instance))
 	  Lisp_Object locative =
 	    noseeum_cons (Qnil,
 			  noseeum_cons (pointerp ? ls3 : instantiator,
 					subtable));
 	  int speccount = specpdl_depth ();
 	  /* make sure we cache the failures, too.
 	     Use an unwind-protect to catch such errors.
 	     If we fail, the unwind-protect records nil in
 	     the hash table.  If we succeed, we change the
 	     car of the locative to the resulting instance,
 						     domain,
 						     instantiator,
 						     pointer_fg, pointer_bg,
 						     dest_mask,
 						     glyph);
 	  Fsetcar (locative, instance);
 	  /* only after the image has been instantiated do we know
 whether we need to put it in the per-window image instance
 cache. */
 	  if (image_instance_type_to_mask (XIMAGE_INSTANCE_TYPE (instance))
 	      (IMAGE_SUBWINDOW_MASK | IMAGE_WIDGET_MASK))
 	    {
 	      if (!WINDOWP (domain))
 		signal_simple_error ("Can't instantiate subwindow outside a window",
 				     instantiator);
 	      Fsetcdr (XCDR (locative), XWINDOW (domain)->subwindow_instance_cache );
 	    }
 	  unbind_to (speccount, Qnil);
 	}
 else
 void
 set_image_attached_to (Lisp_Object obj, Lisp_Object face_or_glyph,
 		       Lisp_Object property)
 {
-struct Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
+Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
 IMAGE_SPECIFIER_ATTACHEE (image) = face_or_glyph;
 IMAGE_SPECIFIER_ATTACHEE_PROPERTY (image) = property;
 }
 CHECK_VECTOR (instantiator);
 instantiator = Fcopy_sequence (instantiator);
 elt = XVECTOR_DATA (instantiator);
 instantiator_len = XVECTOR_LENGTH (instantiator);
 meths = decode_image_instantiator_format (elt[0], ERROR_ME);
 for (i = 1; i < instantiator_len; i += 2)
 {
 int j;
 ****************************************************************************/
 static Lisp_Object
 mark_glyph (Lisp_Object obj)
 {
-struct Lisp_Glyph *glyph = XGLYPH (obj);
+Lisp_Glyph *glyph = XGLYPH (obj);
 mark_object (glyph->image);
 mark_object (glyph->contrib_p);
 mark_object (glyph->baseline);
 mark_object (glyph->face);
 }
 static void
 print_glyph (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-struct Lisp_Glyph *glyph = XGLYPH (obj);
+Lisp_Glyph *glyph = XGLYPH (obj);
 char buf[20];
 if (print_readably)
 error ("printing unreadable object #<glyph 0x%x>", glyph->header.uid);
 This isn't concerned with "unspecified" attributes, that's what
 #'glyph-differs-from-default-p is for. */
 static int
 glyph_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
-struct Lisp_Glyph *g1 = XGLYPH (obj1);
+Lisp_Glyph *g1 = XGLYPH (obj1);
-struct Lisp_Glyph *g2 = XGLYPH (obj2);
+Lisp_Glyph *g2 = XGLYPH (obj2);
 depth++;
 return (internal_equal (g1->image,     g2->image,     depth) &&
 	  internal_equal (g1->contrib_p, g2->contrib_p, depth) &&
 }
 static Lisp_Object
 glyph_getprop (Lisp_Object obj, Lisp_Object prop)
 {
-struct Lisp_Glyph *g = XGLYPH (obj);
+Lisp_Glyph *g = XGLYPH (obj);
 if (EQ (prop, Qimage))     return g->image;
 if (EQ (prop, Qcontrib_p)) return g->contrib_p;
 if (EQ (prop, Qbaseline))  return g->baseline;
 if (EQ (prop, Qface))      return g->face;
 }
 static Lisp_Object
 glyph_plist (Lisp_Object obj)
 {
-struct Lisp_Glyph *glyph = XGLYPH (obj);
+Lisp_Glyph *glyph = XGLYPH (obj);
 Lisp_Object result = glyph->plist;
 result = cons3 (Qface,      glyph->face,      result);
 result = cons3 (Qbaseline,  glyph->baseline,  result);
 result = cons3 (Qcontrib_p, glyph->contrib_p, result);
 return result;
 }
 static const struct lrecord_description glyph_description[] = {
-{ XD_LISP_OBJECT, offsetof(struct Lisp_Glyph, image), 5 },
+{ XD_LISP_OBJECT, offsetof (Lisp_Glyph, image) },
+{ XD_LISP_OBJECT, offsetof (Lisp_Glyph, contrib_p) },
+{ XD_LISP_OBJECT, offsetof (Lisp_Glyph, baseline) },
+{ XD_LISP_OBJECT, offsetof (Lisp_Glyph, face) },
+{ XD_LISP_OBJECT, offsetof (Lisp_Glyph, plist) },
 { XD_END }
 };
 DEFINE_LRECORD_IMPLEMENTATION_WITH_PROPS ("glyph", glyph,
 					  mark_glyph, print_glyph, 0,
 					  glyph_equal, glyph_hash, glyph_description,
 					  glyph_getprop, glyph_putprop,
 					  glyph_remprop, glyph_plist,
-					  struct Lisp_Glyph);
+					  Lisp_Glyph);
 Lisp_Object
 allocate_glyph (enum glyph_type type,
 		void (*after_change) (Lisp_Object glyph, Lisp_Object property,
 				      Lisp_Object locale))
 {
 /* This function can GC */
 Lisp_Object obj = Qnil;
-struct Lisp_Glyph *g =
+Lisp_Glyph *g = alloc_lcrecord_type (Lisp_Glyph, &lrecord_glyph);
-alloc_lcrecord_type (struct Lisp_Glyph, &lrecord_glyph);
 g->type = type;
 g->image = Fmake_specifier (Qimage); /* This function can GC */
 g->dirty = 0;
 switch (g->type)
 {
 case GLYPH_BUFFER:
 XIMAGE_SPECIFIER_ALLOWED (g->image) =
 	IMAGE_NOTHING_MASK | IMAGE_TEXT_MASK
 	| IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
 	| IMAGE_SUBWINDOW_MASK | IMAGE_WIDGET_MASK
 	| IMAGE_LAYOUT_MASK;
 break;
 case GLYPH_POINTER:
 XIMAGE_SPECIFIER_ALLOWED (g->image) =
 {
 Lisp_Object specifier = GLYPH_IMAGE (XGLYPH (glyph));
 /* This can never return Qunbound.  All glyphs have 'nothing as
 a fallback. */
 Lisp_Object image_instance = specifier_instance (specifier, Qunbound,
 						   domain, errb, no_quit, 0,
 						   Qzero);
+assert (!UNBOUNDP (image_instance));
 return image_instance;
 }
 static Lisp_Object
 unsigned short
 glyph_height (Lisp_Object glyph_or_image, Lisp_Object domain)
 {
 Lisp_Object instance = glyph_image_instance_maybe (glyph_or_image,
 						     domain);
 if (!IMAGE_INSTANCEP (instance))
 return 0;
 if (XIMAGE_INSTANCE_DIRTYP (instance))
 image_instance_layout (instance, IMAGE_UNSPECIFIED_GEOMETRY,
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
 return make_int (glyph_height (glyph, window));
-}
-static unsigned int
-glyph_dirty_p (Lisp_Object glyph_or_image, Lisp_Object window)
-{
-return XIMAGE_INSTANCE_DIRTYP (glyph_image_instance_maybe
-				 (glyph_or_image, window));
 }
 static void
 set_glyph_dirty_p (Lisp_Object glyph_or_image, Lisp_Object window, int dirty)
 {
 }
 #if 0				/* Not used for now */
 static void
 glyph_query_geometry (Lisp_Object glyph_or_image, Lisp_Object window,
 		      unsigned int* width, unsigned int* height,
 		      enum image_instance_geometry disp, Lisp_Object domain)
 {
 Lisp_Object instance = glyph_or_image;
 if (GLYPHP (glyph_or_image))
 instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
 image_instance_query_geometry (instance, width, height, disp, domain);
 }
 static void
 glyph_layout (Lisp_Object glyph_or_image, Lisp_Object window,
 {
 Lisp_Object instance = glyph_or_image;
 if (GLYPHP (glyph_or_image))
 instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
 image_instance_layout (instance, width, height, domain);
 }
 #endif
 static void
 update_glyph_cachel_data (struct window *w, Lisp_Object glyph,
 			  struct glyph_cachel *cachel)
 {
 if (!cachel->updated || NILP (cachel->glyph) || !EQ (cachel->glyph, glyph)
-|| XGLYPH_DIRTYP (cachel->glyph))
+|| XGLYPH_DIRTYP (cachel->glyph)
+|| XFRAME(WINDOW_FRAME(w))->faces_changed)
 {
 Lisp_Object window, instance;
 XSETWINDOW (window, w);
 cachel->glyph   = glyph;
 /* Speed things up slightly by grabbing the glyph instantiation
-and passing it to the size functions. */
+	 and passing it to the size functions. */
 instance = glyph_image_instance (glyph, window, ERROR_ME_NOT, 1);
-cachel->dirty = XGLYPH_DIRTYP (glyph) = glyph_dirty_p (glyph, window);
+/* Mark text instance of the glyph dirty if faces have changed,
+	 because its geometry might have changed. */
+invalidate_glyph_geometry_maybe (instance, w);
+/* #### Do the following 2 lines buy us anything? --kkm */
+XGLYPH_DIRTYP (glyph) = XIMAGE_INSTANCE_DIRTYP (instance);
+cachel->dirty   = XGLYPH_DIRTYP (glyph);
 cachel->width   = glyph_width   (instance, window);
 cachel->ascent  = glyph_ascent  (instance, window);
 cachel->descent = glyph_descent (instance, window);
 }
 Dynarr_atp (w->glyph_cachels, elt)->updated = 0;
 }
 }
 /* Unset the dirty bit on all the glyph cachels that have it. */
 void
 mark_glyph_cachels_as_clean (struct window* w)
 {
 int elt;
 Lisp_Object window;
 XSETWINDOW (window, w);
 for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
 {
 struct subwindow_cachel *cachel =
 	Dynarr_atp (f->subwindow_cachels, elt);
 if (EQ (cachel->subwindow, subwindow) && !NILP (subwindow))
 	{
 	  update_subwindow_cachel_data (f, subwindow, cachel);
 	}
 }
 /* Checking for exact matches just isn't good enough as we
 	 mighte get exposures for partially obscure subwindows, thus
 	 we have to check for overlaps. Being conservative we will
 	 check for exposures wholly contained by the subwindow, this
 	 might give us what we want.*/
 if (ei->x <= x && ei->y <= y
 	  && ei->x + ei->width >= x + width
 	  && ei->y + ei->height >= y + height)
 	{
 #ifdef DEBUG_WIDGETS
 	  stderr_out ("ignored %d+%d, %dx%d for exposure %d+%d, %dx%d\n",
 #endif
 	  if (!prev)
 	    f->subwindow_exposures = ei->next;
 	  else
 	    prev->next = ei->next;
 	  if (ei == f->subwindow_exposures_tail)
 	    f->subwindow_exposures_tail = prev;
 	  Blocktype_free (the_expose_ignore_blocktype, ei);
 	  return 1;
 register_ignored_expose (struct frame* f, int x, int y, int width, int height)
 {
 if (!hold_ignored_expose_registration)
 {
 struct expose_ignore *ei;
 ei = Blocktype_alloc (the_expose_ignore_blocktype);
 ei->next = NULL;
 ei->x = x;
 ei->y = y;
 ei->width = width;
 ei->height = height;
 /* we have to add the exposure to the end of the list, since we
 	 want to check the oldest events first. for speed we keep a record
 	 of the end so that we can add right to it. */
 if (f->subwindow_exposures_tail)
 	{
 	Dynarr_atp (f->subwindow_cachels, elt);
 if (cachel->being_displayed
 	  &&
 	  cachel->x <= x && cachel->y <= y
 	  &&
 	  cachel->x + cachel->width >= x + width
 	  &&
 	  cachel->y + cachel->height >= y + height)
 	{
 	  return 1;
 /* update the displayed characteristics of a subwindow */
 static void
 update_subwindow (Lisp_Object subwindow)
 {
-struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
+Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
 if (!IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
 ||
 NILP (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii)))
 return;
 if (f->subwindows_changed || f->subwindows_state_changed || f->faces_changed)
 for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
 {
 	struct subwindow_cachel *cachel =
 	  Dynarr_atp (f->subwindow_cachels, elt);
 	if (cachel->being_displayed)
 	  {
 	    update_subwindow (cachel->subwindow);
 	  }
 }
 }
 /* remove a subwindow from its frame */
 void unmap_subwindow (Lisp_Object subwindow)
 {
-struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
+Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
 int elt;
 struct subwindow_cachel* cachel;
 struct frame* f;
 if (!(IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
 /* show a subwindow in its frame */
 void map_subwindow (Lisp_Object subwindow, int x, int y,
 		    struct display_glyph_area *dga)
 {
-struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
+Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
 int elt;
 struct subwindow_cachel* cachel;
 struct frame* f;
 if (!(IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
 	||
 before we show it. I'm not sure whether or not we need mark as
 clean here, but for now we will. */
 if (IMAGE_INSTANCE_DIRTYP (ii))
 {
 update_subwindow (subwindow);
 IMAGE_INSTANCE_DIRTYP (ii) = 0;
 }
 MAYBE_DEVMETH (XDEVICE (ii->device), map_subwindow, (ii, x, y, dga));
 }
 void
 subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		       Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		       int dest_mask, Lisp_Object domain)
 {
-struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 Lisp_Object frame = FW_FRAME (domain);
 Lisp_Object width = find_keyword_in_vector (instantiator, Q_pixel_width);
 Lisp_Object height = find_keyword_in_vector (instantiator, Q_pixel_height);
 if (NILP (frame))
 signal_simple_error ("No selected frame", device);
 if (!(dest_mask & IMAGE_SUBWINDOW_MASK))
 incompatible_image_types (instantiator, dest_mask, IMAGE_SUBWINDOW_MASK);
 ii->data = 0;
 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = 0;
 IMAGE_INSTANCE_SUBWINDOW_FRAME (ii) = frame;
 /* #### This stuff may get overidden by the widget code and is
 actually really dumb now that we have dynamic geometry
 calculations. What should really happen is that the subwindow
-should query its child for and appropriate geometry. */
+should query its child for an appropriate geometry. */
 if (NILP (width))
 IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = 20;
 else
 {
 int w = 1;
 CHECK_WEAK_LIST (arg);
 if (!NILP (XWEAK_LIST_LIST (arg)) && !NILP (XCAR (XWEAK_LIST_LIST (arg))))
 {
 Lisp_Object value = XCAR (XWEAK_LIST_LIST (arg));
 if (IMAGE_INSTANCEP (value))
 	{
-	  struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (value);
+	  Lisp_Image_Instance* ii = XIMAGE_INSTANCE (value);
 	  if (COLOR_PIXMAP_IMAGE_INSTANCEP (value)
 	      &&
 	      IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii) > 1
 	      &&
 	      IMAGE_INSTANCE_PIXMAP_SLICE (ii) =
 		(IMAGE_INSTANCE_PIXMAP_SLICE (ii) + 1)
 		% IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii);
 	      /* We might need to kick redisplay at this point - but we
 		 also might not. */
 	      MARK_DEVICE_FRAMES_GLYPHS_CHANGED
 		(XDEVICE (IMAGE_INSTANCE_DEVICE (ii)));
 	      MARK_IMAGE_INSTANCE_CHANGED (ii);
 	    }
 	}
 }
 	    "image-conversion error", Qio_error);
 }
 static const struct lrecord_description image_specifier_description[] = {
-{ XD_LISP_OBJECT, specifier_data_offset + offsetof(struct image_specifier, attachee), 2 },
+{ XD_LISP_OBJECT, specifier_data_offset + offsetof (struct image_specifier, attachee) },
+{ XD_LISP_OBJECT, specifier_data_offset + offsetof (struct image_specifier, attachee_property) },
 { XD_END }
 };
 void
 specifier_type_create_image (void)
 REINITIALIZE_SPECIFIER_TYPE (image);
 }
 static const struct lrecord_description iike_description_1[] = {
-{ XD_LISP_OBJECT, offsetof(ii_keyword_entry, keyword), 1 },
+{ XD_LISP_OBJECT, offsetof (ii_keyword_entry, keyword) },
 { XD_END }
 };
 static const struct struct_description iike_description = {
-sizeof(ii_keyword_entry),
+sizeof (ii_keyword_entry),
 iike_description_1
 };
 static const struct lrecord_description iiked_description_1[] = {
-XD_DYNARR_DESC(ii_keyword_entry_dynarr, &iike_description),
+XD_DYNARR_DESC (ii_keyword_entry_dynarr, &iike_description),
 { XD_END }
 };
 static const struct struct_description iiked_description = {
-sizeof(ii_keyword_entry_dynarr),
+sizeof (ii_keyword_entry_dynarr),
 iiked_description_1
 };
 static const struct lrecord_description iife_description_1[] = {
-{ XD_LISP_OBJECT, offsetof(image_instantiator_format_entry, symbol), 2 },
+{ XD_LISP_OBJECT, offsetof (image_instantiator_format_entry, symbol) },
-{ XD_STRUCT_PTR,  offsetof(image_instantiator_format_entry, meths),  1, &iim_description },
+{ XD_LISP_OBJECT, offsetof (image_instantiator_format_entry, device) },
+{ XD_STRUCT_PTR,  offsetof (image_instantiator_format_entry, meths),  1, &iim_description },
 { XD_END }
 };
 static const struct struct_description iife_description = {
-sizeof(image_instantiator_format_entry),
+sizeof (image_instantiator_format_entry),
 iife_description_1
 };
 static const struct lrecord_description iifed_description_1[] = {
-XD_DYNARR_DESC(image_instantiator_format_entry_dynarr, &iife_description),
+XD_DYNARR_DESC (image_instantiator_format_entry_dynarr, &iife_description),
 { XD_END }
 };
 static const struct struct_description iifed_description = {
-sizeof(image_instantiator_format_entry_dynarr),
+sizeof (image_instantiator_format_entry_dynarr),
 iifed_description_1
 };
 static const struct lrecord_description iim_description_1[] = {
-{ XD_LISP_OBJECT, offsetof(struct image_instantiator_methods, symbol), 2 },
+{ XD_LISP_OBJECT, offsetof (struct image_instantiator_methods, symbol) },
-{ XD_STRUCT_PTR,  offsetof(struct image_instantiator_methods, keywords), 1, &iiked_description },
+{ XD_LISP_OBJECT, offsetof (struct image_instantiator_methods, device) },
-{ XD_STRUCT_PTR,  offsetof(struct image_instantiator_methods, consoles), 1, &cted_description },
+{ XD_STRUCT_PTR,  offsetof (struct image_instantiator_methods, keywords), 1, &iiked_description },
+{ XD_STRUCT_PTR,  offsetof (struct image_instantiator_methods, consoles), 1, &cted_description },
 { XD_END }
 };
 const struct struct_description iim_description = {
 sizeof(struct image_instantiator_methods),
 Vthe_nothing_vector = vector1 (Qnothing);
 staticpro (&Vthe_nothing_vector);
 /* image instances */
 Vimage_instance_type_list = Fcons (Qnothing,
 				     list6 (Qtext, Qmono_pixmap, Qcolor_pixmap,
 					    Qpointer, Qsubwindow, Qwidget));
 staticpro (&Vimage_instance_type_list);
 /* glyphs */

Mercurial > hg > xemacs-beta

comparison src/glyphs.c @ 440:8de8e3f6228a r21-2-28