xemacs-beta: src/glyphs.c comparison

comparison src/glyphs.c @ 408:501cfd01ee6d r21-2-34

Import from CVS: tag r21-2-34

author	cvs
date	Mon, 13 Aug 2007 11:18:11 +0200
parents	b8cc9ab3f761
children	de805c49cfc1

comparison

equal deleted inserted replaced

-:ed6218a7d4d3
+:501cfd01ee6d
 /* Generic glyph/image implementation + display tables
 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
 Copyright (C) 1995 Tinker Systems
-Copyright (C) 1995, 1996 Ben Wing
+Copyright (C) 1995, 1996, 2000 Ben Wing
 Copyright (C) 1995 Sun Microsystems
 Copyright (C) 1998, 1999, 2000 Andy Piper
 This file is part of XEmacs.
 rewritten by Andy Piper. */
 #include <config.h>
 #include "lisp.h"
+#include "blocktype.h"
 #include "buffer.h"
+#include "chartab.h"
 #include "device.h"
 #include "elhash.h"
 #include "faces.h"
 #include "frame.h"
+#include "glyphs.h"
 #include "insdel.h"
+#include "objects.h"
 #include "opaque.h"
-#include "objects.h"
+#include "rangetab.h"
 #include "redisplay.h"
+#include "specifier.h"
 #include "window.h"
-#include "frame.h"
-#include "chartab.h"
-#include "rangetab.h"
-#include "blocktype.h"
 #ifdef HAVE_XPM
 #include <X11/xpm.h>
 #endif
 Lisp_Object Qnothing_image_instance_p, Qtext_image_instance_p;
 Lisp_Object Qmono_pixmap_image_instance_p;
 Lisp_Object Qcolor_pixmap_image_instance_p;
 Lisp_Object Qpointer_image_instance_p;
 Lisp_Object Qsubwindow_image_instance_p;
-Lisp_Object Qlayout_image_instance_p;
-Lisp_Object Qupdate_widget_instances;
 Lisp_Object Qwidget_image_instance_p;
 Lisp_Object Qconst_glyph_variable;
 Lisp_Object Qmono_pixmap, Qcolor_pixmap, Qsubwindow;
 Lisp_Object Q_file, Q_data, Q_face, Q_pixel_width, Q_pixel_height;
 Lisp_Object Qformatted_string;
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (inherit);
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (string);
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (formatted_string);
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (subwindow);
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (text);
+DEFINE_IMAGE_INSTANTIATOR_FORMAT (pointer);
 #ifdef HAVE_WINDOW_SYSTEM
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (xbm);
 Lisp_Object Qxbm;
 typedef struct
 {
 Dynarr_declare (struct image_instantiator_format_entry);
 } image_instantiator_format_entry_dynarr;
+/* This contains one entry per format, per device it's defined on. */
 image_instantiator_format_entry_dynarr *
 the_image_instantiator_format_entry_dynarr;
-static Lisp_Object allocate_image_instance (Lisp_Object device, Lisp_Object glyph);
+static Lisp_Object allocate_image_instance (Lisp_Object governing_domain,
+					    Lisp_Object glyph);
 static void image_validate (Lisp_Object instantiator);
 static void glyph_property_was_changed (Lisp_Object glyph,
 					Lisp_Object property,
 					Lisp_Object locale);
 static void set_image_instance_dirty_p (Lisp_Object instance, int dirty);
 static void register_ignored_expose (struct frame* f, int x, int y, int width, int height);
+static void cache_subwindow_instance_in_frame_maybe (Lisp_Object instance);
 /* Unfortunately windows and X are different. In windows BeginPaint()
 will prevent WM_PAINT messages being generated so it is unnecessary
 to register exposures as they will not occur. Under X they will
 always occur. */
 int hold_ignored_expose_registration;
 DEFUN ("valid-image-instantiator-format-p", Fvalid_image_instantiator_format_p,
 1, 2, 0, /*
 Given an IMAGE-INSTANTIATOR-FORMAT, return non-nil if it is valid.
 If LOCALE is non-nil then the format is checked in that domain.
 If LOCALE is nil the current console is used.
 Valid formats are some subset of 'nothing, 'string, 'formatted-string,
 'xpm, 'xbm, 'xface, 'gif, 'jpeg, 'png, 'tiff, 'cursor-font, 'font,
-'autodetect, 'widget and 'subwindow, depending on how XEmacs was compiled.
+'autodetect, 'subwindow, 'inherit, 'mswindows-resource, 'bmp,
+'native-layout, 'layout, 'label, 'tab-control, 'tree-view,
+'progress-gauge, 'scrollbar, 'combo-box, 'edit-field, 'button,
+'widget, 'pointer, and 'text, depending on how XEmacs was compiled.
 */
 (image_instantiator_format, locale))
 {
-return valid_image_instantiator_format_p (image_instantiator_format, locale) ?
+return valid_image_instantiator_format_p (image_instantiator_format,
+					    locale) ?
 Qt : Qnil;
 }
 DEFUN ("image-instantiator-format-list", Fimage_instantiator_format_list,
 0, 0, 0, /*
 entry.symbol = symbol;
 entry.device = device;
 entry.meths = meths;
 Dynarr_add (the_image_instantiator_format_entry_dynarr, entry);
-Vimage_instantiator_format_list =
+if (NILP (memq_no_quit (symbol, Vimage_instantiator_format_list)))
-Fcons (symbol, Vimage_instantiator_format_list);
+Vimage_instantiator_format_list =
+Fcons (symbol, Vimage_instantiator_format_list);
 }
 void
 add_entry_to_image_instantiator_format_list (Lisp_Object symbol,
 					     struct
 }
 return Fvector (len, elt);
 }
+#ifdef ERROR_CHECK_GLYPHS
+static int
+check_instance_cache_mapper (Lisp_Object key, Lisp_Object value,
+			     void *flag_closure)
+{
+/* This function can GC */
+/* value can be nil; we cache failures as well as successes */
+if (!NILP (value))
+{
+Lisp_Object window;
+VOID_TO_LISP (window, flag_closure);
+assert (EQ (XIMAGE_INSTANCE_DOMAIN (value), window));
+}
+return 0;
+}
+void
+check_window_subwindow_cache (struct window* w)
+{
+Lisp_Object window;
+XSETWINDOW (window, w);
+assert (!NILP (w->subwindow_instance_cache));
+elisp_maphash (check_instance_cache_mapper,
+		 w->subwindow_instance_cache,
+		 LISP_TO_VOID (window));
+}
+void
+check_image_instance_structure (Lisp_Object instance)
+{
+/* Weird nothing images exist at startup when the console is
+deleted. */
+if (!NOTHING_IMAGE_INSTANCEP (instance))
+assert (DOMAIN_LIVE_P (instance));
+if (WINDOWP (XIMAGE_INSTANCE_DOMAIN (instance)))
+check_window_subwindow_cache
+(XWINDOW (XIMAGE_INSTANCE_DOMAIN (instance)));
+}
+#endif
+/* Determine what kind of domain governs the image instance.
+Verify that the given domain is at least as specific, and extract
+the governing domain from it. */
+static Lisp_Object
+get_image_instantiator_governing_domain (Lisp_Object instantiator,
+					 Lisp_Object domain)
+{
+int governing_domain;
+struct image_instantiator_methods *meths =
+decode_image_instantiator_format (XVECTOR_DATA (instantiator)[0],
+				      ERROR_ME);
+governing_domain = IIFORMAT_METH_OR_GIVEN (meths, governing_domain, (),
+					     GOVERNING_DOMAIN_DEVICE);
+if (governing_domain == GOVERNING_DOMAIN_WINDOW
+&& NILP (DOMAIN_WINDOW (domain)))
+signal_simple_error_2 ("Domain for this instantiator must be resolvable to a window",
+			   instantiator, domain);
+else if (governing_domain == GOVERNING_DOMAIN_FRAME
+	   && NILP (DOMAIN_FRAME (domain)))
+signal_simple_error_2
+("Domain for this instantiator must be resolvable to a frame",
+instantiator, domain);
+if (governing_domain == GOVERNING_DOMAIN_WINDOW)
+domain = DOMAIN_WINDOW (domain);
+else if (governing_domain == GOVERNING_DOMAIN_FRAME)
+domain = DOMAIN_FRAME (domain);
+else if (governing_domain == GOVERNING_DOMAIN_DEVICE)
+domain = DOMAIN_DEVICE (domain);
+else
+abort ();
+return domain;
+}
 static Lisp_Object
 normalize_image_instantiator (Lisp_Object instantiator,
 			      Lisp_Object contype,
 			      Lisp_Object dest_mask)
 {
 					    instantiator));
 }
 }
 static Lisp_Object
-instantiate_image_instantiator (Lisp_Object device, Lisp_Object domain,
+instantiate_image_instantiator (Lisp_Object governing_domain,
+				Lisp_Object domain,
 				Lisp_Object instantiator,
 				Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 				int dest_mask, Lisp_Object glyph)
 {
-Lisp_Object ii = allocate_image_instance (device, glyph);
+Lisp_Object ii = allocate_image_instance (governing_domain, glyph);
 Lisp_Image_Instance* p = XIMAGE_INSTANCE (ii);
-struct image_instantiator_methods *meths;
+struct image_instantiator_methods *meths, *device_meths;
 struct gcpro gcpro1;
-int  methp = 0;
 GCPRO1 (ii);
-if (!valid_image_instantiator_format_p (XVECTOR_DATA (instantiator)[0], device))
+if (!valid_image_instantiator_format_p (XVECTOR_DATA (instantiator)[0],
+					  DOMAIN_DEVICE (governing_domain)))
 signal_simple_error
 ("Image instantiator format is invalid in this locale.",
 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 */
+/* Now do device specific instantiation. */
-meths = decode_device_ii_format (device, XVECTOR_DATA (instantiator)[0],
+device_meths = decode_device_ii_format (DOMAIN_DEVICE (governing_domain),
-				   ERROR_ME_NOT);
+					  XVECTOR_DATA (instantiator)[0],
+					  ERROR_ME_NOT);
-if (!methp && (!meths || !HAS_IIFORMAT_METH_P (meths, instantiate)))
+if (!HAS_IIFORMAT_METH_P (meths, instantiate)
+&& (!device_meths || !HAS_IIFORMAT_METH_P (device_meths, instantiate)))
 signal_simple_error
 ("Don't know how to instantiate this image instantiator?",
 instantiator);
-MAYBE_IIFORMAT_METH (meths, instantiate, (ii, instantiator, pointer_fg,
-					    pointer_bg, dest_mask, domain));
+/* In general native window system methods will require sane
-UNGCPRO;
+geometry values, thus the instance needs to have been laid-out
+before they get called. */
-/* Some code may have already laid out the widget, if not then do it
+image_instance_layout (ii, XIMAGE_INSTANCE_WIDTH (ii),
-here. */
+			 XIMAGE_INSTANCE_HEIGHT (ii), domain);
+MAYBE_IIFORMAT_METH (device_meths, instantiate, (ii, instantiator, pointer_fg,
+						   pointer_bg, dest_mask, domain));
+/* Do post instantiation. */
+MAYBE_IIFORMAT_METH (meths, post_instantiate, (ii, instantiator, domain));
+MAYBE_IIFORMAT_METH (device_meths, post_instantiate, (ii, instantiator, domain));
+/* We're done. */
+IMAGE_INSTANCE_INITIALIZED (p) = 1;
+/* Now that we're done verify that we really are laid out. */
 if (IMAGE_INSTANCE_LAYOUT_CHANGED (p))
-image_instance_layout (ii, IMAGE_UNSPECIFIED_GEOMETRY,
+image_instance_layout (ii, XIMAGE_INSTANCE_WIDTH (ii),
-			   IMAGE_UNSPECIFIED_GEOMETRY, domain);
+			     XIMAGE_INSTANCE_HEIGHT (ii), domain);
 /* We *must* have a clean image at this point. */
 IMAGE_INSTANCE_TEXT_CHANGED (p) = 0;
 IMAGE_INSTANCE_SIZE_CHANGED (p) = 0;
 IMAGE_INSTANCE_LAYOUT_CHANGED (p) = 0;
 IMAGE_INSTANCE_DIRTYP (p) = 0;
-return ii;
+assert ( XIMAGE_INSTANCE_HEIGHT (ii)
+	      != IMAGE_UNSPECIFIED_GEOMETRY
+	      && XIMAGE_INSTANCE_WIDTH (ii)
+	      != IMAGE_UNSPECIFIED_GEOMETRY);
+ERROR_CHECK_IMAGE_INSTANCE (ii);
+RETURN_UNGCPRO (ii);
 }
 /****************************************************************************
 *                          Image-Instance Object                           *
 static Lisp_Object
 mark_image_instance (Lisp_Object obj)
 {
 Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
+/* #### I want to check the instance here, but there are way too
+many instances of the instance being marked while the domain is
+dead. For instance you can get marked through an event when using
+callback_ex.*/
+#if 0
+ERROR_CHECK_IMAGE_INSTANCE (obj);
+#endif
 mark_object (i->name);
+/* Is this legal in marking? We may get in the situation where the
+domain has been deleted - making the instance unusable. It seems
+better to remove the domain so that it can be finalized. */
+if (!DOMAIN_LIVE_P (i->domain))
+i->domain = Qnil;
+else
+mark_object (i->domain);
 /* We don't mark the glyph reference since that would create a
 circularity preventing GC. */
 switch (IMAGE_INSTANCE_TYPE (i))
 {
 case IMAGE_TEXT:
 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));
