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;
EXFUN (Fimage_instance_type, 1);
EXFUN (Fglyph_type, 1);
+EXFUN (Fnext_window, 4);
\f
/****************************************************************************
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_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;
break;
case IMAGE_WIDGET:
+ print_internal (IMAGE_INSTANCE_WIDGET_TYPE (ii), printcharfun, 0);
+
+ if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)))
+ {
+ write_c_string (" ", printcharfun);
+ print_internal (IMAGE_INSTANCE_WIDGET_TEXT (ii), printcharfun, 1);
+ }
+
if (!NILP (IMAGE_INSTANCE_WIDGET_FACE (ii)))
{
- write_c_string (" (", printcharfun);
+ write_c_string (" face=", printcharfun);
print_internal
(IMAGE_INSTANCE_WIDGET_FACE (ii), printcharfun, 0);
- write_c_string (")", printcharfun);
}
- if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)))
- print_internal (IMAGE_INSTANCE_WIDGET_TEXT (ii), printcharfun, 0);
case IMAGE_SUBWINDOW:
case IMAGE_LAYOUT:
else
write_c_string (DEVICE_TYPE_NAME (XDEVICE (FRAME_DEVICE (f))),
printcharfun);
-
- write_c_string ("-frame ", printcharfun);
}
- write_c_string (">", printcharfun);
+ write_c_string ("-frame>", printcharfun);
sprintf (buf, " 0x%p", IMAGE_INSTANCE_SUBWINDOW_ID (ii));
write_c_string (buf, printcharfun);
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_WIDGET_PROPS (i1),
IMAGE_INSTANCE_WIDGET_PROPS (i2),
depth + 1)
+ && internal_equal (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (i1),
+ IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (i2),
+ depth + 1)
+ && internal_equal (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (i1),
+ IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (i2),
+ depth + 1)
))
return 0;
break;
return DEVMETH_OR_GIVEN (d1, image_instance_equal, (i1, i2, depth), 1);
}
+#if 0
+/* internal_hash will not go very far down a list because of the way
+ its written. For items we need to hash all elements so we provide
+ our own list hashing function. */
+static unsigned long
+full_list_hash (Lisp_Object obj, int depth)
+{
+ unsigned long hash = 0;
+ Lisp_Object rest;
+
+ if (!CONSP (obj))
+ return internal_hash (obj, depth + 1);
+
+ hash = LISP_HASH (XCAR (obj));
+ LIST_LOOP (rest, XCDR (obj))
+ {
+ hash = HASH2 (hash, internal_hash (XCAR (rest), depth + 1));
+ }
+ return hash;
+}
+#endif
+
static unsigned long
image_instance_hash (Lisp_Object obj, int depth)
{
case IMAGE_WIDGET:
case IMAGE_LAYOUT:
+ /* We need the hash to be equivalent to what should be
+ displayed. */
hash = HASH4 (hash,
- internal_hash (IMAGE_INSTANCE_WIDGET_TYPE (i), depth + 1),
+ 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));
case IMAGE_SUBWINDOW:
Lisp_Object pointer_fg = Qnil;
Lisp_Object pointer_bg = Qnil;
+ /* 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
+ image_instance until after it has been created. We thus need
+ to be really careful how we place things. */
+
if (pointerp)
{
pointer_fg = FACE_FOREGROUND (Vpointer_face, domain);
&&
dest_mask & (IMAGE_SUBWINDOW_MASK
| IMAGE_WIDGET_MASK
- | IMAGE_TEXT_MASK))
+ | IMAGE_LAYOUT_MASK
+ | IMAGE_TEXT_MASK)
+ && WINDOWP (domain))
{
- 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);
cache. */
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 ))
{
+#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 subwindow outside a window",
+ signal_simple_error ("Can't instantiate text or subwindow outside a window",
instantiator);
-
- Fsetcdr (XCDR (locative), XWINDOW (domain)->subwindow_instance_cache );
+#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_LAYOUT_MASK
+ | IMAGE_TEXT_MASK ))
+ assert (EQ (Fgethash ((pointerp ? ls3 : instantiator),
+ XWINDOW (domain)->subwindow_instance_cache,
+ Qunbound), instance));
+#endif
}
else
free_list (ls3);
if (NILP (instance))
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),
+ FW_FRAME (domain)));
+#endif
return instance;
}
/* Update the displayed characteristics of a subwindow. This function
should generally only get called if the subwindow is actually
- dirty. The only other time it gets called is if subwindow state
- changed, when we can't actually tell whether its going to be dirty
- or not.
- #### I suspect what we should really do is re-evaluate all the
- gui slots that could affect this and then mark the instance as
- dirty. Right now, updating everything is safe but expensive. */
+ dirty. */
void
update_subwindow (Lisp_Object subwindow)
{
||
IMAGE_INSTANCE_TYPE (ii) == IMAGE_LAYOUT)
{
- if (IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET)
+ if (image_instance_changed (subwindow))
update_widget (subwindow);
/* Reset the changed flags. */
IMAGE_INSTANCE_WIDGET_FACE_CHANGED (ii) = 0;
- IMAGE_INSTANCE_WIDGET_PERCENT_CHANGED (ii) = 0;
IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) = 0;
IMAGE_INSTANCE_TEXT_CHANGED (ii) = 0;
}
}
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
+ of the output to determine whether on-screen is the same as
+ recorded structure. This approach has limitations in there is a
+ good chance that hash values will be different for the same
+ visual appearance. However, we would rather that then the other
+ way round - it simply means that we will get more displays than
+ we might need. We can get better hashing by making the depth
+ negative - currently it will recurse down 7 levels.*/
+ IMAGE_INSTANCE_DISPLAY_HASH (ii) = internal_hash (subwindow,
+ IMAGE_INSTANCE_HASH_DEPTH);
unbind_to (count, Qnil);
}
+int
+image_instance_changed (Lisp_Object subwindow)
+{
+ 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)
+ || LAYOUT_IMAGE_INSTANCEP (subwindow))
+ && !internal_equal (IMAGE_INSTANCE_WIDGET_ITEMS (ii),
+ IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii), 0))
+ return 1;
+ else
+ return 0;
+}
+
/* Update all the subwindows on a frame. */
-void
-update_frame_subwindows (struct frame *f)
+DEFUN ("update-widget-instances", Fupdate_widget_instances,1, 1, 0, /*
+Given a FRAME, re-evaluate the display hash code for all widgets in the frame.
+Don't use this.
+*/
+ (frame))
{
int elt;
+ struct frame* f;
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
- /* #### Checking all of these might be overkill now that we update
- subwindows in the actual redisplay code. */
- if (f->subwindows_changed || f->subwindows_state_changed || f->faces_changed)
- for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
+ /* If we get called we know something has 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
- &&
- /* We only want to update if something has really
- changed. */
- (f->subwindows_state_changed
- ||
- XIMAGE_INSTANCE_DIRTYP (cachel->subwindow)))
+ if (cachel->being_displayed &&
+ image_instance_changed (cachel->subwindow))
{
- update_subwindow (cachel->subwindow);
+ set_image_instance_dirty_p (cachel->subwindow, 1);
+ MARK_FRAME_GLYPHS_CHANGED (f);
}
}
+ return Qnil;
}
/* remove a subwindow from its frame */
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 (NILP (width))
- IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = 20;
- else
+ if (INTP (width))
{
int w = 1;
- CHECK_INT (width);
if (XINT (width) > 1)
w = XINT (width);
IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = w;
}
- if (NILP (height))
- IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii) = 20;
else
+ IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = 20;
+
+ if (INTP (height))
{
int h = 1;
- CHECK_INT (height);
if (XINT (height) > 1)
h = XINT (height);
IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii) = h;
}
+ else
+ IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii) = 20;
}
DEFUN ("subwindowp", Fsubwindowp, 1, 1, 0, /*
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");
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);
projects / chise / xemacs-chise.git.1 / blobdiff