Copyright (C) 1995 Tinker Systems
Copyright (C) 1995, 1996 Ben Wing
Copyright (C) 1995 Sun Microsystems
- Copyright (C) 1998, 1999 Andy Piper
+ Copyright (C) 1998, 1999, 2000 Andy Piper
This file is part of XEmacs.
/* Synched up with: Not in FSF. */
-/* Written by Ben Wing and Chuck Thompson. */
+/* Written by Ben Wing and Chuck Thompson. Heavily modified /
+ rewritten by Andy Piper. */
#include <config.h>
#include "lisp.h"
image_instantiator_format_entry_dynarr *
the_image_instantiator_format_entry_dynarr;
-static Lisp_Object allocate_image_instance (Lisp_Object device);
+static Lisp_Object allocate_image_instance (Lisp_Object device, Lisp_Object glyph);
static void image_validate (Lisp_Object instantiator);
static void glyph_property_was_changed (Lisp_Object glyph,
Lisp_Object property,
if ((NILP (d) && NILP (device))
||
(!NILP (device) &&
- EQ (CONSOLE_TYPE (XCONSOLE
+ EQ (CONSOLE_TYPE (XCONSOLE
(DEVICE_CONSOLE (XDEVICE (device)))), d)))
return Dynarr_at (the_image_instantiator_format_entry_dynarr, i).meths;
}
struct image_instantiator_methods *meths;
GCPRO1 (instantiator);
-
+
meths = decode_image_instantiator_format (XVECTOR_DATA (instantiator)[0],
ERROR_ME);
RETURN_UNGCPRO (IIFORMAT_METH_OR_GIVEN (meths, normalize,
instantiate_image_instantiator (Lisp_Object device, Lisp_Object domain,
Lisp_Object instantiator,
Lisp_Object pointer_fg, Lisp_Object pointer_bg,
- int dest_mask)
+ int dest_mask, Lisp_Object glyph)
{
- Lisp_Object ii = allocate_image_instance (device);
+ Lisp_Object ii = allocate_image_instance (device, glyph);
struct image_instantiator_methods *meths;
struct gcpro gcpro1;
int methp = 0;
methp = (int)HAS_IIFORMAT_METH_P (meths, instantiate);
MAYBE_IIFORMAT_METH (meths, instantiate, (ii, instantiator, pointer_fg,
pointer_bg, dest_mask, domain));
-
+
/* now do device specific instantiation */
meths = decode_device_ii_format (device, XVECTOR_DATA (instantiator)[0],
ERROR_ME_NOT);
static Lisp_Object
mark_image_instance (Lisp_Object obj)
{
- struct Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
+ Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
mark_object (i->name);
+ /* We don't mark the glyph reference since that would create a
+ circularity preventing GC. */
switch (IMAGE_INSTANCE_TYPE (i))
{
case IMAGE_TEXT:
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_SUBWINDOW_FRAME (i));
break;
- case IMAGE_LAYOUT:
- mark_object (IMAGE_INSTANCE_LAYOUT_CHILDREN (i));
- mark_object (IMAGE_INSTANCE_LAYOUT_BORDER (i));
- mark_object (IMAGE_INSTANCE_SUBWINDOW_FRAME (i));
- break;
-
default:
break;
}
int escapeflag)
{
char buf[100];
- struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (obj);
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (obj);
if (print_readably)
error ("printing unreadable object #<image-instance 0x%x>",
break;
case IMAGE_WIDGET:
- /*
- if (!NILP (IMAGE_INSTANCE_WIDGET_CALLBACK (ii)))
- {
- print_internal (IMAGE_INSTANCE_WIDGET_CALLBACK (ii), printcharfun, 0);
- write_c_string (", ", printcharfun);
- }
- */
if (!NILP (IMAGE_INSTANCE_WIDGET_FACE (ii)))
{
write_c_string (" (", printcharfun);
write_c_string (" on #<", printcharfun);
{
struct frame* f = XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (ii));
-
+
if (!FRAME_LIVE_P (f))
write_c_string ("dead", printcharfun);
- else
+ else
write_c_string (DEVICE_TYPE_NAME (XDEVICE (FRAME_DEVICE (f))),
printcharfun);
write_c_string (">", printcharfun);
sprintf (buf, " 0x%p", IMAGE_INSTANCE_SUBWINDOW_ID (ii));
write_c_string (buf, printcharfun);
-
+
break;
default:
static void
finalize_image_instance (void *header, int for_disksave)
{
- struct Lisp_Image_Instance *i = (struct Lisp_Image_Instance *) header;
+ Lisp_Image_Instance *i = (Lisp_Image_Instance *) header;
if (IMAGE_INSTANCE_TYPE (i) == IMAGE_NOTHING)
/* objects like this exist at dump time, so don't bomb out. */
||
IMAGE_INSTANCE_TYPE (i) == IMAGE_SUBWINDOW)
{
- MARK_FRAME_SUBWINDOWS_CHANGED
+ MARK_FRAME_SUBWINDOWS_CHANGED
(XFRAME (IMAGE_INSTANCE_SUBWINDOW_FRAME (i)));
}
static int
image_instance_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
- struct Lisp_Image_Instance *i1 = XIMAGE_INSTANCE (obj1);
- struct Lisp_Image_Instance *i2 = XIMAGE_INSTANCE (obj2);
+ 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);
if (d1 != d2)
return 0;
- if (IMAGE_INSTANCE_TYPE (i1) != IMAGE_INSTANCE_TYPE (i2))
+ if (IMAGE_INSTANCE_TYPE (i1) != IMAGE_INSTANCE_TYPE (i2)
+ || IMAGE_INSTANCE_WIDTH (i1) != IMAGE_INSTANCE_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))
case IMAGE_MONO_PIXMAP:
case IMAGE_COLOR_PIXMAP:
case IMAGE_POINTER:
- if (!(IMAGE_INSTANCE_PIXMAP_WIDTH (i1) ==
- IMAGE_INSTANCE_PIXMAP_WIDTH (i2) &&
- IMAGE_INSTANCE_PIXMAP_HEIGHT (i1) ==
- IMAGE_INSTANCE_PIXMAP_HEIGHT (i2) &&
- IMAGE_INSTANCE_PIXMAP_DEPTH (i1) ==
+ if (!(IMAGE_INSTANCE_PIXMAP_DEPTH (i1) ==
IMAGE_INSTANCE_PIXMAP_DEPTH (i2) &&
IMAGE_INSTANCE_PIXMAP_SLICE (i1) ==
IMAGE_INSTANCE_PIXMAP_SLICE (i2) &&
break;
case IMAGE_WIDGET:
+ case IMAGE_LAYOUT:
if (!(EQ (IMAGE_INSTANCE_WIDGET_TYPE (i1),
IMAGE_INSTANCE_WIDGET_TYPE (i2))
+ && IMAGE_INSTANCE_SUBWINDOW_ID (i1) ==
+ IMAGE_INSTANCE_SUBWINDOW_ID (i2)
&& internal_equal (IMAGE_INSTANCE_WIDGET_ITEMS (i1),
IMAGE_INSTANCE_WIDGET_ITEMS (i2),
depth + 1)
depth + 1)
))
return 0;
- case IMAGE_LAYOUT:
- if (IMAGE_INSTANCE_TYPE (i1) == IMAGE_LAYOUT
- &&
- !(EQ (IMAGE_INSTANCE_LAYOUT_BORDER (i1),
- IMAGE_INSTANCE_LAYOUT_BORDER (i2))
- &&
- internal_equal (IMAGE_INSTANCE_LAYOUT_CHILDREN (i1),
- IMAGE_INSTANCE_LAYOUT_CHILDREN (i2),
- depth + 1)))
- return 0;
+ break;
+
case IMAGE_SUBWINDOW:
- if (!(IMAGE_INSTANCE_SUBWINDOW_WIDTH (i1) ==
- IMAGE_INSTANCE_SUBWINDOW_WIDTH (i2) &&
- IMAGE_INSTANCE_SUBWINDOW_HEIGHT (i1) ==
- IMAGE_INSTANCE_SUBWINDOW_HEIGHT (i2) &&
- IMAGE_INSTANCE_SUBWINDOW_ID (i1) ==
+ if (!(IMAGE_INSTANCE_SUBWINDOW_ID (i1) ==
IMAGE_INSTANCE_SUBWINDOW_ID (i2)))
return 0;
break;
static unsigned long
image_instance_hash (Lisp_Object obj, int depth)
{
- struct Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
+ Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj);
struct device *d = XDEVICE (i->device);
- unsigned long hash = (unsigned long) d;
+ unsigned long hash = HASH3 ((unsigned long) d,
+ IMAGE_INSTANCE_WIDTH (i),
+ IMAGE_INSTANCE_HEIGHT (i));
switch (IMAGE_INSTANCE_TYPE (i))
{
case IMAGE_MONO_PIXMAP:
case IMAGE_COLOR_PIXMAP:
case IMAGE_POINTER:
- hash = HASH6 (hash, IMAGE_INSTANCE_PIXMAP_WIDTH (i),
- IMAGE_INSTANCE_PIXMAP_HEIGHT (i),
- IMAGE_INSTANCE_PIXMAP_DEPTH (i),
+ hash = HASH4 (hash, IMAGE_INSTANCE_PIXMAP_DEPTH (i),
IMAGE_INSTANCE_PIXMAP_SLICE (i),
internal_hash (IMAGE_INSTANCE_PIXMAP_FILENAME (i),
depth + 1));
break;
case IMAGE_WIDGET:
- hash = HASH4 (hash,
+ case IMAGE_LAYOUT:
+ hash = HASH4 (hash,
internal_hash (IMAGE_INSTANCE_WIDGET_TYPE (i), depth + 1),
internal_hash (IMAGE_INSTANCE_WIDGET_PROPS (i), depth + 1),
internal_hash (IMAGE_INSTANCE_WIDGET_ITEMS (i), depth + 1));
- case IMAGE_LAYOUT:
- if (IMAGE_INSTANCE_TYPE (i) == IMAGE_LAYOUT)
- hash = HASH3 (hash,
- internal_hash (IMAGE_INSTANCE_LAYOUT_BORDER (i), depth + 1),
- internal_hash (IMAGE_INSTANCE_LAYOUT_CHILDREN (i),
- depth + 1));
case IMAGE_SUBWINDOW:
- hash = HASH4 (hash, IMAGE_INSTANCE_SUBWINDOW_WIDTH (i),
- IMAGE_INSTANCE_SUBWINDOW_HEIGHT (i),
- (int) IMAGE_INSTANCE_SUBWINDOW_ID (i));
+ hash = HASH2 (hash, (int) IMAGE_INSTANCE_SUBWINDOW_ID (i));
break;
default:
mark_image_instance, print_image_instance,
finalize_image_instance, image_instance_equal,
image_instance_hash, 0,
- struct Lisp_Image_Instance);
+ Lisp_Image_Instance);
static Lisp_Object
-allocate_image_instance (Lisp_Object device)
+allocate_image_instance (Lisp_Object device, Lisp_Object glyph)
{
- struct Lisp_Image_Instance *lp =
- alloc_lcrecord_type (struct Lisp_Image_Instance, &lrecord_image_instance);
+ Lisp_Image_Instance *lp =
+ alloc_lcrecord_type (Lisp_Image_Instance, &lrecord_image_instance);
Lisp_Object val;
zero_lcrecord (lp);
lp->name = Qnil;
lp->x_offset = 0;
lp->y_offset = 0;
+ lp->width = 0;
+ lp->height = 0;
+ lp->glyph = glyph;
+ MARK_IMAGE_INSTANCE_CHANGED (lp); /* So that layouts get done. */
XSETIMAGE_INSTANCE (val, lp);
+ MARK_GLYPHS_CHANGED; /* So that the dirty flag gets reset. */
return val;
}
if (VECTORP (data) && EQ (XVECTOR_DATA (data)[0], Qinherit))
signal_simple_error ("Inheritance not allowed here", data);
ii = instantiate_image_instantiator (device, device, data,
- Qnil, Qnil, dest_mask);
+ Qnil, Qnil, dest_mask, Qnil);
RETURN_UNGCPRO (ii);
}
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.
+message is generated and this function returns nil.
*/
(data, device, dest_types, no_error))
{
}
DEFUN ("image-instance-property", Fimage_instance_property, 2, 2, 0, /*
-Return the given property of the given image instance.
+Return the given property of the given image instance.
Returns nil if the property or the property method do not exist for
-the image instance in the domain.
+the image instance in the domain.
*/
(image_instance, prop))
{
- struct Lisp_Image_Instance* ii;
+ Lisp_Image_Instance* ii;
Lisp_Object type, ret;
struct image_instantiator_methods* meths;
/* ... 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 (ii),
type, ERROR_ME_NOT);
if (meths && HAS_IIFORMAT_METH_P (meths, property)
- &&
+ &&
!UNBOUNDP (ret = IIFORMAT_METH (meths, property, (image_instance, prop))))
{
return ret;
}
DEFUN ("set-image-instance-property", Fset_image_instance_property, 3, 3, 0, /*
-Set the given property of the given image instance.
+Set the given property of the given image instance.
Does nothing if the property or the property method do not exist for
the image instance in the domain.
*/
(image_instance, prop, val))
{
- struct Lisp_Image_Instance* ii;
+ Lisp_Image_Instance* ii;
Lisp_Object type, ret;
struct image_instantiator_methods* meths;
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 (ii),
type, ERROR_ME_NOT);
if (meths && HAS_IIFORMAT_METH_P (meths, set_property)
&&
- !UNBOUNDP (ret =
+ !UNBOUNDP (ret =
IIFORMAT_METH (meths, set_property, (image_instance, prop, val))))
{
val = ret;
meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
if (meths && HAS_IIFORMAT_METH_P (meths, set_property)
&&
- !UNBOUNDP (ret =
+ !UNBOUNDP (ret =
IIFORMAT_METH (meths, set_property, (image_instance, prop, val))))
{
val = ret;
}
}
- /* Make sure the image instance gets redisplayed. */
+ /* Make sure the image instance gets redisplayed.
+
+ ### This currently does not change the dirty state of an
+ enclosing layout which may be bad. */
MARK_IMAGE_INSTANCE_CHANGED (ii);
MARK_SUBWINDOWS_STATE_CHANGED;
MARK_GLYPHS_CHANGED;
case IMAGE_MONO_PIXMAP:
case IMAGE_COLOR_PIXMAP:
case IMAGE_POINTER:
- return make_int (XIMAGE_INSTANCE_PIXMAP_HEIGHT (image_instance));
-
case IMAGE_SUBWINDOW:
case IMAGE_WIDGET:
case IMAGE_LAYOUT:
- return make_int (XIMAGE_INSTANCE_SUBWINDOW_HEIGHT (image_instance));
+ return make_int (XIMAGE_INSTANCE_HEIGHT (image_instance));
default:
return Qnil;
case IMAGE_MONO_PIXMAP:
case IMAGE_COLOR_PIXMAP:
case IMAGE_POINTER:
- return make_int (XIMAGE_INSTANCE_PIXMAP_WIDTH (image_instance));
-
case IMAGE_SUBWINDOW:
case IMAGE_WIDGET:
case IMAGE_LAYOUT:
- return make_int (XIMAGE_INSTANCE_SUBWINDOW_WIDTH (image_instance));
+ return make_int (XIMAGE_INSTANCE_WIDTH (image_instance));
default:
return Qnil;
case IMAGE_WIDGET:
return FACE_FOREGROUND (
XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
- XIMAGE_INSTANCE_SUBWINDOW_FRAME
+ XIMAGE_INSTANCE_SUBWINDOW_FRAME
(image_instance));
default:
case IMAGE_WIDGET:
return FACE_BACKGROUND (
XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
- XIMAGE_INSTANCE_SUBWINDOW_FRAME
+ XIMAGE_INSTANCE_SUBWINDOW_FRAME
(image_instance));
default:
/* #### There should be a copy_image_instance(), which calls a
device-specific method to copy the window-system subobject. */
- new = allocate_image_instance (device);
+ new = allocate_image_instance (device, 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
return new;
}
+
+/************************************************************************/
+/* Geometry calculations */
+/************************************************************************/
+
+/* Find out desired geometry of the image instance. If there is no
+ special function then just return the width and / or height. */
+void
+image_instance_query_geometry (Lisp_Object image_instance,
+ unsigned int* width, unsigned int* height,
+ enum image_instance_geometry disp,
+ Lisp_Object domain)
+{
+ Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
+ Lisp_Object type;
+ struct image_instantiator_methods* meths;
+
+ type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
+ meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
+
+ if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry))
+ {
+ IIFORMAT_METH (meths, query_geometry, (image_instance, width, height,
+ disp, domain));
+ }
+ else
+ {
+ if (width)
+ *width = IMAGE_INSTANCE_WIDTH (ii);
+ if (height)
+ *height = IMAGE_INSTANCE_HEIGHT (ii);
+ }
+}
+
+/* Layout the image instance using the provided dimensions. Layout
+ widgets are going to do different kinds of calculations to
+ determine what size to give things so we could make the layout
+ function relatively simple to take account of that. An alternative
+ approach is to consider separately the two cases, one where you
+ don't mind what size you have (normal widgets) and one where you
+ want to specifiy something (layout widgets). */
+void
+image_instance_layout (Lisp_Object image_instance,
+ unsigned int width, unsigned int height,
+ Lisp_Object domain)
+{
+ Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
+ Lisp_Object type;
+ struct image_instantiator_methods* meths;
+
+ type = encode_image_instance_type (IMAGE_INSTANCE_TYPE (ii));
+ meths = decode_device_ii_format (Qnil, type, ERROR_ME_NOT);
+
+ /* If geometry is unspecified then get some reasonable values for it. */
+ if (width == IMAGE_UNSPECIFIED_GEOMETRY
+ ||
+ height == IMAGE_UNSPECIFIED_GEOMETRY)
+ {
+ unsigned int dwidth, dheight;
+
+ /* Get the desired geometry. */
+ if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry))
+ {
+ IIFORMAT_METH (meths, query_geometry, (image_instance, &dwidth, &dheight,
+ IMAGE_DESIRED_GEOMETRY,
+ domain));
+ }
+ else
+ {
+ dwidth = IMAGE_INSTANCE_WIDTH (ii);
+ dheight = IMAGE_INSTANCE_HEIGHT (ii);
+ }
+
+ /* Compare with allowed geometry. */
+ if (width == IMAGE_UNSPECIFIED_GEOMETRY)
+ width = dwidth;
+ if (height == IMAGE_UNSPECIFIED_GEOMETRY)
+ height = dheight;
+ }
+
+ /* At this point width and height should contain sane values. Thus
+ we set the glyph geometry and lay it out. */
+ IMAGE_INSTANCE_WIDTH (ii) = width;
+ IMAGE_INSTANCE_HEIGHT (ii) = height;
+
+ if (meths && HAS_IIFORMAT_METH_P (meths, layout))
+ {
+ IIFORMAT_METH (meths, layout, (image_instance, width, height, domain));
+ }
+ /* else no change to the geometry. */
+
+ XIMAGE_INSTANCE_DIRTYP (image_instance) = 0;
+}
+
+/*
+ * Mark image instance in W as dirty if (a) W's faces have changed and
+ * (b) GLYPH_OR_II instance in W is a string.
+ *
+ * Return non-zero if instance has been marked dirty.
+ */
+int
+invalidate_glyph_geometry_maybe (Lisp_Object glyph_or_ii, struct window* w)
+{
+ if (XFRAME(WINDOW_FRAME(w))->faces_changed)
+ {
+ Lisp_Object image = glyph_or_ii;
+
+ if (GLYPHP (glyph_or_ii))
+ {
+ Lisp_Object window;
+ XSETWINDOW (window, w);
+ image = glyph_image_instance (glyph_or_ii, window, ERROR_ME_NOT, 1);
+ }
+
+ if (TEXT_IMAGE_INSTANCEP (image))
+ {
+ XIMAGE_INSTANCE_DIRTYP (image) = 1;
+ if (GLYPHP (glyph_or_ii))
+ XGLYPH_DIRTYP (glyph_or_ii) = 1;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
\f
/************************************************************************/
/* error helpers */
Lisp_Object pointer_fg, Lisp_Object pointer_bg,
int dest_mask, Lisp_Object domain)
{
- struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
if (dest_mask & IMAGE_NOTHING_MASK)
IMAGE_INSTANCE_TYPE (ii) = IMAGE_NOTHING;
return IMAGE_TEXT_MASK;
}
-/* called from autodetect_instantiate() */
+/* Called from autodetect_instantiate() */
void
string_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
Lisp_Object pointer_fg, Lisp_Object pointer_bg,
int dest_mask, Lisp_Object domain)
{
Lisp_Object string = find_keyword_in_vector (instantiator, Q_data);
- struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
- assert (!NILP (string));
+ /* Should never get here with a domain other than a window. */
+ assert (!NILP (string) && WINDOWP (domain));
if (dest_mask & IMAGE_TEXT_MASK)
{
IMAGE_INSTANCE_TYPE (ii) = IMAGE_TEXT;
incompatible_image_types (instantiator, dest_mask, IMAGE_TEXT_MASK);
}
+/* Sort out the size of the text that is being displayed. Calculating
+ it dynamically allows us to change the text and still see
+ everything. Note that the following methods are for text not string
+ since that is what the instantiated type is. The first method is a
+ helper that is used elsewhere for calculating text geometry. */
+void
+query_string_geometry (Lisp_Object string, Lisp_Object face,
+ unsigned int* width, unsigned int* height,
+ unsigned int* descent, Lisp_Object domain)
+{
+ struct font_metric_info fm;
+ unsigned char charsets[NUM_LEADING_BYTES];
+ struct face_cachel frame_cachel;
+ struct face_cachel *cachel;
+ Lisp_Object frame = FW_FRAME (domain);
+
+ /* Compute height */
+ if (height)
+ {
+ /* Compute string metric info */
+ find_charsets_in_bufbyte_string (charsets,
+ XSTRING_DATA (string),
+ XSTRING_LENGTH (string));
+
+ /* Fallback to the default face if none was provided. */
+ if (!NILP (face))
+ {
+ reset_face_cachel (&frame_cachel);
+ update_face_cachel_data (&frame_cachel, frame, face);
+ cachel = &frame_cachel;
+ }
+ else
+ {
+ cachel = WINDOW_FACE_CACHEL (XWINDOW (domain), DEFAULT_INDEX);
+ }
+
+ ensure_face_cachel_complete (cachel, domain, charsets);
+ face_cachel_charset_font_metric_info (cachel, charsets, &fm);
+
+ *height = fm.ascent + fm.descent;
+ /* #### descent only gets set if we query the height as well. */
+ if (descent)
+ *descent = fm.descent;
+ }
+
+ /* Compute width */
+ if (width)
+ {
+ if (!NILP (face))
+ *width = redisplay_frame_text_width_string (XFRAME (frame),
+ face,
+ 0, string, 0, -1);
+ else
+ *width = redisplay_frame_text_width_string (XFRAME (frame),
+ Vdefault_face,
+ 0, string, 0, -1);
+ }
+}
+
+Lisp_Object
+query_string_font (Lisp_Object string, Lisp_Object face, Lisp_Object domain)
+{
+ unsigned char charsets[NUM_LEADING_BYTES];
+ struct face_cachel frame_cachel;
+ struct face_cachel *cachel;
+ int i;
+ Lisp_Object frame = FW_FRAME (domain);
+
+ /* Compute string font info */
+ find_charsets_in_bufbyte_string (charsets,
+ XSTRING_DATA (string),
+ XSTRING_LENGTH (string));
+
+ reset_face_cachel (&frame_cachel);
+ update_face_cachel_data (&frame_cachel, frame, face);
+ cachel = &frame_cachel;
+
+ ensure_face_cachel_complete (cachel, domain, charsets);
+
+ for (i = 0; i < NUM_LEADING_BYTES; i++)
+ {
+ if (charsets[i])
+ {
+ return FACE_CACHEL_FONT (cachel,
+ CHARSET_BY_LEADING_BYTE (i +
+ MIN_LEADING_BYTE));
+
+ }
+ }
+
+ return Qnil; /* NOT REACHED */
+}
+
+static void
+text_query_geometry (Lisp_Object image_instance,
+ unsigned int* width, unsigned int* height,
+ enum image_instance_geometry disp, Lisp_Object domain)
+{
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+ unsigned int descent = 0;
+
+ query_string_geometry (IMAGE_INSTANCE_TEXT_STRING (ii),
+ IMAGE_INSTANCE_FACE (ii),
+ width, height, &descent, domain);
+
+ /* The descent gets set as a side effect of querying the
+ geometry. */
+ IMAGE_INSTANCE_TEXT_DESCENT (ii) = descent;
+}
+
/* set the properties of a string */
static Lisp_Object
text_set_property (Lisp_Object image_instance, Lisp_Object prop,
Lisp_Object val)
{
- struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
if (EQ (prop, Q_data))
{
Lisp_Object pointer_fg, Lisp_Object pointer_bg,
int dest_mask, Lisp_Object domain)
{
- Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
- struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-
- assert (!NILP (data));
/* #### implement this */
warn_when_safe (Qunimplemented, Qnotice,
"`formatted-string' not yet implemented; assuming `string'");
- if (dest_mask & IMAGE_TEXT_MASK)
- {
- IMAGE_INSTANCE_TYPE (ii) = IMAGE_TEXT;
- IMAGE_INSTANCE_TEXT_STRING (ii) = data;
- }
- else
- incompatible_image_types (instantiator, dest_mask, IMAGE_TEXT_MASK);
+
+ string_instantiate (image_instance, instantiator,
+ pointer_fg, pointer_bg, dest_mask, domain);
}
\f
int result;
CONST char *filename_ext;
- GET_C_STRING_FILENAME_DATA_ALLOCA (name, filename_ext);
+ TO_EXTERNAL_FORMAT (LISP_STRING, name,
+ C_STRING_ALLOCA, filename_ext,
+ Qfile_name);
result = read_bitmap_data_from_file (filename_ext, &w, &h,
&data, xhot, yhot);
int len = (w + 7) / 8 * h;
retval = list3 (make_int (w), make_int (h),
- make_ext_string (data, len, FORMAT_BINARY));
+ make_ext_string (data, len, Qbinary));
XFree ((char *) data);
return retval;
}
char **data;
int result;
char *fname = 0;
-
- GET_C_STRING_FILENAME_DATA_ALLOCA (name, fname);
+
+ TO_EXTERNAL_FORMAT (LISP_STRING, name,
+ C_STRING_ALLOCA, fname,
+ Qfile_name);
result = XpmReadFileToData (fname, &data);
if (result == XpmSuccess)
static void
image_create (Lisp_Object obj)
{
- struct Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
+ Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
IMAGE_SPECIFIER_ALLOWED (image) = ~0; /* all are allowed */
IMAGE_SPECIFIER_ATTACHEE (image) = Qnil;
static void
image_mark (Lisp_Object obj)
{
- struct Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
+ Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
mark_object (IMAGE_SPECIFIER_ATTACHEE (image));
mark_object (IMAGE_SPECIFIER_ATTACHEE_PROPERTY (image));
{
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);
/* For the image instance cache, we do comparisons with EQ rather
than with EQUAL, as we do for color and font names.
The reasons are:
-
+
1) pixmap data can be very long, and thus the hashing and
comparing will take awhile.
2) It's not so likely that we'll run into things that are EQUAL
round it. */
if (UNBOUNDP (instance)
&&
- dest_mask & (IMAGE_SUBWINDOW_MASK
+ dest_mask & (IMAGE_SUBWINDOW_MASK
| IMAGE_WIDGET_MASK
| IMAGE_TEXT_MASK))
{
if (!WINDOWP (domain))
signal_simple_error ("Can't instantiate text or subwindow outside a window",
instantiator);
- instance = Fgethash (instantiator,
- XWINDOW (domain)->subwindow_instance_cache,
+ instance = Fgethash (instantiator,
+ XWINDOW (domain)->subwindow_instance_cache,
Qunbound);
}
}
noseeum_cons (pointerp ? ls3 : instantiator,
subtable));
int speccount = specpdl_depth ();
-
+
/* make sure we cache the failures, too.
Use an unwind-protect to catch such errors.
If we fail, the unwind-protect records nil in
domain,
instantiator,
pointer_fg, pointer_bg,
- dest_mask);
-
+ dest_mask,
+ glyph);
+
Fsetcar (locative, instance);
/* only after the image has been instantiated do we know
whether we need to put it in the per-window image instance
if (!WINDOWP (domain))
signal_simple_error ("Can't instantiate subwindow outside a window",
instantiator);
-
+
Fsetcdr (XCDR (locative), XWINDOW (domain)->subwindow_instance_cache );
}
unbind_to (speccount, Qnil);
set_image_attached_to (Lisp_Object obj, Lisp_Object face_or_glyph,
Lisp_Object property)
{
- struct Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
+ Lisp_Specifier *image = XIMAGE_SPECIFIER (obj);
IMAGE_SPECIFIER_ATTACHEE (image) = face_or_glyph;
IMAGE_SPECIFIER_ATTACHEE_PROPERTY (image) = property;
instantiator = Fcopy_sequence (instantiator);
elt = XVECTOR_DATA (instantiator);
instantiator_len = XVECTOR_LENGTH (instantiator);
-
+
meths = decode_image_instantiator_format (elt[0], ERROR_ME);
for (i = 1; i < instantiator_len; i += 2)
static Lisp_Object
mark_glyph (Lisp_Object obj)
{
- struct Lisp_Glyph *glyph = XGLYPH (obj);
+ Lisp_Glyph *glyph = XGLYPH (obj);
mark_object (glyph->image);
mark_object (glyph->contrib_p);
static void
print_glyph (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
- struct Lisp_Glyph *glyph = XGLYPH (obj);
+ Lisp_Glyph *glyph = XGLYPH (obj);
char buf[20];
if (print_readably)
static int
glyph_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
- struct Lisp_Glyph *g1 = XGLYPH (obj1);
- struct Lisp_Glyph *g2 = XGLYPH (obj2);
+ Lisp_Glyph *g1 = XGLYPH (obj1);
+ Lisp_Glyph *g2 = XGLYPH (obj2);
depth++;
static Lisp_Object
glyph_getprop (Lisp_Object obj, Lisp_Object prop)
{
- struct Lisp_Glyph *g = XGLYPH (obj);
+ Lisp_Glyph *g = XGLYPH (obj);
if (EQ (prop, Qimage)) return g->image;
if (EQ (prop, Qcontrib_p)) return g->contrib_p;
static Lisp_Object
glyph_plist (Lisp_Object obj)
{
- struct Lisp_Glyph *glyph = XGLYPH (obj);
+ Lisp_Glyph *glyph = XGLYPH (obj);
Lisp_Object result = glyph->plist;
result = cons3 (Qface, glyph->face, result);
}
static const struct lrecord_description glyph_description[] = {
- { XD_LISP_OBJECT, offsetof(struct Lisp_Glyph, image), 5 },
+ { XD_LISP_OBJECT, offsetof (Lisp_Glyph, image) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Glyph, contrib_p) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Glyph, baseline) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Glyph, face) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Glyph, plist) },
{ XD_END }
};
glyph_equal, glyph_hash, glyph_description,
glyph_getprop, glyph_putprop,
glyph_remprop, glyph_plist,
- struct Lisp_Glyph);
+ Lisp_Glyph);
\f
Lisp_Object
allocate_glyph (enum glyph_type type,
{
/* This function can GC */
Lisp_Object obj = Qnil;
- struct Lisp_Glyph *g =
- alloc_lcrecord_type (struct Lisp_Glyph, &lrecord_glyph);
+ Lisp_Glyph *g = alloc_lcrecord_type (Lisp_Glyph, &lrecord_glyph);
g->type = type;
g->image = Fmake_specifier (Qimage); /* This function can GC */
{
case GLYPH_BUFFER:
XIMAGE_SPECIFIER_ALLOWED (g->image) =
- IMAGE_NOTHING_MASK | IMAGE_TEXT_MASK
- | IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
+ IMAGE_NOTHING_MASK | IMAGE_TEXT_MASK
+ | IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
| IMAGE_SUBWINDOW_MASK | IMAGE_WIDGET_MASK
| IMAGE_LAYOUT_MASK;
break;
break;
case GLYPH_ICON:
XIMAGE_SPECIFIER_ALLOWED (g->image) =
- IMAGE_NOTHING_MASK | IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK;
+ IMAGE_NOTHING_MASK | IMAGE_MONO_PIXMAP_MASK
+ | IMAGE_COLOR_PIXMAP_MASK;
break;
default:
abort ();
}
}
-/*****************************************************************************
- glyph_width
+Lisp_Object
+glyph_image_instance (Lisp_Object glyph, Lisp_Object domain,
+ Error_behavior errb, int no_quit)
+{
+ Lisp_Object specifier = GLYPH_IMAGE (XGLYPH (glyph));
- Return the width of the given GLYPH on the given WINDOW. If the
- instance is a string then the width is calculated using the font of
- the given FACE, unless a face is defined by the glyph itself.
- ****************************************************************************/
-unsigned short
-glyph_width (Lisp_Object glyph_or_image, Lisp_Object frame_face,
- face_index window_findex, Lisp_Object window)
+ /* This can never return Qunbound. All glyphs have 'nothing as
+ a fallback. */
+ Lisp_Object image_instance = specifier_instance (specifier, Qunbound,
+ domain, errb, no_quit, 0,
+ Qzero);
+ assert (!UNBOUNDP (image_instance));
+
+ return image_instance;
+}
+
+static Lisp_Object
+glyph_image_instance_maybe (Lisp_Object glyph_or_image, Lisp_Object window)
{
Lisp_Object instance = glyph_or_image;
- Lisp_Object frame = XWINDOW (window)->frame;
- /* #### We somehow need to distinguish between the user causing this
- error condition and a bug causing it. */
if (GLYPHP (glyph_or_image))
instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
- if (!IMAGE_INSTANCEP (instance))
- return 0;
-
- switch (XIMAGE_INSTANCE_TYPE (instance))
- {
- case IMAGE_TEXT:
- {
- Lisp_Object str = XIMAGE_INSTANCE_TEXT_STRING (instance);
- Lisp_Object private_face = Qnil;
-
- if (GLYPHP (glyph_or_image))
- private_face = XGLYPH_FACE(glyph_or_image);
-
- if (!NILP (private_face))
- return redisplay_frame_text_width_string (XFRAME (frame),
- private_face,
- 0, str, 0, -1);
- else
- if (!NILP (frame_face))
- return redisplay_frame_text_width_string (XFRAME (frame),
- frame_face,
- 0, str, 0, -1);
- else
- return redisplay_text_width_string (XWINDOW (window),
- window_findex,
- 0, str, 0, -1);
- }
+ return instance;
+}
- case IMAGE_MONO_PIXMAP:
- case IMAGE_COLOR_PIXMAP:
- case IMAGE_POINTER:
- return XIMAGE_INSTANCE_PIXMAP_WIDTH (instance);
+/*****************************************************************************
+ glyph_width
- case IMAGE_NOTHING:
- return 0;
+ Return the width of the given GLYPH on the given WINDOW.
+ Calculations are done based on recursively querying the geometry of
+ the associated image instances.
+ ****************************************************************************/
+unsigned short
+glyph_width (Lisp_Object glyph_or_image, Lisp_Object domain)
+{
+ Lisp_Object instance = glyph_image_instance_maybe (glyph_or_image,
+ domain);
+ if (!IMAGE_INSTANCEP (instance))
+ return 0;
- case IMAGE_SUBWINDOW:
- case IMAGE_WIDGET:
- case IMAGE_LAYOUT:
- return XIMAGE_INSTANCE_SUBWINDOW_WIDTH (instance);
+ if (XIMAGE_INSTANCE_DIRTYP (instance))
+ image_instance_layout (instance, IMAGE_UNSPECIFIED_GEOMETRY,
+ IMAGE_UNSPECIFIED_GEOMETRY, domain);
- default:
- abort ();
- return 0;
- }
+ return XIMAGE_INSTANCE_WIDTH (instance);
}
DEFUN ("glyph-width", Fglyph_width, 1, 2, 0, /*
XSETWINDOW (window, decode_window (window));
CHECK_GLYPH (glyph);
- return make_int (glyph_width (glyph, Qnil, DEFAULT_INDEX, window));
+ return make_int (glyph_width (glyph, window));
}
-#define RETURN_ASCENT 0
-#define RETURN_DESCENT 1
-#define RETURN_HEIGHT 2
-
-Lisp_Object
-glyph_image_instance (Lisp_Object glyph, Lisp_Object domain,
- Error_behavior errb, int no_quit)
-{
- Lisp_Object specifier = GLYPH_IMAGE (XGLYPH (glyph));
-
- /* This can never return Qunbound. All glyphs have 'nothing as
- a fallback. */
- return specifier_instance (specifier, Qunbound, domain, errb, no_quit, 0,
- Qzero);
-}
-
-static unsigned short
-glyph_height_internal (Lisp_Object glyph_or_image, Lisp_Object frame_face,
- face_index window_findex, Lisp_Object window,
- int function)
+unsigned short
+glyph_ascent (Lisp_Object glyph_or_image, Lisp_Object domain)
{
- Lisp_Object instance = glyph_or_image;
- Lisp_Object frame = XWINDOW (window)->frame;
-
- if (GLYPHP (glyph_or_image))
- instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
-
+ Lisp_Object instance = glyph_image_instance_maybe (glyph_or_image,
+ domain);
if (!IMAGE_INSTANCEP (instance))
return 0;
- switch (XIMAGE_INSTANCE_TYPE (instance))
- {
- case IMAGE_TEXT:
- {
- struct font_metric_info fm;
- Lisp_Object string = XIMAGE_INSTANCE_TEXT_STRING (instance);
- unsigned char charsets[NUM_LEADING_BYTES];
- struct face_cachel frame_cachel;
- struct face_cachel *cachel;
-
- find_charsets_in_bufbyte_string (charsets,
- XSTRING_DATA (string),
- XSTRING_LENGTH (string));
-
- if (!NILP (frame_face))
- {
- reset_face_cachel (&frame_cachel);
- update_face_cachel_data (&frame_cachel, frame, frame_face);
- cachel = &frame_cachel;
- }
- else
- cachel = WINDOW_FACE_CACHEL (XWINDOW (window), window_findex);
- ensure_face_cachel_complete (cachel, window, charsets);
-
- face_cachel_charset_font_metric_info (cachel, charsets, &fm);
+ if (XIMAGE_INSTANCE_DIRTYP (instance))
+ image_instance_layout (instance, IMAGE_UNSPECIFIED_GEOMETRY,
+ IMAGE_UNSPECIFIED_GEOMETRY, domain);
- switch (function)
- {
- case RETURN_ASCENT: return fm.ascent;
- case RETURN_DESCENT: return fm.descent;
- case RETURN_HEIGHT: return fm.ascent + fm.descent;
- default:
- abort ();
- return 0; /* not reached */
- }
- }
-
- case IMAGE_MONO_PIXMAP:
- case IMAGE_COLOR_PIXMAP:
- case IMAGE_POINTER:
- /* #### Ugh ugh ugh -- temporary crap */
- if (function == RETURN_ASCENT || function == RETURN_HEIGHT)
- return XIMAGE_INSTANCE_PIXMAP_HEIGHT (instance);
- else
- return 0;
-
- case IMAGE_NOTHING:
- return 0;
-
- case IMAGE_SUBWINDOW:
- case IMAGE_WIDGET:
- case IMAGE_LAYOUT:
- /* #### Ugh ugh ugh -- temporary crap */
- if (function == RETURN_ASCENT || function == RETURN_HEIGHT)
- return XIMAGE_INSTANCE_SUBWINDOW_HEIGHT (instance);
- else
- return 0;
-
- default:
- abort ();
- return 0;
- }
+ if (XIMAGE_INSTANCE_TYPE (instance) == IMAGE_TEXT)
+ return XIMAGE_INSTANCE_TEXT_ASCENT (instance);
+ else
+ return XIMAGE_INSTANCE_HEIGHT (instance);
}
unsigned short
-glyph_ascent (Lisp_Object glyph, Lisp_Object frame_face,
- face_index window_findex, Lisp_Object window)
+glyph_descent (Lisp_Object glyph_or_image, Lisp_Object domain)
{
- return glyph_height_internal (glyph, frame_face, window_findex, window,
- RETURN_ASCENT);
-}
+ Lisp_Object instance = glyph_image_instance_maybe (glyph_or_image,
+ domain);
+ if (!IMAGE_INSTANCEP (instance))
+ return 0;
-unsigned short
-glyph_descent (Lisp_Object glyph, Lisp_Object frame_face,
- face_index window_findex, Lisp_Object window)
-{
- return glyph_height_internal (glyph, frame_face, window_findex, window,
- RETURN_DESCENT);
+ if (XIMAGE_INSTANCE_DIRTYP (instance))
+ image_instance_layout (instance, IMAGE_UNSPECIFIED_GEOMETRY,
+ IMAGE_UNSPECIFIED_GEOMETRY, domain);
+
+ if (XIMAGE_INSTANCE_TYPE (instance) == IMAGE_TEXT)
+ return XIMAGE_INSTANCE_TEXT_DESCENT (instance);
+ else
+ return 0;
}
/* strictly a convenience function. */
unsigned short
-glyph_height (Lisp_Object glyph, Lisp_Object frame_face,
- face_index window_findex, Lisp_Object window)
+glyph_height (Lisp_Object glyph_or_image, Lisp_Object domain)
{
- return glyph_height_internal (glyph, frame_face, window_findex, window,
- RETURN_HEIGHT);
+ Lisp_Object instance = glyph_image_instance_maybe (glyph_or_image,
+ domain);
+
+ if (!IMAGE_INSTANCEP (instance))
+ return 0;
+
+ if (XIMAGE_INSTANCE_DIRTYP (instance))
+ image_instance_layout (instance, IMAGE_UNSPECIFIED_GEOMETRY,
+ IMAGE_UNSPECIFIED_GEOMETRY, domain);
+
+ return XIMAGE_INSTANCE_HEIGHT (instance);
}
DEFUN ("glyph-ascent", Fglyph_ascent, 1, 2, 0, /*
XSETWINDOW (window, decode_window (window));
CHECK_GLYPH (glyph);
- return make_int (glyph_ascent (glyph, Qnil, DEFAULT_INDEX, window));
+ return make_int (glyph_ascent (glyph, window));
}
DEFUN ("glyph-descent", Fglyph_descent, 1, 2, 0, /*
XSETWINDOW (window, decode_window (window));
CHECK_GLYPH (glyph);
- return make_int (glyph_descent (glyph, Qnil, DEFAULT_INDEX, window));
+ return make_int (glyph_descent (glyph, window));
}
/* This is redundant but I bet a lot of people expect it to exist. */
XSETWINDOW (window, decode_window (window));
CHECK_GLYPH (glyph);
- return make_int (glyph_height (glyph, Qnil, DEFAULT_INDEX, window));
-}
-
-#undef RETURN_ASCENT
-#undef RETURN_DESCENT
-#undef RETURN_HEIGHT
-
-static unsigned int
-glyph_dirty_p (Lisp_Object glyph_or_image, Lisp_Object window)
-{
- Lisp_Object instance = glyph_or_image;
-
- if (GLYPHP (glyph_or_image))
- instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
-
- return XIMAGE_INSTANCE_DIRTYP (instance);
+ return make_int (glyph_height (glyph, window));
}
static void
(XGLYPH (glyph)->after_change) (glyph, property, locale);
}
+#if 0 /* Not used for now */
+static void
+glyph_query_geometry (Lisp_Object glyph_or_image, Lisp_Object window,
+ unsigned int* width, unsigned int* height,
+ enum image_instance_geometry disp, Lisp_Object domain)
+{
+ Lisp_Object instance = glyph_or_image;
+
+ if (GLYPHP (glyph_or_image))
+ instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
+
+ image_instance_query_geometry (instance, width, height, disp, domain);
+}
+
+static void
+glyph_layout (Lisp_Object glyph_or_image, Lisp_Object window,
+ unsigned int width, unsigned int height, Lisp_Object domain)
+{
+ Lisp_Object instance = glyph_or_image;
+
+ if (GLYPHP (glyph_or_image))
+ instance = glyph_image_instance (glyph_or_image, window, ERROR_ME_NOT, 1);
+
+ image_instance_layout (instance, width, height, domain);
+}
+#endif
+
\f
/*****************************************************************************
* glyph cachel functions *
struct glyph_cachel *cachel)
{
if (!cachel->updated || NILP (cachel->glyph) || !EQ (cachel->glyph, glyph)
- || XGLYPH_DIRTYP (cachel->glyph))
+ || XGLYPH_DIRTYP (cachel->glyph)
+ || XFRAME(WINDOW_FRAME(w))->faces_changed)
{
Lisp_Object window, instance;
XSETWINDOW (window, w);
cachel->glyph = glyph;
- /* Speed things up slightly by grabbing the glyph instantiation
- and passing it to the size functions. */
+ /* 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);
- cachel->dirty = XGLYPH_DIRTYP (glyph) = glyph_dirty_p (glyph, window);
- cachel->width = glyph_width (instance, Qnil, DEFAULT_INDEX, window);
- cachel->ascent = glyph_ascent (instance, Qnil, DEFAULT_INDEX, window);
- cachel->descent = glyph_descent (instance, Qnil, DEFAULT_INDEX, window);
+
+ /* Mark text instance of the glyph dirty if faces have changed,
+ because its geometry might have changed. */
+ invalidate_glyph_geometry_maybe (instance, w);
+
+ /* #### Do the following 2 lines buy us anything? --kkm */
+ XGLYPH_DIRTYP (glyph) = XIMAGE_INSTANCE_DIRTYP (instance);
+ cachel->dirty = XGLYPH_DIRTYP (glyph);
+ cachel->width = glyph_width (instance, window);
+ cachel->ascent = glyph_ascent (instance, window);
+ cachel->descent = glyph_descent (instance, window);
}
cachel->updated = 1;
}
/* Unset the dirty bit on all the glyph cachels that have it. */
-void
+void
mark_glyph_cachels_as_clean (struct window* w)
{
int elt;
/*****************************************************************************
* subwindow cachel functions *
*****************************************************************************/
-/* subwindows are curious in that you have to physically unmap them to
+/* Subwindows are curious in that you have to physically unmap them to
not display them. It is problematic deciding what to do in
redisplay. We have two caches - a per-window instance cache that
keeps track of subwindows on a window, these are linked to their
{
struct subwindow_cachel *cachel =
Dynarr_atp (f->subwindow_cachels, elt);
-
+
if (EQ (cachel->subwindow, subwindow) && !NILP (subwindow))
{
update_subwindow_cachel_data (f, subwindow, cachel);
we have to check for overlaps. Being conservative we will
check for exposures wholly contained by the subwindow, this
might give us what we want.*/
- if (ei->x <= x && ei->y <= y
+ if (ei->x <= x && ei->y <= y
&& ei->x + ei->width >= x + width
&& ei->y + ei->height >= y + height)
{
f->subwindow_exposures = ei->next;
else
prev->next = ei->next;
-
+
if (ei == f->subwindow_exposures_tail)
f->subwindow_exposures_tail = prev;
if (!hold_ignored_expose_registration)
{
struct expose_ignore *ei;
-
+
ei = Blocktype_alloc (the_expose_ignore_blocktype);
-
+
ei->next = NULL;
ei->x = x;
ei->y = y;
ei->width = width;
ei->height = height;
-
+
/* we have to add the exposure to the end of the list, since we
want to check the oldest events first. for speed we keep a record
of the end so that we can add right to it. */
if (cachel->being_displayed
&&
cachel->x <= x && cachel->y <= y
- &&
+ &&
cachel->x + cachel->width >= x + width
&&
cachel->y + cachel->height >= y + height)
static void
update_subwindow (Lisp_Object subwindow)
{
- struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
+ Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
if (!IMAGE_INSTANCE_TYPE (ii) == IMAGE_WIDGET
||
return;
MAYBE_DEVMETH (XDEVICE (ii->device), update_subwindow, (ii));
+ /* We must update the window's size as it may have been changed by
+ the the layout routines. We also do this here so that explicit resizing
+ from lisp does not result in synchronous updates. */
+ MAYBE_DEVMETH (XDEVICE (ii->device), resize_subwindow, (ii,
+ IMAGE_INSTANCE_WIDTH (ii),
+ IMAGE_INSTANCE_HEIGHT (ii)));
}
+/* Update all the subwindows on a frame. */
void
update_frame_subwindows (struct frame *f)
{
{
struct subwindow_cachel *cachel =
Dynarr_atp (f->subwindow_cachels, elt);
-
+
if (cachel->being_displayed)
{
update_subwindow (cachel->subwindow);
/* remove a subwindow from its frame */
void unmap_subwindow (Lisp_Object subwindow)
{
- struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
+ Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
int elt;
struct subwindow_cachel* cachel;
struct frame* f;
/* make sure we don't get expose events */
register_ignored_expose (f, cachel->x, cachel->y, cachel->width, cachel->height);
- cachel->x = -1;
- cachel->y = -1;
+ cachel->x = ~0;
+ cachel->y = ~0;
cachel->being_displayed = 0;
IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii) = 0;
void map_subwindow (Lisp_Object subwindow, int x, int y,
struct display_glyph_area *dga)
{
- struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
- int elt;
+ Lisp_Image_Instance* ii = XIMAGE_INSTANCE (subwindow);
+ int elt;
struct subwindow_cachel* cachel;
struct frame* f;
cachel->height = dga->height;
cachel->being_displayed = 1;
+ /* This forces any pending display changes to happen to the image
+ before we show it. I'm not sure whether or not we need mark as
+ clean here, but for now we will. */
+ if (IMAGE_INSTANCE_DIRTYP (ii))
+ {
+ update_subwindow (subwindow);
+ IMAGE_INSTANCE_DIRTYP (ii) = 0;
+ }
+
MAYBE_DEVMETH (XDEVICE (ii->device), map_subwindow, (ii, x, y, dga));
}
Lisp_Object pointer_fg, Lisp_Object pointer_bg,
int dest_mask, Lisp_Object domain)
{
- struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
Lisp_Object frame = FW_FRAME (domain);
Lisp_Object width = find_keyword_in_vector (instantiator, Q_pixel_width);
if (NILP (frame))
signal_simple_error ("No selected frame", device);
-
+
if (!(dest_mask & IMAGE_SUBWINDOW_MASK))
incompatible_image_types (instantiator, dest_mask, IMAGE_SUBWINDOW_MASK);
IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii) = 0;
IMAGE_INSTANCE_SUBWINDOW_FRAME (ii) = frame;
- /* this stuff may get overidden by the widget code */
+ /* #### 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 (NILP (width))
IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii) = 20;
else
CHECK_SUBWINDOW_IMAGE_INSTANCE (subwindow);
if (NILP (width))
- neww = XIMAGE_INSTANCE_SUBWINDOW_WIDTH (subwindow);
+ neww = XIMAGE_INSTANCE_WIDTH (subwindow);
else
neww = XINT (width);
if (NILP (height))
- newh = XIMAGE_INSTANCE_SUBWINDOW_HEIGHT (subwindow);
+ newh = XIMAGE_INSTANCE_HEIGHT (subwindow);
else
newh = XINT (height);
-
- MAYBE_DEVMETH (XDEVICE (XIMAGE_INSTANCE_DEVICE (subwindow)),
- resize_subwindow, (XIMAGE_INSTANCE (subwindow), neww, newh));
-
- XIMAGE_INSTANCE_SUBWINDOW_HEIGHT (subwindow) = newh;
- XIMAGE_INSTANCE_SUBWINDOW_WIDTH (subwindow) = neww;
+ /* The actual resizing gets done asychronously by
+ update_subwindow. */
+ XIMAGE_INSTANCE_HEIGHT (subwindow) = newh;
+ XIMAGE_INSTANCE_WIDTH (subwindow) = neww;
/* need to update the cachels as redisplay will not do this */
update_subwindow_cachel (subwindow);
if (!NILP (XWEAK_LIST_LIST (arg)) && !NILP (XCAR (XWEAK_LIST_LIST (arg))))
{
Lisp_Object value = XCAR (XWEAK_LIST_LIST (arg));
-
+
if (IMAGE_INSTANCEP (value))
{
- struct Lisp_Image_Instance* ii = XIMAGE_INSTANCE (value);
+ Lisp_Image_Instance* ii = XIMAGE_INSTANCE (value);
if (COLOR_PIXMAP_IMAGE_INSTANCEP (value)
&&
% IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii);
/* We might need to kick redisplay at this point - but we
also might not. */
- MARK_DEVICE_FRAMES_GLYPHS_CHANGED
+ MARK_DEVICE_FRAMES_GLYPHS_CHANGED
(XDEVICE (IMAGE_INSTANCE_DEVICE (ii)));
- IMAGE_INSTANCE_DIRTYP (ii) = 1;
+ MARK_IMAGE_INSTANCE_CHANGED (ii);
}
}
}
}
static const struct lrecord_description image_specifier_description[] = {
- { XD_LISP_OBJECT, specifier_data_offset + offsetof(struct image_specifier, attachee), 2 },
+ { XD_LISP_OBJECT, specifier_data_offset + offsetof (struct image_specifier, attachee) },
+ { XD_LISP_OBJECT, specifier_data_offset + offsetof (struct image_specifier, attachee_property) },
{ XD_END }
};
static const struct lrecord_description iike_description_1[] = {
- { XD_LISP_OBJECT, offsetof(ii_keyword_entry, keyword), 1 },
+ { XD_LISP_OBJECT, offsetof (ii_keyword_entry, keyword) },
{ XD_END }
};
static const struct struct_description iike_description = {
- sizeof(ii_keyword_entry),
+ sizeof (ii_keyword_entry),
iike_description_1
};
static const struct lrecord_description iiked_description_1[] = {
- XD_DYNARR_DESC(ii_keyword_entry_dynarr, &iike_description),
+ XD_DYNARR_DESC (ii_keyword_entry_dynarr, &iike_description),
{ XD_END }
};
static const struct struct_description iiked_description = {
- sizeof(ii_keyword_entry_dynarr),
+ sizeof (ii_keyword_entry_dynarr),
iiked_description_1
};
static const struct lrecord_description iife_description_1[] = {
- { XD_LISP_OBJECT, offsetof(image_instantiator_format_entry, symbol), 2 },
- { XD_STRUCT_PTR, offsetof(image_instantiator_format_entry, meths), 1, &iim_description },
+ { XD_LISP_OBJECT, offsetof (image_instantiator_format_entry, symbol) },
+ { XD_LISP_OBJECT, offsetof (image_instantiator_format_entry, device) },
+ { XD_STRUCT_PTR, offsetof (image_instantiator_format_entry, meths), 1, &iim_description },
{ XD_END }
};
static const struct struct_description iife_description = {
- sizeof(image_instantiator_format_entry),
+ sizeof (image_instantiator_format_entry),
iife_description_1
};
static const struct lrecord_description iifed_description_1[] = {
- XD_DYNARR_DESC(image_instantiator_format_entry_dynarr, &iife_description),
+ XD_DYNARR_DESC (image_instantiator_format_entry_dynarr, &iife_description),
{ XD_END }
};
static const struct struct_description iifed_description = {
- sizeof(image_instantiator_format_entry_dynarr),
+ sizeof (image_instantiator_format_entry_dynarr),
iifed_description_1
};
static const struct lrecord_description iim_description_1[] = {
- { XD_LISP_OBJECT, offsetof(struct image_instantiator_methods, symbol), 2 },
- { XD_STRUCT_PTR, offsetof(struct image_instantiator_methods, keywords), 1, &iiked_description },
- { XD_STRUCT_PTR, offsetof(struct image_instantiator_methods, consoles), 1, &cted_description },
+ { XD_LISP_OBJECT, offsetof (struct image_instantiator_methods, symbol) },
+ { XD_LISP_OBJECT, offsetof (struct image_instantiator_methods, device) },
+ { XD_STRUCT_PTR, offsetof (struct image_instantiator_methods, keywords), 1, &iiked_description },
+ { XD_STRUCT_PTR, offsetof (struct image_instantiator_methods, consoles), 1, &cted_description },
{ XD_END }
};
/* Do this so we can set strings. */
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");
/* image instances */
- Vimage_instance_type_list = Fcons (Qnothing,
- list6 (Qtext, Qmono_pixmap, Qcolor_pixmap,
+ Vimage_instance_type_list = Fcons (Qnothing,
+ list6 (Qtext, Qmono_pixmap, Qcolor_pixmap,
Qpointer, Qsubwindow, Qwidget));
staticpro (&Vimage_instance_type_list);
set_specifier_fallback (Vcurrent_display_table,
list1 (Fcons (Qnil, Qnil)));
set_specifier_caching (Vcurrent_display_table,
- slot_offset (struct window,
- display_table),
+ offsetof (struct window, display_table),
some_window_value_changed,
0, 0);
}
projects / chise / xemacs-chise.git.1 / blobdiff