+mark_object (IMAGE_INSTANCE_LAYOUT_CHILDREN (i));
 mark_object (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (i));
 mark_object (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (i));
 mark_object (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (i));
 case IMAGE_SUBWINDOW:
-mark_object (IMAGE_INSTANCE_SUBWINDOW_FRAME (i));
 break;
 default:
 break;
 }
-MAYBE_DEVMETH (XDEVICE (i->device), mark_image_instance, (i));
+/* The image may have been previously finalized (yes that's wierd,
+see Fdelete_frame() and mark_window_as_deleted()), in which case
+the domain will be nil, so cope with this. */
+if (!NILP (IMAGE_INSTANCE_DEVICE (i)))
+MAYBE_DEVMETH (XDEVICE (IMAGE_INSTANCE_DEVICE (i)),
+		   mark_image_instance, (i));
 return i->device;
 }
 static void
 {
 print_internal (ii->name, printcharfun, 1);
 write_c_string (" ", printcharfun);
 }
 write_c_string ("on ", printcharfun);
-print_internal (ii->device, printcharfun, 0);
+print_internal (ii->domain, printcharfun, 0);
 write_c_string (" ", printcharfun);
 switch (IMAGE_INSTANCE_TYPE (ii))
 {
 case IMAGE_NOTHING:
 break;
 break;
 case IMAGE_WIDGET:
 print_internal (IMAGE_INSTANCE_WIDGET_TYPE (ii), printcharfun, 0);
-if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)))
+if (GUI_ITEMP (IMAGE_INSTANCE_WIDGET_ITEM (ii)))
 	{
 	  write_c_string (" ", printcharfun);
 	  print_internal (IMAGE_INSTANCE_WIDGET_TEXT (ii), printcharfun, 1);
 	}
 	    (IMAGE_INSTANCE_WIDGET_FACE (ii), printcharfun, 0);
 	}
 case IMAGE_SUBWINDOW:
-case IMAGE_LAYOUT:
+sprintf (buf, " %dx%d", IMAGE_INSTANCE_WIDTH (ii),
-sprintf (buf, " %dx%d", IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii),
+	       IMAGE_INSTANCE_HEIGHT (ii));
-	       IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii));
 write_c_string (buf, printcharfun);
 /* This is stolen from frame.c.  Subwindows are strange in that they
 	 are specific to a particular frame so we want to print in their
 	 description what that frame is. */
 write_c_string (" on #<", printcharfun);
 {
-	struct frame* f  = XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii));
+	struct frame* f  = XFRAME (IMAGE_INSTANCE_FRAME (ii));
 	if (!FRAME_LIVE_P (f))
 	  write_c_string ("dead", printcharfun);
 	else
 	  write_c_string (DEVICE_TYPE_NAME (XDEVICE (FRAME_DEVICE (f))),
 default:
 abort ();
 }
-MAYBE_DEVMETH (XDEVICE (ii->device), print_image_instance,
+MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain), print_image_instance,
 		 (ii, printcharfun, escapeflag));
 sprintf (buf, " 0x%x>", ii->header.uid);
 write_c_string (buf, printcharfun);
 }
 static void
 finalize_image_instance (void *header, int for_disksave)
 {
 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. */
-/* objects like this exist at dump time, so don't bomb out. */
+if (IMAGE_INSTANCE_TYPE (i) == IMAGE_NOTHING
+||
+NILP (IMAGE_INSTANCE_DEVICE (i)))
 return;
 if (for_disksave) finalose (i);
-/* do this so that the cachels get reset */
+/* We can't use the domain here, because it might have
-if (IMAGE_INSTANCE_TYPE (i) == IMAGE_WIDGET
+disappeared. */
-||
+MAYBE_DEVMETH (XDEVICE (IMAGE_INSTANCE_DEVICE (i)),
-IMAGE_INSTANCE_TYPE (i) == IMAGE_SUBWINDOW
+		 finalize_image_instance, (i));
-||
-IMAGE_INSTANCE_TYPE (i) == IMAGE_SUBWINDOW)
+/* Make sure we don't try this twice. */
-{
+IMAGE_INSTANCE_DEVICE (i) = Qnil;
-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)
 {
 Lisp_Image_Instance *i1 = XIMAGE_INSTANCE (obj1);
 Lisp_Image_Instance *i2 = XIMAGE_INSTANCE (obj2);
-struct device *d1 = XDEVICE (i1->device);
-struct device *d2 = XDEVICE (i2->device);
+ERROR_CHECK_IMAGE_INSTANCE (obj1);
+ERROR_CHECK_IMAGE_INSTANCE (obj2);
-if (d1 != d2)
-return 0;
+if (!EQ (IMAGE_INSTANCE_DOMAIN (i1),
-if (IMAGE_INSTANCE_TYPE (i1) != IMAGE_INSTANCE_TYPE (i2)
+	   IMAGE_INSTANCE_DOMAIN (i2))
+|| IMAGE_INSTANCE_TYPE (i1) != IMAGE_INSTANCE_TYPE (i2)
 || IMAGE_INSTANCE_WIDTH (i1) != IMAGE_INSTANCE_WIDTH (i2)
+|| IMAGE_INSTANCE_MARGIN_WIDTH (i1) !=
+IMAGE_INSTANCE_MARGIN_WIDTH (i2)
 || IMAGE_INSTANCE_HEIGHT (i1) != IMAGE_INSTANCE_HEIGHT (i2)
 || IMAGE_INSTANCE_XOFFSET (i1) != IMAGE_INSTANCE_XOFFSET (i2)
 || IMAGE_INSTANCE_YOFFSET (i1) != IMAGE_INSTANCE_YOFFSET (i2))
 return 0;
 if (!internal_equal (IMAGE_INSTANCE_NAME (i1), IMAGE_INSTANCE_NAME (i2),
 			    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)
 	    &&
 	    EQ (IMAGE_INSTANCE_WIDGET_FACE (i1),
 		IMAGE_INSTANCE_WIDGET_TYPE (i2))
 	    && internal_equal (IMAGE_INSTANCE_WIDGET_ITEMS (i1),
 			       IMAGE_INSTANCE_WIDGET_ITEMS (i2),
+			       depth + 1)
+	    && internal_equal (IMAGE_INSTANCE_LAYOUT_CHILDREN (i1),
+			       IMAGE_INSTANCE_LAYOUT_CHILDREN (i2),
 			       depth + 1)
 	    && internal_equal (IMAGE_INSTANCE_WIDGET_PROPS (i1),
 			       IMAGE_INSTANCE_WIDGET_PROPS (i2),
 			       depth + 1)
 	    && internal_equal (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (i1),
 default:
 abort ();
 }
-return DEVMETH_OR_GIVEN (d1, image_instance_equal, (i1, i2, depth), 1);
+return DEVMETH_OR_GIVEN (DOMAIN_XDEVICE (i1->domain),
-}
+			   image_instance_equal, (i1, i2, depth), 1);
+}
-#if 0
-/* internal_hash will not go very far down a list because of the way
+/* Image instance domain manipulators. We can't error check in these
-its written. For items we need to hash all elements so we provide
+otherwise we get into infinite recursion. */
-our own list hashing function. */
+Lisp_Object
-static unsigned long
+image_instance_device (Lisp_Object instance)
-full_list_hash (Lisp_Object obj, int depth)
+{
-{
+return XIMAGE_INSTANCE_DEVICE (instance);
-unsigned long hash = 0;
+}
-Lisp_Object rest;
+Lisp_Object
-if (!CONSP (obj))
+image_instance_frame (Lisp_Object instance)
-return internal_hash (obj, depth + 1);
+{
+return XIMAGE_INSTANCE_FRAME (instance);
-hash = LISP_HASH (XCAR (obj));
+}
-LIST_LOOP (rest, XCDR (obj))
-{
+Lisp_Object
-hash = HASH2 (hash, internal_hash (XCAR (rest), depth + 1));
+image_instance_window (Lisp_Object instance)
-}
+{
-return hash;
+return DOMAIN_WINDOW (XIMAGE_INSTANCE_DOMAIN (instance));
 }
-#endif
+int
+image_instance_live_p (Lisp_Object instance)
+{
+return DOMAIN_LIVE_P (XIMAGE_INSTANCE_DOMAIN (instance));
+}
 static unsigned long
 image_instance_hash (Lisp_Object obj, int depth)
 {
 Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
-struct device *d = XDEVICE (i->device);
+unsigned long hash = HASH4 (LISP_HASH (IMAGE_INSTANCE_DOMAIN (i)),
-unsigned long hash = HASH3 ((unsigned long) d,
 			      IMAGE_INSTANCE_WIDTH (i),
+			      IMAGE_INSTANCE_MARGIN_WIDTH (i),
 			      IMAGE_INSTANCE_HEIGHT (i));
+ERROR_CHECK_IMAGE_INSTANCE (obj);
 switch (IMAGE_INSTANCE_TYPE (i))
 {
 case IMAGE_NOTHING:
 break;
 		    internal_hash (IMAGE_INSTANCE_PIXMAP_FILENAME (i),
 				   depth + 1));
 break;
 case IMAGE_WIDGET:
-case IMAGE_LAYOUT:
 /* We need the hash to be equivalent to what should be
 displayed. */
-hash = HASH4 (hash,
+hash = HASH5 (hash,
 		    LISP_HASH (IMAGE_INSTANCE_WIDGET_TYPE (i)),
 		    internal_hash (IMAGE_INSTANCE_WIDGET_PROPS (i), depth + 1),
-		    internal_hash (IMAGE_INSTANCE_WIDGET_ITEMS (i), depth + 1));
+		    internal_hash (IMAGE_INSTANCE_WIDGET_ITEMS (i), depth + 1),
+		    internal_hash (IMAGE_INSTANCE_LAYOUT_CHILDREN (i),
+				   depth + 1));
 case IMAGE_SUBWINDOW:
 hash = HASH2 (hash, (int) IMAGE_INSTANCE_SUBWINDOW_ID (i));
 break;
 default:
 abort ();
 }
-return HASH2 (hash, DEVMETH_OR_GIVEN (d, image_instance_hash, (i, depth),
+return HASH2 (hash, DEVMETH_OR_GIVEN
-					0));
+		(XDEVICE (image_instance_device (obj)),
+		 image_instance_hash, (i, depth),
+		 0));
 }
 DEFINE_LRECORD_IMPLEMENTATION ("image-instance", image_instance,
 			       mark_image_instance, print_image_instance,
 			       finalize_image_instance, image_instance_equal,
 			       image_instance_hash, 0,
 			       Lisp_Image_Instance);
 static Lisp_Object
-allocate_image_instance (Lisp_Object device, Lisp_Object glyph)
+allocate_image_instance (Lisp_Object governing_domain, Lisp_Object glyph)
 {
 Lisp_Image_Instance *lp =
 alloc_lcrecord_type (Lisp_Image_Instance, &lrecord_image_instance);
 Lisp_Object val;
 zero_lcrecord (lp);
-lp->device = device;
+/* It's not possible to simply keep a record of the domain in which
+the instance was instantiated. This is because caching may mean
+that the domain becomes invalid but the instance remains
+valid. However, the only truly relevant domain is the domain in
+which the instance is cached since this is the one that will be
+common to the instances. */
+lp->domain = governing_domain;
+/* The cache domain is not quite sufficient since the domain can get
+deleted before the image instance does. We need to know the
+domain device in order to finalize the image instance
+properly. We therefore record the device also. */
+lp->device = DOMAIN_DEVICE (governing_domain);
 lp->type = IMAGE_NOTHING;
 lp->name = Qnil;
 lp->x_offset = 0;
 lp->y_offset = 0;
-lp->width = 0;
+lp->width = IMAGE_UNSPECIFIED_GEOMETRY;
-lp->height = 0;
+lp->margin_width = 0;
+lp->height = IMAGE_UNSPECIFIED_GEOMETRY;
 lp->parent = glyph;
 /* So that layouts get done. */
 lp->layout_changed = 1;
+lp->initialized = 0;
 XSETIMAGE_INSTANCE (val, lp);
 MARK_GLYPHS_CHANGED;
 return val;
 if (EQ (type, Qmono_pixmap))  return IMAGE_MONO_PIXMAP;
 if (EQ (type, Qcolor_pixmap)) return IMAGE_COLOR_PIXMAP;
 if (EQ (type, Qpointer))      return IMAGE_POINTER;
 if (EQ (type, Qsubwindow))    return IMAGE_SUBWINDOW;
 if (EQ (type, Qwidget))    return IMAGE_WIDGET;
-if (EQ (type, Qlayout))    return IMAGE_LAYOUT;
 maybe_signal_simple_error ("Invalid image-instance type", type,
 			     Qimage, errb);
 return IMAGE_UNKNOWN; /* not reached */
 case IMAGE_MONO_PIXMAP:  return Qmono_pixmap;
 case IMAGE_COLOR_PIXMAP: return Qcolor_pixmap;
 case IMAGE_POINTER:      return Qpointer;
 case IMAGE_SUBWINDOW:    return Qsubwindow;
 case IMAGE_WIDGET:    return Qwidget;
-case IMAGE_LAYOUT:    return Qlayout;
 default:
 abort ();
 }
 return Qnil; /* not reached */
-}
-static int
-image_instance_type_to_mask (enum image_instance_type type)
-{
-/* This depends on the fact that enums are assigned consecutive
-integers starting at 0. (Remember that IMAGE_UNKNOWN is the
-first enum.) I'm fairly sure this behavior is ANSI-mandated,
-so there should be no portability problems here. */
-return (1 << ((int) (type) - 1));
 }
 static int
 decode_image_instance_type_list (Lisp_Object list)
 {
 }
 DEFUN ("valid-image-instance-type-p", Fvalid_image_instance_type_p, 1, 1, 0, /*
 Given an IMAGE-INSTANCE-TYPE, return non-nil if it is valid.
 Valid types are some subset of 'nothing, 'text, 'mono-pixmap, 'color-pixmap,
-'pointer, and 'subwindow, depending on how XEmacs was compiled.
+'pointer, 'subwindow, and 'widget, depending on how XEmacs was compiled.
 */
 (image_instance_type))
 {
 return valid_image_instance_type_p (image_instance_type) ? Qt : Qnil;
 }
 }
 return IMAGE_INSTANCE_PARENT (ii);
 }
 static Lisp_Object
-make_image_instance_1 (Lisp_Object data, Lisp_Object device,
+make_image_instance_1 (Lisp_Object data, Lisp_Object domain,
 		       Lisp_Object dest_types)
 {
 Lisp_Object ii;
 struct gcpro gcpro1;
 int dest_mask;
+Lisp_Object governing_domain;
-XSETDEVICE (device, decode_device (device));
-/* instantiate_image_instantiator() will abort if given an
-image instance ... */
 if (IMAGE_INSTANCEP (data))
 signal_simple_error ("Image instances not allowed here", data);
 image_validate (data);
+domain = decode_domain (domain);
+/* instantiate_image_instantiator() will abort if given an
+image instance ... */
 dest_mask = decode_image_instance_type_list (dest_types);
-data = normalize_image_instantiator (data, DEVICE_TYPE (XDEVICE (device)),
+data = normalize_image_instantiator (data,
+				       DEVICE_TYPE (DOMAIN_XDEVICE (domain)),
 				       make_int (dest_mask));
 GCPRO1 (data);
-if (VECTORP (data) && EQ (XVECTOR_DATA (data)[0], Qinherit))
+/* After normalizing the data, it's always either an image instance (which
+we filtered out above) or a vector. */
+if (EQ (XVECTOR_DATA (data)[0], Qinherit))
 signal_simple_error ("Inheritance not allowed here", data);
-ii = instantiate_image_instantiator (device, device, data,
+governing_domain =
+get_image_instantiator_governing_domain (data, domain);
+ii = instantiate_image_instantiator (governing_domain, domain, data,
 				       Qnil, Qnil, dest_mask, Qnil);
 RETURN_UNGCPRO (ii);
 }
 DEFUN ("make-image-instance", Fmake_image_instance, 1, 4, 0, /*
 do not need to directly create image instances; use a glyph instead.
 However, it may occasionally be useful to explicitly create image
 instances, if you want more control over the instantiation process.
 DATA is an image instantiator, which describes the image; see
-`image-specifier-p' for a description of the allowed values.
+`make-image-specifier' for a description of the allowed values.
 DEST-TYPES should be a list of allowed image instance types that can
 be generated.  The recognized image instance types are
 'nothing
 'subwindow
 A child window that is treated as an image.  This allows (e.g.)
 another program to be responsible for drawing into the window.
 'widget
 A child window that contains a window-system widget, e.g. a push
-button.
+button, text field, or slider.
-The DEST-TYPES list is unordered.  If multiple destination types
+The DEST-TYPES list is unordered.  If multiple destination types are
-are possible for a given instantiator, the "most natural" type
+possible for a given instantiator, the "most natural" type for the
-for the instantiator's format is chosen. (For XBM, the most natural
+instantiator's format is chosen. (For XBM, the most natural types are
-types are `mono-pixmap', followed by `color-pixmap', followed by
+`mono-pixmap', followed by `color-pixmap', followed by `pointer'.  For
-`pointer'.  For the other normal image formats, the most natural
+the other normal image formats, the most natural types are
-types are `color-pixmap', followed by `mono-pixmap', followed by
+`color-pixmap', followed by `mono-pixmap', followed by `pointer'.  For
-`pointer'.  For the string and formatted-string formats, the most
+the string and formatted-string formats, the most natural types are
-natural types are `text', followed by `mono-pixmap' (not currently
+`text', followed by `mono-pixmap' (not currently implemented),
-implemented), followed by `color-pixmap' (not currently implemented).
+followed by `color-pixmap' (not currently implemented).  For MS
-The other formats can only be instantiated as one type. (If you
+Windows resources, the most natural type for pointer resources is
-want to control more specifically the order of the types into which
+`pointer', and for the others it's `color-pixmap'.  The other formats
-an image is instantiated, just call `make-image-instance' repeatedly
+can only be instantiated as one type. (If you want to control more
-until it succeeds, passing less and less preferred destination types
+specifically the order of the types into which an image is
-each time.
+instantiated, just call `make-image-instance' repeatedly until it
+succeeds, passing less and less preferred destination types each
+time.)
+See `make-image-specifier' for a description of the different image
+instantiator formats.
 If DEST-TYPES is omitted, all possible types are allowed.
+DOMAIN specifies the domain to which the image instance will be attached.
+This domain is termed the \"governing domain\".  The type of the governing
+domain depends on the image instantiator format. (Although, more correctly,
+it should probably depend on the image instance type.) For example, pixmap
+image instances are specific to a device, but widget image instances are
+specific to a particular XEmacs window because in order to display such a
+widget when two windows onto the same buffer want to display the widget,
+two separate underlying widgets must be created. (That's because a widget
+is actually a child window-system window, and all window-system windows have
+a unique existence on the screen.) This means that the governing domain for
+a pixmap image instance will be some device (most likely, the only existing
+device), whereas the governing domain for a widget image instance will be
+some XEmacs window.
+If you specify an overly general DOMAIN (e.g. a frame when a window was
+wanted), an error is signaled.  If you specify an overly specific DOMAIN
+\(e.g. a window when a device was wanted), the corresponding general domain
+is fetched and used instead.  For `make-image-instance', it makes no
+difference whether you specify an overly specific domain or the properly
+general domain derived from it.  However, it does matter when creating an
+image instance by instantiating a specifier or glyph (e.g. with
+`glyph-image-instance'), because the more specific domain causes spec lookup
+to start there and proceed to more general domains. (It would also matter
+when creating an image instance with an instantiator format of `inherit',
+but we currently disallow this. #### We should fix this.)
+If omitted, DOMAIN defaults to the selected window.
 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))
+(data, domain, dest_types, no_error))
 {
 Error_behavior errb = decode_error_behavior_flag (no_error);
 return call_with_suspended_errors ((lisp_fn_t) make_image_instance_1,
 				     Qnil, Qimage, errb,
-				     3, data, device, dest_types);
+				     3, data, domain, dest_types);
 }
 DEFUN ("image-instance-p", Fimage_instance_p, 1, 1, 0, /*
 Return non-nil if OBJECT is an image instance.
 */
 'color-pixmap, 'pointer, or 'subwindow.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 return encode_image_instance_type (XIMAGE_INSTANCE_TYPE (image_instance));
 }
 DEFUN ("image-instance-name", Fimage_instance_name, 1, 1, 0, /*
 Return the name of the given image instance.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 return XIMAGE_INSTANCE_NAME (image_instance);
+}
+DEFUN ("image-instance-domain", Fimage_instance_domain, 1, 1, 0, /*
+Return the governing domain of the given image instance.
+The governing domain of an image instance is the domain that the image
+instance is specific to.  It is NOT necessarily the domain that was
+given to the call to `specifier-instance' that resulted in the creation
+of this image instance.  See `make-image-instance' for more information
+on governing domains.
+*/
+(image_instance))
+{
+CHECK_IMAGE_INSTANCE (image_instance);
+return XIMAGE_INSTANCE_DOMAIN (image_instance);
 }
 DEFUN ("image-instance-string", Fimage_instance_string, 1, 1, 0, /*
 Return the string of the given image instance.
 This will only be non-nil for text image instances and widgets.
 Lisp_Image_Instance* ii;
 Lisp_Object type, ret;
 struct image_instantiator_methods* meths;
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_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),
+meths = decode_device_ii_format (image_instance_device (image_instance),
 				   type, ERROR_ME_NOT);
 if (meths && HAS_IIFORMAT_METH_P (meths, property)
 &&
 !UNBOUNDP (ret =  IIFORMAT_METH (meths, property, (image_instance, prop))))
 {
 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.
-*/
+WARNING: If you are thinking about using this function, think again.
+You probably want to be using `set-glyph-image' to change the glyph's
+specifier.  Be especially wary if you are thinking of calling this
+function after having called `glyph-image-instance'.  Unless you are
+absolutely sure what you're doing, pretty much the only legitimate
+uses for this function are setting user-specified info in a widget,
+such as text in a text field.  */
 (image_instance, prop, val))
 {
 Lisp_Image_Instance* ii;
 Lisp_Object type, ret;
 struct image_instantiator_methods* meths;
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_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),
+meths = decode_device_ii_format (image_instance_device (image_instance),
 				   type, ERROR_ME_NOT);
 if (meths && HAS_IIFORMAT_METH_P (meths, set_property)
 &&
 !UNBOUNDP (ret =
 		 IIFORMAT_METH (meths, set_property, (image_instance, prop, val))))
 Return the file name from which IMAGE-INSTANCE was read, if known.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 Return the file name from which IMAGE-INSTANCE's mask was read, if known.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 This is 0 for a bitmap, or a positive integer for a pixmap.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 Return the height of the image instance, in pixels.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 case IMAGE_SUBWINDOW:
 case IMAGE_WIDGET:
-case IMAGE_LAYOUT:
 return make_int (XIMAGE_INSTANCE_HEIGHT (image_instance));
 default:
 return Qnil;
 }
 Return the width of the image instance, in pixels.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 case IMAGE_SUBWINDOW:
 case IMAGE_WIDGET:
-case IMAGE_LAYOUT:
 return make_int (XIMAGE_INSTANCE_WIDTH (image_instance));
 default:
 return Qnil;
 }
 This will always be nil for a non-pointer image instance.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 This will always be nil for a non-pointer image instance.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 colorized mono pixmaps and for pointers.)
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 return XIMAGE_INSTANCE_PIXMAP_FG (image_instance);
 case IMAGE_WIDGET:
 return FACE_FOREGROUND (
 			      XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
-			      XIMAGE_INSTANCE_SUBWINDOW_FRAME
+			      XIMAGE_INSTANCE_FRAME
 			      (image_instance));
 default:
 return Qnil;
 }
 colorized mono pixmaps and for pointers.)
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 return XIMAGE_INSTANCE_PIXMAP_BG (image_instance);
 case IMAGE_WIDGET:
 return FACE_BACKGROUND (
 			      XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
-			      XIMAGE_INSTANCE_SUBWINDOW_FRAME
+			      XIMAGE_INSTANCE_FRAME
 			      (image_instance));
 default:
 return Qnil;
 }
 {
 Lisp_Object new;
 Lisp_Object device;
 CHECK_IMAGE_INSTANCE (image_instance);
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 CHECK_COLOR_INSTANCE (foreground);
 CHECK_COLOR_INSTANCE (background);
-device = XIMAGE_INSTANCE_DEVICE (image_instance);
+device = image_instance_device (image_instance);
 if (!HAS_DEVMETH_P (XDEVICE (device), colorize_image_instance))
 return image_instance;
 /* #### There should be a copy_image_instance(), which calls a
 device-specific method to copy the window-system subobject. */
-new = allocate_image_instance (device, Qnil);
+new = allocate_image_instance (XIMAGE_INSTANCE_DOMAIN (image_instance),
+				 Qnil);
 copy_lcrecord (XIMAGE_INSTANCE (new), XIMAGE_INSTANCE (image_instance));
 /* note that if this method returns non-zero, this method MUST
 copy any window-system resources, so that when one image instance is
 freed, the other one is not hosed. */
 if (!DEVMETH (XDEVICE (device), colorize_image_instance, (new, foreground,
 			       Lisp_Object domain)
 {
 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object type;
 struct image_instantiator_methods* meths;
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 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))
 {
 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object type;
 struct image_instantiator_methods* meths;
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
+/* Nothing is as nothing does. */
+if (NOTHING_IMAGE_INSTANCEP (image_instance))
+return;
 type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
 meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
 /* If geometry is unspecified then get some reasonable values for it. */
 if (width == IMAGE_UNSPECIFIED_GEOMETRY
 ||
 height == IMAGE_UNSPECIFIED_GEOMETRY)
 {
-unsigned int dwidth, dheight;
+unsigned int dwidth = IMAGE_UNSPECIFIED_GEOMETRY,
+	  dheight = IMAGE_UNSPECIFIED_GEOMETRY;
 /* Get the desired geometry. */
 if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry))
 	{
 	  IIFORMAT_METH (meths, query_geometry, (image_instance, &dwidth, &dheight,
 	width = dwidth;
 if (height == IMAGE_UNSPECIFIED_GEOMETRY)
 	height = dheight;
 }
+/* If we don't have sane values then we cannot layout at this point and
+must just return. */
+if (width == IMAGE_UNSPECIFIED_GEOMETRY
+||
+height == IMAGE_UNSPECIFIED_GEOMETRY)
+return;
 /* At this point width and height should contain sane values. Thus
 we set the glyph geometry and lay it out. */
 if (IMAGE_INSTANCE_WIDTH (ii) != width
 ||
 IMAGE_INSTANCE_HEIGHT (ii) != height)
 }
 IMAGE_INSTANCE_WIDTH (ii) = width;
 IMAGE_INSTANCE_HEIGHT (ii) = height;
-if (meths && HAS_IIFORMAT_METH_P (meths, layout))
+if (IIFORMAT_METH_OR_GIVEN (meths, layout,
-{
+			      (image_instance, width, height, domain), 1))
-IIFORMAT_METH (meths, layout, (image_instance, width, height, domain));
+/* Do not clear the dirty flag here - redisplay will do this for
-}
+us at the end. */
-/* else no change to the geometry. */
+IMAGE_INSTANCE_LAYOUT_CHANGED (ii) = 0;
-/* Do not clear the dirty flag here - redisplay will do this for
-us at the end. */
-IMAGE_INSTANCE_LAYOUT_CHANGED (ii) = 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.
 		     int dest_mask, Lisp_Object domain)
 {
 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 if (dest_mask & IMAGE_NOTHING_MASK)
-IMAGE_INSTANCE_TYPE (ii) = IMAGE_NOTHING;
+{
+IMAGE_INSTANCE_TYPE (ii) = IMAGE_NOTHING;
+IMAGE_INSTANCE_HEIGHT (ii) = 0;
+IMAGE_INSTANCE_WIDTH (ii) = 0;
+}
 else
 incompatible_image_types (instantiator, dest_mask, IMAGE_NOTHING_MASK);
 }
 {
 Lisp_Object string = find_keyword_in_vector (instantiator, Q_data);
 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 /* Should never get here with a domain other than a window. */
-assert (!NILP (string) && WINDOWP (domain));
+assert (!NILP (string) && WINDOWP (DOMAIN_WINDOW (domain)));
 if (dest_mask & IMAGE_TEXT_MASK)
 {
 IMAGE_INSTANCE_TYPE (ii) = IMAGE_TEXT;
 IMAGE_INSTANCE_TEXT_STRING (ii) = string;
 }
 {
 struct font_metric_info fm;
 unsigned char charsets[NUM_LEADING_BYTES];
 struct face_cachel frame_cachel;
 struct face_cachel *cachel;
-Lisp_Object frame = FW_FRAME (domain);
+Lisp_Object frame = DOMAIN_FRAME (domain);
 /* Compute height */
 if (height)
 {
 /* Compute string metric info */
 	  update_face_cachel_data (&frame_cachel, frame, face);
 	  cachel = &frame_cachel;
 	}
 else
 	{
-	  cachel = WINDOW_FACE_CACHEL (XWINDOW (domain), DEFAULT_INDEX);
+	  cachel = WINDOW_FACE_CACHEL (DOMAIN_XWINDOW (domain),
+				       DEFAULT_INDEX);
 	}
 ensure_face_cachel_complete (cachel, domain, charsets);
 face_cachel_charset_font_metric_info (cachel, charsets, &fm);
 {
 unsigned char charsets[NUM_LEADING_BYTES];
 struct face_cachel frame_cachel;
 struct face_cachel *cachel;
 int i;
-Lisp_Object frame = FW_FRAME (domain);
+Lisp_Object frame = DOMAIN_FRAME (domain);
 /* Compute string font info */
 find_charsets_in_bufbyte_string (charsets,
 				   XSTRING_DATA   (string),
 				   XSTRING_LENGTH (string));
 static Lisp_Object
 image_instantiate (Lisp_Object specifier, Lisp_Object matchspec,
 		   Lisp_Object domain, Lisp_Object instantiator,
 		   Lisp_Object depth)
 {
-Lisp_Object device = DFW_DEVICE (domain);
-struct device *d = XDEVICE (device);
 Lisp_Object glyph = IMAGE_SPECIFIER_ATTACHEE (XIMAGE_SPECIFIER (specifier));
 int dest_mask = XIMAGE_SPECIFIER_ALLOWED (specifier);
 int pointerp = dest_mask & image_instance_type_to_mask (IMAGE_POINTER);
 if (IMAGE_INSTANCEP (instantiator))
 {
-/* make sure that the image instance's device and type are
+/* make sure that the image instance's governing domain and type are
 	 matching. */
+Lisp_Object governing_domain = XIMAGE_INSTANCE_DOMAIN (instantiator);
-if (EQ (device, XIMAGE_INSTANCE_DEVICE (instantiator)))
+if ((DEVICEP (governing_domain)
+	   && EQ (governing_domain, DOMAIN_DEVICE (domain)))
+	  || (FRAMEP (governing_domain)
+	      && EQ (governing_domain, DOMAIN_FRAME (domain)))
+	  || (WINDOWP (governing_domain)
+	      && EQ (governing_domain, DOMAIN_WINDOW (domain))))
 	{
 	  int mask =
 	    image_instance_type_to_mask (XIMAGE_INSTANCE_TYPE (instantiator));
 	  if (mask & dest_mask)
 	    return instantiator;
 	  else
 	    signal_simple_error ("Type of image instance not allowed here",
 				 instantiator);
 	}
 else
-	signal_simple_error_2 ("Wrong device for image instance",
+	signal_simple_error_2 ("Wrong domain for image instance",
-			       instantiator, device);
+			       instantiator, domain);
 }
 else if (VECTORP (instantiator)
 	   && EQ (XVECTOR_DATA (instantiator)[0], Qinherit))
 {
 assert (XVECTOR_LENGTH (instantiator) == 3);
 Lisp_Object instance;
 Lisp_Object subtable;
 Lisp_Object ls3 = Qnil;
 Lisp_Object pointer_fg = Qnil;
 Lisp_Object pointer_bg = Qnil;
+Lisp_Object governing_domain =
+	get_image_instantiator_governing_domain (instantiator, domain);
 /* We have to put subwindow, widget and text image instances in
 	 a per-window cache so that we can see the same glyph in
-	 different windows. Unfortunately we do not know the type of
+	 different windows. We use governing_domain to determine the type
-	 image_instance until after it has been created. We thus need
+	 of image_instance that will be created. */
-	 to be really careful how we place things.  */
 if (pointerp)
 	{
 	  pointer_fg = FACE_FOREGROUND (Vpointer_face, domain);
 	  pointer_bg = FACE_BACKGROUND (Vpointer_face, domain);
 	  ls3 = list3 (instantiator, pointer_fg, pointer_bg);
 	}
-/* First look in the hash table. */
+/* First look in the device cache. */
-subtable = Fgethash (make_int (dest_mask), d->image_instance_cache,
+if (DEVICEP (governing_domain))
-			   Qunbound);
-if (UNBOUNDP (subtable))
 	{
-	  /* For the image instance cache, we do comparisons with EQ rather
+	  subtable = Fgethash (make_int (dest_mask),
-	     than with EQUAL, as we do for color and font names.
+			       XDEVICE (governing_domain)->
-	     The reasons are:
+			       image_instance_cache,
+			       Qunbound);
-	     1) pixmap data can be very long, and thus the hashing and
+	  if (UNBOUNDP (subtable))
-	     comparing will take awhile.
+	    {
-	     2) It's not so likely that we'll run into things that are EQUAL
+	      /* For the image instance cache, we do comparisons with
-	     but not EQ (that can happen a lot with faces, because their
+		 EQ rather than with EQUAL, as we do for color and
-	     specifiers are copied around); but pixmaps tend not to be
+		 font names.  The reasons are:
-	     in faces.
+		 1) pixmap data can be very long, and thus the hashing
-	     However, if the image-instance could be a pointer, we have to
+		 and comparing will take awhile.
-	     use EQUAL because we massaged the instantiator into a cons3
-	     also containing the foreground and background of the
+		 2) It's not so likely that we'll run into things that
-	     pointer face.
+		 are EQUAL but not EQ (that can happen a lot with
-	   */
+		 faces, because their specifiers are copied around);
+		 but pixmaps tend not to be in faces.
-	  subtable = make_lisp_hash_table (20,
-					   pointerp ? HASH_TABLE_KEY_CAR_WEAK
+		 However, if the image-instance could be a pointer, we
-					   : HASH_TABLE_KEY_WEAK,
+		 have to use EQUAL because we massaged the
-					   pointerp ? HASH_TABLE_EQUAL
+		 instantiator into a cons3 also containing the
-					   : HASH_TABLE_EQ);
+		 foreground and background of the pointer face.  */
-	  Fputhash (make_int (dest_mask), subtable,
-		    d->image_instance_cache);
+	      subtable = make_lisp_hash_table
-	  instance = Qunbound;
+		(20, pointerp ? HASH_TABLE_KEY_CAR_WEAK
+		 : HASH_TABLE_KEY_WEAK,
+		 pointerp ? HASH_TABLE_EQUAL
+		 : HASH_TABLE_EQ);
+	      Fputhash (make_int (dest_mask), subtable,
+			XDEVICE (governing_domain)->image_instance_cache);
+	      instance = Qunbound;
+	    }
+	  else
+	    {
+	      instance = Fgethash (pointerp ? ls3 : instantiator,
+				   subtable, Qunbound);
+	    }
+	}
+else if (WINDOWP (governing_domain))
+	{
+	  /* Subwindows have a per-window cache and have to be treated
+	     differently. */
+	  instance =
+	    Fgethash (instantiator,
+		      XWINDOW (governing_domain)->subwindow_instance_cache,
+		      Qunbound);
 	}
 else
-	{
+	abort ();	/* We're not allowed anything else currently. */
-	  instance = Fgethash (pointerp ? ls3 : instantiator,
-			       subtable, Qunbound);
+/* If we don't have an instance at this point then create
-	  /* subwindows have a per-window cache and have to be treated
+one. */
-	     differently.  dest_mask can be a bitwise OR of all image
-	     types so we will only catch someone possibly trying to
-	     instantiate a subwindow type thing. Unfortunately, this
-	     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_LAYOUT_MASK
-			   | IMAGE_TEXT_MASK)
-	      && WINDOWP (domain))
-	    {
-	      instance = Fgethash (instantiator,
-				   XWINDOW (domain)->subwindow_instance_cache,
-				   Qunbound);
-	    }
-	}
 if (UNBOUNDP (instance))
 	{
 	  Lisp_Object locative =
 	    noseeum_cons (Qnil,
 			  noseeum_cons (pointerp ? ls3 : instantiator,
-					subtable));
+					DEVICEP (governing_domain) ? subtable
+					: XWINDOW (governing_domain)
+					->subwindow_instance_cache));
 	  int speccount = specpdl_depth ();
-	  /* make sure we cache the failures, too.
+	  /* Make sure we cache the failures, too.  Use an
-	     Use an unwind-protect to catch such errors.
+	     unwind-protect to catch such errors.  If we fail, the
-	     If we fail, the unwind-protect records nil in
+	     unwind-protect records nil in the hash table.  If we
-	     the hash table.  If we succeed, we change the
+	     succeed, we change the car of the locative to the
-	     car of the locative to the resulting instance,
+	     resulting instance, which gets recorded instead. */
-	     which gets recorded instead. */
 	  record_unwind_protect (image_instantiate_cache_result,
 				 locative);
-	  instance = instantiate_image_instantiator (device,
+	  instance =
-						     domain,
+	    instantiate_image_instantiator (governing_domain,
-						     instantiator,
+					    domain, instantiator,
-						     pointer_fg, pointer_bg,
+					    pointer_fg, pointer_bg,
-						     dest_mask,
+					    dest_mask, glyph);
-						     glyph);
+	  /* We need a per-frame cache for redisplay. */
+	  cache_subwindow_instance_in_frame_maybe (instance);
 	  Fsetcar (locative, instance);
-	  /* only after the image has been instantiated do we know
+#ifdef ERROR_CHECK_GLYPHS
-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))
-	      (IMAGE_SUBWINDOW_MASK
+	      assert (EQ (XIMAGE_INSTANCE_FRAME (instance),
-	       | IMAGE_WIDGET_MASK
+			  DOMAIN_FRAME (domain)));
-	       | IMAGE_LAYOUT_MASK
-	       | IMAGE_TEXT_MASK ))
-	    {
-#ifdef ERROR_CHECK_GLYPHS
-	      if (XIMAGE_INSTANCE_TYPE (instance) != IMAGE_TEXT)
-		assert (EQ (XIMAGE_INSTANCE_SUBWINDOW_FRAME (instance),
-			    FW_FRAME (domain)));
 #endif
-	      if (!WINDOWP (domain))
-		signal_simple_error ("Can't instantiate text or subwindow outside a window",
-				     instantiator);
-#ifdef ERROR_CHECK_GLYPHS
-	      if (XIMAGE_INSTANCE_TYPE (instance) != IMAGE_TEXT)
-		assert (EQ (XIMAGE_INSTANCE_SUBWINDOW_FRAME (instance),
-			    FW_FRAME (domain)));
-#endif
-	      Fsetcdr (XCDR (locative), XWINDOW (domain)->subwindow_instance_cache);
-	    }
 	  unbind_to (speccount, Qnil);
 #ifdef ERROR_CHECK_GLYPHS
 	  if (image_instance_type_to_mask (XIMAGE_INSTANCE_TYPE (instance))
-	      &
+	      & (IMAGE_SUBWINDOW_MASK | IMAGE_WIDGET_MASK))
-	      (IMAGE_SUBWINDOW_MASK
-	       | IMAGE_WIDGET_MASK
-	       | IMAGE_LAYOUT_MASK
-	       | IMAGE_TEXT_MASK ))
 	    assert (EQ (Fgethash ((pointerp ? ls3 : instantiator),
-				  XWINDOW (domain)->subwindow_instance_cache,
+				  XWINDOW (governing_domain)
+				  ->subwindow_instance_cache,
 				  Qunbound), instance));
 #endif
 	}
 else
 	free_list (ls3);
 	signal_simple_error ("Can't instantiate image (probably cached)",
 			     instantiator);
 #ifdef ERROR_CHECK_GLYPHS
 if (image_instance_type_to_mask (XIMAGE_INSTANCE_TYPE (instance))
 	  & (IMAGE_SUBWINDOW_MASK | IMAGE_WIDGET_MASK))
-	assert (EQ (XIMAGE_INSTANCE_SUBWINDOW_FRAME (instance),
+	assert (EQ (XIMAGE_INSTANCE_FRAME (instance),
-		    FW_FRAME (domain)));
+		    DOMAIN_FRAME (domain)));
 #endif
+ERROR_CHECK_IMAGE_INSTANCE (instance);
 return instance;
 }
 abort ();
 return Qnil; /* not reached */
 return arg;
 }
 DEFUN ("image-specifier-p", Fimage_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is an image specifier.
+See `make-image-specifier' for a description of image instantiators.
-An image specifier is used for images (pixmaps and the like).  It is used
-to describe the actual image in a glyph.  It is instanced as an image-
-instance.
-Image instantiators come in many formats: `xbm', `xpm', `gif', `jpeg',
-etc.  This describes the format of the data describing the image.  The
-resulting image instances also come in many types -- `mono-pixmap',
-`color-pixmap', `text', `pointer', etc.  This refers to the behavior of
-the image and the sorts of places it can appear. (For example, a
-color-pixmap image has fixed colors specified for it, while a
-mono-pixmap image comes in two unspecified shades "foreground" and
-"background" that are determined from the face of the glyph or
-surrounding text; a text image appears as a string of text and has an
-unspecified foreground, background, and font; a pointer image behaves
-like a mono-pixmap image but can only be used as a mouse pointer
-\[mono-pixmap images cannot be used as mouse pointers]; etc.) It is
-important to keep the distinction between image instantiator format and
-image instance type in mind.  Typically, a given image instantiator
-format can result in many different image instance types (for example,
-`xpm' can be instanced as `color-pixmap', `mono-pixmap', or `pointer';
-whereas `cursor-font' can be instanced only as `pointer'), and a
-particular image instance type can be generated by many different
-image instantiator formats (e.g.  `color-pixmap' can be generated by `xpm',
-`gif', `jpeg', etc.).
-See `make-image-instance' for a more detailed discussion of image
-instance types.
-An image instantiator should be a string or a vector of the form
-[FORMAT :KEYWORD VALUE ...]
-i.e. a format symbol followed by zero or more alternating keyword-value
-pairs.  FORMAT should be one of
-'nothing
-(Don't display anything; no keywords are valid for this.
-Can only be instanced as `nothing'.)
-'string
-(Display this image as a text string.  Can only be instanced
-as `text', although support for instancing as `mono-pixmap'
-should be added.)
-'formatted-string
-(Display this image as a text string, with replaceable fields;
-not currently implemented.)
-'xbm
-(An X bitmap; only if X or Windows support was compiled into this XEmacs.
-Can be instanced as `mono-pixmap', `color-pixmap', or `pointer'.)
-'xpm
-(An XPM pixmap; only if XPM support was compiled into this XEmacs.
-Can be instanced as `color-pixmap', `mono-pixmap', or `pointer'.)
-'xface
-(An X-Face bitmap, used to encode people's faces in e-mail messages;
-only if X-Face support was compiled into this XEmacs.  Can be
-instanced as `mono-pixmap', `color-pixmap', or `pointer'.)
-'gif
-(A GIF87 or GIF89 image; only if GIF support was compiled into this
-XEmacs.  NOTE: only the first frame of animated gifs will be displayed.
-Can be instanced as `color-pixmap'.)
-'jpeg
-(A JPEG image; only if JPEG support was compiled into this XEmacs.
-Can be instanced as `color-pixmap'.)
-'png
-(A PNG image; only if PNG support was compiled into this XEmacs.
-Can be instanced as `color-pixmap'.)
-'tiff
-(A TIFF image; only if TIFF support was compiled into this XEmacs.
-Can be instanced as `color-pixmap'.)
-'cursor-font
-(One of the standard cursor-font names, such as "watch" or
-"right_ptr" under X.  Under X, this is, more specifically, any
-of the standard cursor names from appendix B of the Xlib manual
-[also known as the file <X11/cursorfont.h>] minus the XC_ prefix.
-On other window systems, the valid names will be specific to the
-type of window system.  Can only be instanced as `pointer'.)
-'font
-(A glyph from a font; i.e. the name of a font, and glyph index into it
-of the form "FONT fontname index [[mask-font] mask-index]".
-Currently can only be instanced as `pointer', although this should
-probably be fixed.)
-'subwindow
-(An embedded windowing system window.)
-'edit-field
-(A text editing widget glyph.)
-'button
-(A button widget glyph; either a push button, radio button or toggle button.)
-'tab-control
-(A tab widget glyph; a series of user selectable tabs.)
-'progress-gauge
-(A sliding widget glyph, for showing progress.)
-'combo-box
-(A drop list of selectable items in a widget glyph, for editing text.)
-'label
-(A static, text-only, widget glyph; for displaying text.)
-'tree-view
-(A folding widget glyph.)
-'autodetect
-(XEmacs tries to guess what format the data is in.  If X support
-exists, the data string will be checked to see if it names a filename.
-If so, and this filename contains XBM or XPM data, the appropriate
-sort of pixmap or pointer will be created. [This includes picking up
-any specified hotspot or associated mask file.] Otherwise, if `pointer'
-is one of the allowable image-instance types and the string names a
-valid cursor-font name, the image will be created as a pointer.
-Otherwise, the image will be displayed as text.  If no X support
-exists, the image will always be displayed as text.)
-'inherit
-Inherit from the background-pixmap property of a face.
-The valid keywords are:
-:data
-(Inline data.  For most formats above, this should be a string.  For
-XBM images, this should be a list of three elements: width, height, and
-a string of bit data.  This keyword is not valid for instantiator
-formats `nothing' and `inherit'.)
-:file
-(Data is contained in a file.  The value is the name of this file.
-If both :data and :file are specified, the image is created from
-what is specified in :data and the string in :file becomes the
-value of the `image-instance-file-name' function when applied to
-the resulting image-instance.  This keyword is not valid for
-instantiator formats `nothing', `string', `formatted-string',
-`cursor-font', `font', `autodetect', and `inherit'.)
-:foreground
-:background
-(For `xbm', `xface', `cursor-font', `widget' and `font'.  These keywords
-allow you to explicitly specify foreground and background colors.
-The argument should be anything acceptable to `make-color-instance'.
-This will cause what would be a `mono-pixmap' to instead be colorized
-as a two-color color-pixmap, and specifies the foreground and/or
-background colors for a pointer instead of black and white.)
-:mask-data
-(For `xbm' and `xface'.  This specifies a mask to be used with the
-bitmap.  The format is a list of width, height, and bits, like for
-:data.)
-:mask-file
-(For `xbm' and `xface'.  This specifies a file containing the mask data.
-If neither a mask file nor inline mask data is given for an XBM image,
-and the XBM image comes from a file, XEmacs will look for a mask file
-with the same name as the image file but with "Mask" or "msk"
-appended.  For example, if you specify the XBM file "left_ptr"
-[usually located in "/usr/include/X11/bitmaps"], the associated
-mask file "left_ptrmsk" will automatically be picked up.)
-:hotspot-x
-:hotspot-y
-(For `xbm' and `xface'.  These keywords specify a hotspot if the image
-is instantiated as a `pointer'.  Note that if the XBM image file
-specifies a hotspot, it will automatically be picked up if no
-explicit hotspot is given.)
-:color-symbols
-(Only for `xpm'.  This specifies an alist that maps strings
-that specify symbolic color names to the actual color to be used
-for that symbolic color (in the form of a string or a color-specifier
-object).  If this is not specified, the contents of `xpm-color-symbols'
-are used to generate the alist.)
-:face
-(Only for `inherit'.  This specifies the face to inherit from.
-For widget glyphs this also specifies the face to use for
-display. It defaults to gui-element-face.)
-Keywords accepted as menu item specs are also accepted by widget
-glyphs. These are `:selected', `:active', `:suffix', `:keys',
-`:style', `:filter', `:config', `:included', `:key-sequence',
-`:accelerator', `:label' and `:callback'.
-If instead of a vector, the instantiator is a string, it will be
-converted into a vector by looking it up according to the specs in the
-`console-type-image-conversion-list' (q.v.) for the console type of
-the domain (usually a window; sometimes a frame or device) over which
-the image is being instantiated.
-If the instantiator specifies data from a file, the data will be read
-in at the time that the instantiator is added to the image (which may
-be well before when the image is actually displayed), and the
-instantiator will be converted into one of the inline-data forms, with
-the filename retained using a :file keyword.  This implies that the
-file must exist when the instantiator is added to the image, but does
-not need to exist at any other time (e.g. it may safely be a temporary
-file).
 */
 (object))
 {
 return IMAGE_SPECIFIERP (object) ? Qt : Qnil;
 }
 {
 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_SUBWINDOW_MASK | IMAGE_WIDGET_MASK;
-	| IMAGE_LAYOUT_MASK;
 break;
 case GLYPH_POINTER:
 XIMAGE_SPECIFIER_ALLOWED (g->image) =
 	IMAGE_NOTHING_MASK | IMAGE_POINTER_MASK;
 break;
 }
 DEFUN ("glyphp", Fglyphp, 1, 1, 0, /*
 Return non-nil if OBJECT is a glyph.
-A glyph is an object used for pixmaps and the like.  It is used
+A glyph is an object used for pixmaps, widgets and the like.  It is used
 in begin-glyphs and end-glyphs attached to extents, in marginal and textual
 annotations, in overlay arrows (overlay-arrow-* variables), in toolbar
-buttons, and the like.  Its image is described using an image specifier --
+buttons, and the like.  Much more detailed information can be found at
-see `image-specifier-p'.
+`make-glyph'.  Its image is described using an image specifier --
+see `make-image-specifier'.  See also `make-image-instance' for further
+information.
 */
 (object))
 {
 return GLYPHP (object) ? Qt : Qnil;
 }
 a fallback. */
 Lisp_Object image_instance = specifier_instance (specifier, Qunbound,
 						   domain, errb, no_quit, 0,
 						   Qzero);
 assert (!UNBOUNDP (image_instance));
+ERROR_CHECK_IMAGE_INSTANCE (image_instance);
 return image_instance;
 }
 static Lisp_Object
 	{
 	  instance = glyph_image_instance (glyph_or_image, window,
 					   ERROR_ME_NOT, 1);
 	  XGLYPH_DIRTYP (glyph_or_image) = dirty;
 	}
+if (!IMAGE_INSTANCEP (instance))
+	return;
 XIMAGE_INSTANCE_DIRTYP (instance) = dirty;
 }
 }
 cachel->glyph   = glyph;
 /* Speed things up slightly by grabbing the glyph instantiation
 	 and passing it to the size functions. */
 instance = glyph_image_instance (glyph, window, ERROR_ME_NOT, 1);
+if (!IMAGE_INSTANCEP (instance))
+	return;
 /* 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 */
 instantiator in the hashtable and when the instantiator goes away
 we want the instance to go away also. However we also have a
 per-frame instance cache that we use to determine if a subwindow is
 obscuring an area that we want to clear. We need to be able to flip
 through this quickly so a hashtable is not suitable hence the
-subwindow_cachels. The question is should we just not mark
+subwindow_cachels. This is a weak list so unreference instances
-instances in the subwindow_cachels or should we try and invalidate
+will get deleted properly. */
-the cache at suitable points in redisplay? If we don't invalidate
-the cache it will fill up with crud that will only get removed when
-the frame is deleted. So invalidation is good, the question is when
-and whether we mark as well. Go for the simple option - don't mark,
-MARK_SUBWINDOWS_CHANGED when a subwindow gets deleted. */
-void
-mark_subwindow_cachels (subwindow_cachel_dynarr *elements)
-{
-int elt;
-if (!elements)
-return;
-for (elt = 0; elt < Dynarr_length (elements); elt++)
-{
-struct subwindow_cachel *cachel = Dynarr_atp (elements, elt);
-mark_object (cachel->subwindow);
-}
-}
-static void
-update_subwindow_cachel_data (struct frame *f, Lisp_Object subwindow,
-			  struct subwindow_cachel *cachel)
-{
-cachel->subwindow   = subwindow;
-cachel->width   = XIMAGE_INSTANCE_SUBWINDOW_WIDTH (subwindow);
-cachel->height   = XIMAGE_INSTANCE_SUBWINDOW_HEIGHT (subwindow);
-cachel->updated = 1;
-}
-static void
-add_subwindow_cachel (struct frame *f, Lisp_Object subwindow)
-{
-struct subwindow_cachel new_cachel;
-xzero (new_cachel);
-new_cachel.subwindow = Qnil;
-new_cachel.x=0;
-new_cachel.y=0;
-new_cachel.being_displayed=0;
-update_subwindow_cachel_data (f, subwindow, &new_cachel);
-Dynarr_add (f->subwindow_cachels, new_cachel);
-}
-static int
-get_subwindow_cachel_index (struct frame *f, Lisp_Object subwindow)
-{
-int elt;
-if (noninteractive)
-return 0;
-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))
-	{
-	  if (!cachel->updated)
-	    update_subwindow_cachel_data (f, subwindow, cachel);
-	  return elt;
-	}
-}
-/* If we didn't find the glyph, add it and then return its index. */
-add_subwindow_cachel (f, subwindow);
-return elt;
-}
-static void
-update_subwindow_cachel (Lisp_Object subwindow)
-{
-struct frame* f;
-int elt;
-if (NILP (subwindow))
-return;
-f = XFRAME ( XIMAGE_INSTANCE_SUBWINDOW_FRAME (subwindow));
-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);
-	}
-}
-}
 /* redisplay in general assumes that drawing something will erase
 what was there before. unfortunately this does not apply to
 subwindows that need to be specifically unmapped in order to
 disappear. we take a brute force approach - on the basis that its
 cheap - and unmap all subwindows in a display line */
+/* Put new instances in the frame subwindow cache. This is less costly than
+doing it every time something gets mapped, and deleted instances will be
+removed automatically. */
+static void
+cache_subwindow_instance_in_frame_maybe (Lisp_Object instance)
+{
+Lisp_Image_Instance* ii = XIMAGE_INSTANCE (instance);
+if (image_instance_type_to_mask (IMAGE_INSTANCE_TYPE (ii))
+& (IMAGE_WIDGET_MASK | IMAGE_SUBWINDOW_MASK))
+{
+struct frame* f = DOMAIN_XFRAME (IMAGE_INSTANCE_DOMAIN (ii));
+XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))
+	= Fcons (instance, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)));
+}
+}
+/* Unmap and finalize all subwindow instances in the frame cache. This
+is necessary because GC will not guarantee the order things get
+deleted in and moreover, frame finalization deletes the window
+system windows before deleting XEmacs windows, and hence
+subwindows.  */
 void
-reset_subwindow_cachels (struct frame *f)
+free_frame_subwindow_instance_cache (struct frame* f)
 {
-int elt;
+Lisp_Object rest;
-for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
-{
+LIST_LOOP (rest, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)))
-struct subwindow_cachel *cachel =
+{
-	Dynarr_atp (f->subwindow_cachels, elt);
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (XCAR (rest));
+/* Make sure that the subwindow is unmapped so that window
-if (!NILP (cachel->subwindow) && cachel->being_displayed)
+	 deletion will not try and do it again. */
-	{
+unmap_subwindow (XCAR (rest));
-	  cachel->updated = 1;
+finalize_image_instance (ii, 0);
-	  /* #### This is not optimal as update_subwindow will search
+}
-the cachels for ourselves as well. We could easily optimize. */
+}
-	  unmap_subwindow (cachel->subwindow);
-	}
+/* Unmap and remove all instances from the frame cache. */
-}
-Dynarr_reset (f->subwindow_cachels);
-}
 void
-mark_subwindow_cachels_as_not_updated (struct frame *f)
+reset_frame_subwindow_instance_cache (struct frame* f)
 {
-int elt;
+Lisp_Object rest;
-for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
+LIST_LOOP (rest, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)))
-Dynarr_atp (f->subwindow_cachels, elt)->updated = 0;
+{
-}
+Lisp_Object value = XCAR (rest);
+/* Make sure that the subwindow is unmapped so that window
+	 deletion will not try and do it again. */
+unmap_subwindow (value);
+XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))
+	= delq_no_quit (value, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)));
+}
+}
 /*****************************************************************************
 *                              subwindow exposure ignorance                    *
 *****************************************************************************/
 /* when we unmap subwindows the associated window system will generate
 See if there is a subwindow that completely encloses the requested
 area.
 ****************************************************************************/
 int find_matching_subwindow (struct frame* f, int x, int y, int width, int height)
 {
-int elt;
+Lisp_Object rest;
-for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
+LIST_LOOP (rest, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)))
 {
-struct subwindow_cachel *cachel =
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (XCAR (rest));
-	Dynarr_atp (f->subwindow_cachels, elt);
+if (IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii)
-if (cachel->being_displayed
 	  &&
-	  cachel->x <= x && cachel->y <= y
+	  IMAGE_INSTANCE_DISPLAY_X (ii) <= x
+	  &&
+	  IMAGE_INSTANCE_DISPLAY_Y (ii) <= y
 	  &&
-	  cachel->x + cachel->width >= x + width
+	  IMAGE_INSTANCE_DISPLAY_X (ii)
+	  + IMAGE_INSTANCE_DISPLAY_WIDTH (ii) >= x + width
 	  &&
-	  cachel->y + cachel->height >= y + height)
+	  IMAGE_INSTANCE_DISPLAY_Y (ii)
+	  + IMAGE_INSTANCE_DISPLAY_HEIGHT (ii) >= y + height)
 	{
 	  return 1;
 	}
 }
 return 0;
 common for this function to get called from somewhere in
 redisplay we need to make sure that quits are ignored.  Otherwise
 Fsignal will abort. */
 specbind (Qinhibit_quit, Qt);
-if (IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
+ERROR_CHECK_IMAGE_INSTANCE (subwindow);
-||
-IMAGE_INSTANCE_TYPE (ii) == IMAGE_LAYOUT)
+if (WIDGET_IMAGE_INSTANCEP (subwindow))
 {
 if (image_instance_changed (subwindow))
 	update_widget (subwindow);
 /* Reset the changed flags. */
 IMAGE_INSTANCE_WIDGET_FACE_CHANGED (ii) = 0;
 IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) = 0;
 IMAGE_INSTANCE_TEXT_CHANGED (ii) = 0;
 }
 else if (IMAGE_INSTANCE_TYPE (ii) == IMAGE_SUBWINDOW
 	   &&
-	   !NILP (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii)))
+	   !NILP (IMAGE_INSTANCE_FRAME (ii)))
 {
-MAYBE_DEVMETH (XDEVICE (ii->device), update_subwindow, (ii));
+MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain),
+		     update_subwindow, (ii));
 }
 IMAGE_INSTANCE_SIZE_CHANGED (ii) = 0;
 /* This function is typically called by redisplay just before
 outputting the information to the screen. Thus we record a hash
 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
 if (internal_hash (subwindow, IMAGE_INSTANCE_HASH_DEPTH) !=
 IMAGE_INSTANCE_DISPLAY_HASH (ii))
 return 1;
-else if ((WIDGET_IMAGE_INSTANCEP (subwindow)
+/* #### I think there is probably a bug here. This gets called for
-	    || LAYOUT_IMAGE_INSTANCEP (subwindow))
+layouts - and yet the pending items are always nil for
-	   && !internal_equal (IMAGE_INSTANCE_WIDGET_ITEMS (ii),
+layouts. We are saved by layout optimization, but I'm undecided
-			       IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii), 0))
+as to what the correct fix is. */
+else if (WIDGET_IMAGE_INSTANCEP (subwindow)
+	   && (!internal_equal (IMAGE_INSTANCE_WIDGET_ITEMS (ii),
+				IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii), 0)
+	       || !NILP (IMAGE_INSTANCE_LAYOUT_CHILDREN (ii))))
 return 1;
 else
 return 0;
 }
 /* Update all the subwindows on a frame. */
-DEFUN ("update-widget-instances", Fupdate_widget_instances,1, 1, 0, /*
+void
-Given a FRAME, re-evaluate the display hash code for all widgets in the frame.
+update_widget_instances (Lisp_Object frame)
-Don't use this.
+{
-*/
-(frame))
-{
-int elt;
 struct frame* f;
+Lisp_Object rest;
+/* Its possible for the preceeding callback to have deleted the
+frame, so cope with this. */
+if (!FRAMEP (frame) || !FRAME_LIVE_P (XFRAME (frame)))
+return;
 CHECK_FRAME (frame);
 f = XFRAME (frame);
 /* If we get called we know something has changed. */
-for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
+LIST_LOOP (rest, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)))
 {
-	struct subwindow_cachel *cachel =
+Lisp_Object widget = XCAR (rest);
-	  Dynarr_atp (f->subwindow_cachels, elt);
+if (XIMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (widget)
-	if (cachel->being_displayed &&
+	  &&
-	    image_instance_changed (cachel->subwindow))
+	  image_instance_changed (widget))
-	  {
+	{
-	    set_image_instance_dirty_p (cachel->subwindow, 1);
+	  set_image_instance_dirty_p (widget, 1);
-	    MARK_FRAME_GLYPHS_CHANGED (f);
+	  MARK_FRAME_GLYPHS_CHANGED (f);
-	  }
+	}
 }
-return Qnil;
 }
 /* remove a subwindow from its frame */
 void unmap_subwindow (Lisp_Object subwindow)
 {
 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
-int elt;
-struct subwindow_cachel* cachel;
 struct frame* f;
-if (!(IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
+ERROR_CHECK_IMAGE_INSTANCE (subwindow);
-	||
-	IMAGE_INSTANCE_TYPE (ii) == IMAGE_SUBWINDOW)
+if (!image_instance_type_to_mask (IMAGE_INSTANCE_TYPE (ii))
+& (IMAGE_WIDGET_MASK | IMAGE_SUBWINDOW_MASK)
 ||
-NILP (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii)))
+!IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii))
 return;
 #ifdef DEBUG_WIDGETS
 stderr_out ("unmapping subwindow %d\n", IMAGE_INSTANCE_SUBWINDOW_ID (ii));
 #endif
-f = XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii));
+f = XFRAME (IMAGE_INSTANCE_FRAME (ii));
-elt = get_subwindow_cachel_index (f, subwindow);
-cachel = Dynarr_atp (f->subwindow_cachels, elt);
 /* make sure we don't get expose events */
-register_ignored_expose (f, cachel->x, cachel->y, cachel->width, cachel->height);
+register_ignored_expose (f, IMAGE_INSTANCE_DISPLAY_X (ii),
-cachel->x = ~0;
+			   IMAGE_INSTANCE_DISPLAY_Y (ii),
-cachel->y = ~0;
+			   IMAGE_INSTANCE_DISPLAY_WIDTH (ii),
-cachel->being_displayed = 0;
+			   IMAGE_INSTANCE_DISPLAY_HEIGHT (ii));
 IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii) = 0;
-MAYBE_DEVMETH (XDEVICE (ii->device), unmap_subwindow, (ii));
+MAYBE_DEVMETH (XDEVICE (IMAGE_INSTANCE_DEVICE (ii)),
+		 unmap_subwindow, (ii));
 }
 /* show a subwindow in its frame */
 void map_subwindow (Lisp_Object subwindow, int x, int y,
 		    struct display_glyph_area *dga)
 {
 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
-int elt;
-struct subwindow_cachel* cachel;
 struct frame* f;
-if (!(IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
+ERROR_CHECK_IMAGE_INSTANCE (subwindow);
-	||
-	IMAGE_INSTANCE_TYPE (ii) == IMAGE_SUBWINDOW)
+if (!image_instance_type_to_mask (IMAGE_INSTANCE_TYPE (ii))
-||
+& (IMAGE_WIDGET_MASK | IMAGE_SUBWINDOW_MASK))
-NILP (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii)))
 return;
 #ifdef DEBUG_WIDGETS
 stderr_out ("mapping subwindow %d, %dx%d@%d+%d\n",
 	      IMAGE_INSTANCE_SUBWINDOW_ID (ii),
 	      dga->width, dga->height, x, y);
 #endif
-f = XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii));
+f = XFRAME (IMAGE_INSTANCE_FRAME (ii));
 IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii) = 1;
-elt = get_subwindow_cachel_index (f, subwindow);
+IMAGE_INSTANCE_DISPLAY_X (ii) = x;
-cachel = Dynarr_atp (f->subwindow_cachels, elt);
+IMAGE_INSTANCE_DISPLAY_Y (ii) = y;
-cachel->x = x;
+IMAGE_INSTANCE_DISPLAY_WIDTH (ii) = dga->width;
-cachel->y = y;
+IMAGE_INSTANCE_DISPLAY_HEIGHT (ii) = dga->height;
-cachel->width = dga->width;
-cachel->height = dga->height;
+MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain),
-cachel->being_displayed = 1;
+		 map_subwindow, (ii, x, y, dga));
-MAYBE_DEVMETH (XDEVICE (ii->device), map_subwindow, (ii, x, y, dga));
 }
 static int
 subwindow_possible_dest_types (void)
 {
 return IMAGE_SUBWINDOW_MASK;
+}
+int
+subwindow_governing_domain (void)
+{
+return GOVERNING_DOMAIN_WINDOW;
 }
 /* Partially instantiate a subwindow. */
 void
 subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		       Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		       int dest_mask, Lisp_Object domain)
 {
 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
+Lisp_Object device = image_instance_device (image_instance);
-Lisp_Object frame = FW_FRAME (domain);
+Lisp_Object frame = DOMAIN_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);
 incompatible_image_types (instantiator, dest_mask, IMAGE_SUBWINDOW_MASK);
 ii->data = 0;
 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = 0;
 IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (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 an appropriate geometry. */
 if (INTP (width))
 {
 int w = 1;
 if (XINT (width) > 1)
 	w = XINT (width);
-IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = w;
+IMAGE_INSTANCE_WIDTH (ii) = w;
-}
+IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0;
-else
+}
-IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = 20;
 if (INTP (height))
 {
 int h = 1;
 if (XINT (height) > 1)
 	h = XINT (height);
-IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii) = h;
+IMAGE_INSTANCE_HEIGHT (ii) = h;
-}
+IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0;
-else
+}
-IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii) = 20;
+}
+/* This is just a backup in case no-one has assigned a suitable geometry.
+#### It should really query the enclose window for geometry. */
+static void
+subwindow_query_geometry (Lisp_Object image_instance, unsigned int* width,
+			  unsigned int* height, enum image_instance_geometry disp,
+			  Lisp_Object domain)
+{
+if (width)	*width = 20;
+if (height)	*height = 20;
 }
 DEFUN ("subwindowp", Fsubwindowp, 1, 1, 0, /*
 Return non-nil if OBJECT is a subwindow.
 */
 /* The actual resizing gets done asychronously by
 update_subwindow. */
 IMAGE_INSTANCE_HEIGHT (ii) = newh;
 IMAGE_INSTANCE_WIDTH (ii) = neww;
 IMAGE_INSTANCE_SIZE_CHANGED (ii) = 1;
-/* need to update the cachels as redisplay will not do this */
-update_subwindow_cachel (subwindow);
 return subwindow;
 }
 DEFUN ("force-subwindow-map", Fforce_subwindow_map, 1, 1, 0, /*
 		(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)));
+		(XDEVICE (image_instance_device (value)));
 	      /* Cascade dirtiness so that we can have an animated glyph in a layout
 		 for instance. */
 	      set_image_instance_dirty_p (value, 1);
 	    }
 	}
 DEFSUBR (Fimage_instantiator_format_list);
 DEFSUBR (Fvalid_image_instantiator_format_p);
 DEFSUBR (Fset_console_type_image_conversion_list);
 DEFSUBR (Fconsole_type_image_conversion_list);
-DEFSUBR (Fupdate_widget_instances);
 defkeyword (&Q_file, ":file");
 defkeyword (&Q_data, ":data");
 defkeyword (&Q_face, ":face");
 defkeyword (&Q_pixel_height, ":pixel-height");
 defsymbol (&Qmono_pixmap_image_instance_p, "mono-pixmap-image-instance-p");
 defsymbol (&Qcolor_pixmap_image_instance_p, "color-pixmap-image-instance-p");
 defsymbol (&Qpointer_image_instance_p, "pointer-image-instance-p");
 defsymbol (&Qwidget_image_instance_p, "widget-image-instance-p");
 defsymbol (&Qsubwindow_image_instance_p, "subwindow-image-instance-p");
-defsymbol (&Qlayout_image_instance_p, "layout-image-instance-p");
-defsymbol (&Qupdate_widget_instances, "update-widget-instances");
 DEFSUBR (Fmake_image_instance);
 DEFSUBR (Fimage_instance_p);
 DEFSUBR (Fimage_instance_type);
 DEFSUBR (Fvalid_image_instance_type_p);
 DEFSUBR (Fimage_instance_type_list);
 DEFSUBR (Fimage_instance_name);
+DEFSUBR (Fimage_instance_domain);
 DEFSUBR (Fimage_instance_string);
 DEFSUBR (Fimage_instance_file_name);
 DEFSUBR (Fimage_instance_mask_file_name);
 DEFSUBR (Fimage_instance_depth);
 DEFSUBR (Fimage_instance_height);
 IIFORMAT_VALID_KEYWORD (inherit, Q_face, check_valid_face);
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (string, "string");
 IIFORMAT_HAS_METHOD (string, validate);
+IIFORMAT_HAS_SHARED_METHOD (string, governing_domain, subwindow);
 IIFORMAT_HAS_METHOD (string, possible_dest_types);
 IIFORMAT_HAS_METHOD (string, instantiate);
 IIFORMAT_VALID_KEYWORD (string, Q_data, check_valid_string);
 /* Do this so we can set strings. */
+/* #### Andy, what is this?  This is a bogus format and should not be
+visible to the user. */
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (text, "text");
 IIFORMAT_HAS_METHOD (text, set_property);
 IIFORMAT_HAS_METHOD (text, query_geometry);
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (formatted_string, "formatted-string");
 IIFORMAT_HAS_METHOD (formatted_string, validate);
 IIFORMAT_HAS_METHOD (formatted_string, possible_dest_types);
 IIFORMAT_HAS_METHOD (formatted_string, instantiate);
 IIFORMAT_VALID_KEYWORD (formatted_string, Q_data, check_valid_string);
+/* Do this so pointers have geometry. */
+/* #### Andy, what is this?  This is a bogus format and should not be
+visible to the user. */
+INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (pointer, "pointer");
+IIFORMAT_HAS_SHARED_METHOD (pointer, query_geometry, subwindow);
 /* subwindows */
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (subwindow, "subwindow");
 IIFORMAT_HAS_METHOD (subwindow, possible_dest_types);
+IIFORMAT_HAS_METHOD (subwindow, governing_domain);
 IIFORMAT_HAS_METHOD (subwindow, instantiate);
+IIFORMAT_HAS_METHOD (subwindow, query_geometry);
 IIFORMAT_VALID_KEYWORD (subwindow, Q_pixel_width, check_valid_int);
 IIFORMAT_VALID_KEYWORD (subwindow, Q_pixel_height, check_valid_int);
 #ifdef HAVE_WINDOW_SYSTEM
 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (xbm, "xbm");
 /* display tables */
 DEFVAR_SPECIFIER ("current-display-table", &Vcurrent_display_table /*
 *The display table currently in use.
 This is a specifier; use `set-specifier' to change it.
-The display table is a vector created with `make-display-table'.
-The 256 elements control how to display each possible text character.
+Display tables are used to control how characters are displayed.  Each
-Each value should be a string, a glyph, a vector or nil.
+time that redisplay processes a character, it is looked up in all the
-If a value is a vector it must be composed only of strings and glyphs.
+display tables that apply (obtained by calling `specifier-instance' on
-nil means display the character in the default fashion.
+`current-display-table' and any overriding display tables specified in
-Faces can have their own, overriding display table.
+currently active faces).  The first entry found that matches the
+character determines how the character is displayed.  If there is no
+matching entry, the default display method is used. (Non-control
+characters are displayed as themselves and control characters are
+displayed according to the buffer-local variable `ctl-arrow'.  Control
+characters are further affected by `control-arrow-glyph' and
+`octal-escape-glyph'.)
+Each instantiator in this specifier and the display-table specifiers
+in faces is a display table or a list of such tables.  If a list, each
+table will be searched in turn for an entry matching a particular
+character.  Each display table is one of
+-- a vector, specifying values for characters starting at 0
+-- a char table, either of type `char' or `generic'
+-- a range table
+Each entry in a display table should be one of
+-- nil (this entry is ignored and the search continues)
+-- a character (use this character; if it happens to be the same as
+the original character, default processing happens, otherwise
+redisplay attempts to display this character directly;
+#### At some point recursive display-table lookup will be
+implemented.)
+-- a string (display each character in the string directly;
+#### At some point recursive display-table lookup will be
+implemented.)
+-- a glyph (display the glyph;
+#### At some point recursive display-table lookup will be
+implemented when a string glyph is being processed.)
+-- a cons of the form (format "STRING") where STRING is a printf-like
+spec used to process the character. #### Unfortunately no
+formatting directives other than %% are implemented.
+-- a vector (each element of the vector is processed recursively;
+in such a case, nil elements in the vector are simply ignored)
+#### At some point in the near future, display tables are likely to
+be expanded to include other features, such as referencing characters
+in particular fonts and allowing the character search to continue
+all the way up the chain of specifier instantiators.  These features
+are necessary to properly display Unicode characters.
 */ );
 Vcurrent_display_table = Fmake_specifier (Qdisplay_table);
 set_specifier_fallback (Vcurrent_display_table,
 			  list1 (Fcons (Qnil, Qnil)));
 set_specifier_caching (Vcurrent_display_table,

Mercurial > hg > xemacs-beta

comparison src/glyphs.c @ 408:501cfd01ee6d r21-2-34