+/****************************************************************************
+ redisplay_output_display_block
+
+ Given a display line, a block number for that start line, output all
+ runes between start and end in the specified display block.
+ ****************************************************************************/
+static void
+redisplay_output_display_block (struct window *w, struct display_line *dl, int block,
+ int start, int end, int start_pixpos, int cursor_start,
+ int cursor_width, int cursor_height)
+{
+ struct frame *f = XFRAME (w->frame);
+ struct device *d = XDEVICE (f->device);
+ /* Temporarily disabled until generalization is done. */
+#if 0
+ struct display_block *db = Dynarr_atp (dl->display_blocks, block);
+ rune_dynarr *rba = db->runes;
+ struct rune *rb;
+ int xpos, width;
+ rb = Dynarr_atp (rba, start);
+
+ if (!rb)
+ /* Nothing to do so don't do anything. */
+ return;
+
+ xpos = max (start_pixpos, rb->xpos);
+
+ if (end < 0)
+ end = Dynarr_length (rba);
+
+ rb = Dynarr_atp (rba, end - 1);
+ width = rb->xpos + rb->width - xpos;
+#endif
+ /* now actually output the block. */
+ DEVMETH (d, output_display_block, (w, dl, block, start,
+ end, start_pixpos,
+ cursor_start, cursor_width,
+ cursor_height));
+}
+
+/****************************************************************************
+ redisplay_unmap_subwindows
+
+ Remove subwindows from the area in the box defined by the given
+ parameters.
+ ****************************************************************************/
+static void
+redisplay_unmap_subwindows (struct frame* f, int x, int y, int width, int height,
+ Lisp_Object ignored_window)
+{
+ Lisp_Object rest;
+
+ LIST_LOOP (rest, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)))
+ {
+ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (XCAR (rest));
+ if (IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii)
+ &&
+ IMAGE_INSTANCE_DISPLAY_X (ii)
+ + IMAGE_INSTANCE_DISPLAY_WIDTH (ii) > (unsigned) x
+ &&
+ IMAGE_INSTANCE_DISPLAY_X (ii) < (unsigned) (x + width)
+ &&
+ IMAGE_INSTANCE_DISPLAY_Y (ii)
+ + IMAGE_INSTANCE_DISPLAY_HEIGHT (ii) > (unsigned) y
+ &&
+ IMAGE_INSTANCE_DISPLAY_Y (ii) < (unsigned) (y + height)
+ &&
+ !EQ (XCAR (rest), ignored_window))
+ {
+ unmap_subwindow (XCAR (rest));
+ }
+ }
+}
+
+/****************************************************************************
+ redisplay_unmap_subwindows_maybe
+
+ Potentially subwindows from the area in the box defined by the given
+ parameters.
+ ****************************************************************************/
+void redisplay_unmap_subwindows_maybe (struct frame* f, int x, int y, int width, int height)
+{
+ if (!NILP (XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))))
+ {
+ redisplay_unmap_subwindows (f, x, y, width, height, Qnil);
+ }
+}
+
+static void redisplay_unmap_subwindows_except_us (struct frame* f, int x, int y, int width,
+ int height, Lisp_Object subwindow)
+{
+ if (!NILP (XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))))
+ {
+ redisplay_unmap_subwindows (f, x, y, width, height, subwindow);
+ }
+}
+
+/****************************************************************************
+ redisplay_output_subwindow
+
+ output a subwindow. This code borrows heavily from the pixmap stuff,
+ although is much simpler not needing to account for partial
+ pixmaps, backgrounds etc.
+ ****************************************************************************/
+void
+redisplay_output_subwindow (struct window *w,
+ Lisp_Object image_instance,
+ struct display_box* db, struct display_glyph_area* dga,
+ face_index findex, int cursor_start, int cursor_width,
+ int cursor_height)
+{
+ Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
+ Lisp_Object window;
+ struct display_glyph_area sdga;
+
+ dga->height = IMAGE_INSTANCE_HEIGHT (p);
+ dga->width = IMAGE_INSTANCE_WIDTH (p);
+
+ /* The first thing we are going to do is update the display
+ characteristics of the subwindow. This also clears the dirty
+ flags as a side effect. */
+ redisplay_subwindow (image_instance);
+
+ /* This makes the glyph area fit into the display area. */
+ if (!redisplay_normalize_glyph_area (db, dga))
+ return;
+
+ XSETWINDOW (window, w);
+
+ /* Clear the area the subwindow is going into. */
+ redisplay_clear_clipped_region (window, findex,
+ db, dga, 0, image_instance);
+
+ /* This shrinks the display box to exactly enclose the glyph
+ area. */
+ redisplay_normalize_display_box (db, dga);
+
+ /* if we can't view the whole window we can't view any of it. We
+ have to be careful here since we may be being asked to display
+ part of a subwindow, the rest of which is on-screen as well. We
+ need to allow this case and map the entire subwindow. We also
+ need to be careful since the subwindow could be outside the
+ window in the gutter or modeline - we also need to allow these
+ cases.*/
+ sdga.xoffset = -dga->xoffset;
+ sdga.yoffset = -dga->yoffset;
+ sdga.height = IMAGE_INSTANCE_HEIGHT (p);
+ sdga.width = IMAGE_INSTANCE_WIDTH (p);
+
+ if (redisplay_display_boxes_in_window_p (w, db, &sdga) == 0
+ ||
+ /* We only want to do full subwindow display for windows that
+ are completely in the gutter, otherwise we must clip to be
+ safe. */
+ display_boxes_in_gutter_p (XFRAME (w->frame), db, &sdga) <= 0)
+ {
+ map_subwindow (image_instance, db->xpos, db->ypos, dga);
+ }
+ else
+ {
+ sdga.xoffset = sdga.yoffset = 0;
+ map_subwindow (image_instance, db->xpos - dga->xoffset,
+ db->ypos - dga->yoffset, &sdga);
+ }
+}
+
+/****************************************************************************
+ redisplay_output_layout
+
+ Output a widget hierarchy. This can safely call itself recursively.
+
+ The complexity of outputting layouts is deciding whether to do it or
+ not. Consider a layout enclosing some text, the text changes and is
+ marked as dirty, but the enclosing layout has not been marked as
+ dirty so no updates occur and the text will potentially be truncated.
+ Alternatively we hold a back pointer in the image instance to the
+ parent and mark the parent as dirty. But the layout code assumes that
+ if the layout is dirty then the whole layout should be redisplayed,
+ so we then get lots of flashing even though only the text has changed
+ size. Of course if the text shrinks in size then we do actually need
+ to redisplay the layout to repaint the exposed area. So what happens
+ if we make a non-structural change like changing color? Either we
+ redisplay everything, or we redisplay nothing. These are exactly the
+ issues lwlib has to grapple with. We really need to know what has
+ actually changed and make a layout decision based on that. We also
+ really need to know what has changed so that we can only make the
+ necessary changes in update_subwindow. This has all now been
+ implemented, Viva la revolution!
+ ****************************************************************************/
+void
+redisplay_output_layout (Lisp_Object domain,
+ Lisp_Object image_instance,
+ struct display_box* db, struct display_glyph_area* dga,
+ face_index findex, int cursor_start, int cursor_width,
+ int cursor_height)
+{
+ Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
+ Lisp_Object rest, window = DOMAIN_WINDOW (domain);
+ Charc_dynarr *buf = Dynarr_new (Charc);
+ struct window *w = XWINDOW (window);
+ struct device *d = DOMAIN_XDEVICE (domain);
+ int layout_height, layout_width;
+
+ layout_height = glyph_height (image_instance, domain);
+ layout_width = glyph_width (image_instance, domain);
+
+ dga->height = layout_height;
+ dga->width = layout_width;
+#ifdef DEBUG_WIDGET_OUTPUT
+ printf ("outputing layout glyph %p\n", p);
+#endif
+ /* This makes the glyph area fit into the display area. */
+ if (!redisplay_normalize_glyph_area (db, dga))
+ return;
+
+ /* Highly dodgy optimization. We want to only output the whole
+ layout if we really have to. */
+ if (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (p)
+ || IMAGE_INSTANCE_LAYOUT_CHANGED (p)
+ || IMAGE_INSTANCE_WIDGET_FACE_CHANGED (p)
+ || IMAGE_INSTANCE_SIZE_CHANGED (p)
+ || IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p))
+ {
+ /* First clear the area we are drawing into. This is the easiest
+ thing to do since we have many gaps that we have to make sure are
+ filled in. */
+ redisplay_clear_clipped_region (window, findex, db, dga, 1, Qnil);
+
+ /* Output a border if required */
+ if (!NILP (IMAGE_INSTANCE_LAYOUT_BORDER (p)))
+ {
+ int edges = 0;
+ enum edge_style style;
+ int ypos = db->ypos;
+ int xpos = db->xpos;
+ int height = dga->height;
+ int width = dga->width;
+
+ /* The bevel_area routines always draw in from the specified
+ area so there is no need to adjust the displayed area to
+ make sure that the lines are visible. */
+ if (dga->xoffset >= 0)
+ edges |= EDGE_LEFT;
+ if (dga->width - dga->xoffset == layout_width)
+ edges |= EDGE_RIGHT;
+ if (dga->yoffset >= 0)
+ edges |= EDGE_TOP;
+ if (dga->height - dga->yoffset == layout_height)
+ edges |= EDGE_BOTTOM;
+
+ if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qetched_in))
+ style = EDGE_ETCHED_IN;
+ else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qetched_out))
+ style = EDGE_ETCHED_OUT;
+ else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qbevel_in))
+ style = EDGE_BEVEL_IN;
+ else if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (p)))
+ {
+ style = EDGE_ETCHED_IN;
+ if (edges & EDGE_TOP)
+ {
+ ypos += XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p));
+ height -= XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p));
+ }
+ }
+ else
+ style = EDGE_BEVEL_OUT;
+
+ MAYBE_DEVMETH (d, bevel_area,
+ (w, findex, xpos, ypos, width, height,
+ DEFAULT_WIDGET_SHADOW_WIDTH, edges, style));
+ }
+ }
+
+ /* This shrinks the display box to exactly enclose the glyph
+ area. */
+ redisplay_normalize_display_box (db, dga);
+
+ /* Flip through the widgets in the layout displaying as necessary */
+ LIST_LOOP (rest, IMAGE_INSTANCE_LAYOUT_CHILDREN (p))
+ {
+ Lisp_Object child = glyph_image_instance (XCAR (rest), image_instance,
+ ERROR_ME_NOT, 1);
+
+ struct display_box cdb;
+ /* For losing HP-UX */
+ cdb.xpos = db->xpos;
+ cdb.ypos = db->ypos;
+ cdb.width = db->width;
+ cdb.height = db->height;
+
+ /* First determine if the image is visible at all */
+ if (IMAGE_INSTANCEP (child))
+ {
+ Lisp_Image_Instance* childii = XIMAGE_INSTANCE (child);
+
+ /* The enclosing layout offsets are +ve at this point */
+ struct display_glyph_area cdga;
+ cdga.xoffset = IMAGE_INSTANCE_XOFFSET (childii) - dga->xoffset;
+ cdga.yoffset = IMAGE_INSTANCE_YOFFSET (childii) - dga->yoffset;
+ cdga.width = glyph_width (child, image_instance);
+ cdga.height = glyph_height (child, image_instance);
+
+ IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) =
+ IMAGE_INSTANCE_OPTIMIZE_OUTPUT (p);
+
+ /* Although normalization is done by the output routines
+ we have to do it here so that they don't try and
+ clear all of db. This is true below also. */
+ if (redisplay_normalize_glyph_area (&cdb, &cdga))
+ {
+ redisplay_normalize_display_box (&cdb, &cdga);
+ /* Since the display boxes will now be totally in the
+ window if they are visible at all we can now check this easily. */
+ if (cdb.xpos < db->xpos || cdb.ypos < db->ypos
+ || cdb.xpos + cdb.width > db->xpos + db->width
+ || cdb.ypos + cdb.height > db->ypos + db->height)
+ continue;
+ /* We have to invert the offset here as normalization
+ will have made them positive which the output
+ routines will treat as a truly +ve offset. */
+ cdga.xoffset = -cdga.xoffset;
+ cdga.yoffset = -cdga.yoffset;
+
+ switch (IMAGE_INSTANCE_TYPE (childii))
+ {
+ case IMAGE_TEXT:
+ {
+ /* #### This is well hacked and could use some
+ generalisation.*/
+ if (redisplay_normalize_glyph_area (&cdb, &cdga)
+ &&
+ (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) ||
+ IMAGE_INSTANCE_DIRTYP (childii)))
+ {
+ struct display_line dl; /* this is fake */
+ Lisp_Object string =
+ IMAGE_INSTANCE_TEXT_STRING (childii);
+ Charset_ID charsets[NUM_LEADING_BYTES];
+ struct face_cachel *cachel = WINDOW_FACE_CACHEL (w, findex);
+
+ find_charsets_in_bufbyte_string (charsets,
+ XSTRING_DATA (string),
+ XSTRING_LENGTH (string));
+ ensure_face_cachel_complete (cachel, window, charsets);
+
+ convert_bufbyte_string_into_charc_dynarr
+ (XSTRING_DATA (string), XSTRING_LENGTH (string),
+ buf);
+
+ redisplay_normalize_display_box (&cdb, &cdga);
+ /* Offsets are now +ve again so be careful
+ when fixing up the display line. */
+ xzero (dl);
+ /* Munge boxes into display lines. */
+ dl.ypos = (cdb.ypos - cdga.yoffset)
+ + glyph_ascent (child, image_instance);
+ dl.ascent = glyph_ascent (child, image_instance);
+ dl.descent = glyph_descent (child, image_instance);
+ dl.top_clip = cdga.yoffset;
+ dl.clip = (dl.ypos + dl.descent) - (cdb.ypos + cdb.height);
+ /* output_string doesn't understand offsets in
+ the same way as other routines - we have to
+ add the offset to the width so that we
+ output the full string. */
+ MAYBE_DEVMETH (d, output_string, (w, &dl, buf, cdb.xpos,
+ cdga.xoffset, cdb.xpos,
+ cdga.width + cdga.xoffset,
+ findex, 0, 0, 0, 0));
+ Dynarr_reset (buf);
+ }
+ }
+ break;
+
+ case IMAGE_MONO_PIXMAP:
+ case IMAGE_COLOR_PIXMAP:
+ if (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii)
+ || IMAGE_INSTANCE_DIRTYP (childii))
+ redisplay_output_pixmap (w, child, &cdb, &cdga, findex,
+ 0, 0, 0, 0);
+ break;
+
+ case IMAGE_WIDGET:
+ if (EQ (IMAGE_INSTANCE_WIDGET_TYPE (childii), Qlayout))
+ {
+ redisplay_output_layout (image_instance, child, &cdb, &cdga, findex,
+ 0, 0, 0);
+ break;
+ }
+ case IMAGE_SUBWINDOW:
+ if (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) ||
+ IMAGE_INSTANCE_DIRTYP (childii))
+ redisplay_output_subwindow (w, child, &cdb, &cdga, findex,
+ 0, 0, 0);
+ break;
+
+ case IMAGE_NOTHING:
+ /* nothing is as nothing does */
+ break;
+
+ case IMAGE_POINTER:
+ default:
+ abort ();
+ }
+ }
+ IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) = 0;
+ }
+ }
+
+ /* Update any display properties. I'm not sure whether this actually
+ does anything for layouts except clear the changed flags. */
+ redisplay_subwindow (image_instance);
+
+ Dynarr_free (buf);
+}
+
+/****************************************************************************
+ redisplay_output_pixmap
+
+
+ output a pixmap.
+ ****************************************************************************/
+void
+redisplay_output_pixmap (struct window *w,
+ Lisp_Object image_instance,
+ struct display_box* db, struct display_glyph_area* dga,
+ face_index findex, int cursor_start, int cursor_width,
+ int cursor_height, int offset_bitmap)
+{
+ struct frame *f = XFRAME (w->frame);
+ struct device *d = XDEVICE (f->device);
+ Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
+ Lisp_Object window;
+ XSETWINDOW (window, w);
+
+ dga->height = IMAGE_INSTANCE_PIXMAP_HEIGHT (p);
+ dga->width = IMAGE_INSTANCE_PIXMAP_WIDTH (p);
+
+#ifdef DEBUG_REDISPLAY
+ printf ("redisplay_output_pixmap(request) \
+[%dx%d@%d+%d] in [%dx%d@%d+%d]\n",
+ db->width, db->height, db->xpos, db->ypos,
+ dga->width, dga->height, dga->xoffset, dga->yoffset);
+#endif
+
+ /* This makes the glyph area fit into the display area. */
+ if (!redisplay_normalize_glyph_area (db, dga))
+ return;
+
+#ifdef DEBUG_REDISPLAY
+ printf ("redisplay_output_pixmap(normalized) \
+[%dx%d@%d+%d] in [%dx%d@%d+%d]\n",
+ db->width, db->height, db->xpos, db->ypos,
+ dga->width, dga->height, dga->xoffset, dga->yoffset);
+#endif
+
+ /* Clear the area the pixmap is going into. The pixmap itself will
+ always take care of the full width. We don't want to clear where
+ it is going to go in order to avoid flicker. So, all we have to
+ take care of is any area above or below the pixmap. If the pixmap
+ has a mask in which case we have to clear the whole damn thing
+ since we can't yet clear just the area not included in the
+ mask. */
+ if (!offset_bitmap)
+ {
+ redisplay_clear_clipped_region (window, findex,
+ db, dga,
+ (IMAGE_INSTANCE_PIXMAP_MASK (p) != 0),
+ Qnil);
+
+ /* This shrinks the display box to exactly enclose the glyph
+ area. */
+ redisplay_normalize_display_box (db, dga);
+ }
+ assert (db->xpos >= 0 && db->ypos >= 0);
+
+ MAYBE_DEVMETH (d, output_pixmap, (w, image_instance,
+ db, dga,
+ findex, cursor_start,
+ cursor_width, cursor_height,
+ offset_bitmap));
+}
+
+/****************************************************************************
+ redisplay_clear_region
+
+ Clear the area in the box defined by the given parameters using the
+ given face. This has been generalised so that subwindows can be
+ coped with effectively.
+ ****************************************************************************/
+void
+redisplay_clear_region (Lisp_Object locale, face_index findex, int x, int y,
+ int width, int height)
+{
+ struct window *w = NULL;
+ struct frame *f = NULL;
+ struct device *d;
+ Lisp_Object background_pixmap = Qunbound;
+ Lisp_Object fcolor = Qnil, bcolor = Qnil;
+
+ if (!width || !height)
+ return;
+
+ if (WINDOWP (locale))
+ {
+ w = XWINDOW (locale);
+ f = XFRAME (w->frame);
+ }
+ else if (FRAMEP (locale))
+ {
+ w = NULL;
+ f = XFRAME (locale);
+ }
+ else
+ abort ();
+
+ d = XDEVICE (f->device);
+
+ /* if we have subwindows in the region we have to unmap them */
+ redisplay_unmap_subwindows_maybe (f, x, y, width, height);
+
+ /* #### This isn't quite right for when this function is called
+ from the toolbar code. */
+
+ /* Don't use a backing pixmap in the border area */
+ if (x >= FRAME_LEFT_BORDER_END (f)
+ && x < FRAME_RIGHT_BORDER_START (f)
+ && y >= FRAME_TOP_BORDER_END (f)
+ && y < FRAME_BOTTOM_BORDER_START (f))
+ {
+ Lisp_Object temp;
+
+ if (w)
+ {
+ temp = WINDOW_FACE_CACHEL_BACKGROUND_PIXMAP (w, findex);
+
+ if (IMAGE_INSTANCEP (temp)
+ && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
+ {
+ /* #### maybe we could implement such that a string
+ can be a background pixmap? */
+ background_pixmap = temp;
+ }
+ }
+ else
+ {
+ temp = FACE_BACKGROUND_PIXMAP (Vdefault_face, locale);
+
+ if (IMAGE_INSTANCEP (temp)
+ && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
+ {
+ background_pixmap = temp;
+ }
+ }
+ }
+
+ if (!UNBOUNDP (background_pixmap) &&
+ XIMAGE_INSTANCE_PIXMAP_DEPTH (background_pixmap) == 0)
+ {
+ if (w)
+ {
+ fcolor = WINDOW_FACE_CACHEL_FOREGROUND (w, findex);
+ bcolor = WINDOW_FACE_CACHEL_BACKGROUND (w, findex);
+ }
+ else
+ {
+ fcolor = FACE_FOREGROUND (Vdefault_face, locale);
+ bcolor = FACE_BACKGROUND (Vdefault_face, locale);
+ }
+ }
+ else
+ {
+ fcolor = (w ?
+ WINDOW_FACE_CACHEL_BACKGROUND (w, findex) :
+ FACE_BACKGROUND (Vdefault_face, locale));
+
+ }
+
+ if (UNBOUNDP (background_pixmap))
+ background_pixmap = Qnil;
+
+ DEVMETH (d, clear_region,
+ (locale, d, f, findex, x, y, width, height, fcolor, bcolor, background_pixmap));
+}
+
+/****************************************************************************
+ redisplay_clear_clipped_region
+
+ Clear the area in the dest display_box not covered by the src
+ display_glyph_area using the given face. This is a common occurrence
+ for images shorter than the display line. Clipping can be played
+ around with by altering these. glyphsrc should be normalized.
+ ****************************************************************************/
+static void
+redisplay_clear_clipped_region (Lisp_Object window, face_index findex,
+ struct display_box* dest, struct display_glyph_area* glyphsrc,
+ int fullheight_p, Lisp_Object ignored_subwindow)
+{
+ /* assume dest->xpos >= 0 */
+ int clear_x;
+ struct frame* f = XFRAME (XWINDOW (window)->frame);
+
+ if (glyphsrc->xoffset > 0)
+ {
+ clear_x = dest->xpos + glyphsrc->xoffset;
+ }
+ else
+ {
+ clear_x = dest->xpos;
+ }
+
+ /* If we need the whole height cleared then just do it. */
+ if (fullheight_p)
+ {
+ redisplay_clear_region (window, findex, clear_x, dest->ypos,
+ glyphsrc->width, dest->height);
+ }
+ else
+ {
+ int yoffset = (glyphsrc->yoffset > 0 ? glyphsrc->yoffset : 0);
+
+ /* We need to make sure that subwindows are unmapped from the
+ whole area. */
+ redisplay_unmap_subwindows_except_us (f, clear_x, dest->ypos,
+ glyphsrc->width, dest->height,
+ ignored_subwindow);
+ /* first the top box */
+ if (yoffset > 0)
+ {
+ redisplay_clear_region (window, findex, clear_x, dest->ypos,
+ glyphsrc->width, yoffset);
+
+ }
+ /* Then the bottom box */
+ if (yoffset + glyphsrc->height < dest->height)
+ {
+ redisplay_clear_region (window, findex, clear_x,
+ dest->ypos + yoffset + glyphsrc->height,
+ glyphsrc->width,
+ dest->height - (yoffset + glyphsrc->height));
+
+ }
+ }
+}
+
+/*****************************************************************************
+ redisplay_normalize_glyph_area
+ redisplay_normalize_display_box
+
+ Calculate the visible box for displaying glyphsrc in dest.
+
+ display_box and display_glyph_area are used to represent an area to
+ displayed and where to display it. Using these two structures all
+ combinations of clipping and position can be accommodated.
+
+ dest - display_box
+
+ xpos - absolute horizontal position of area.
+
+ ypos - absolute vertical position of area.
+
+ glyphsrc - display_glyph_area
+
+ xoffset - horizontal offset of the glyph, +ve means display
+ the glyph with the x position offset by xoffset, -ve means
+ display starting xoffset into the glyph.
+
+ yoffset - vertical offset of the glyph, +ve means display the
+ glyph with y position offset by yoffset, -ve means display
+ starting xoffset into the glyph.
+
+ ****************************************************************************/
+int
+redisplay_normalize_glyph_area (struct display_box* dest,
+ struct display_glyph_area* glyphsrc)
+{
+ if (dest->xpos + glyphsrc->xoffset > dest->xpos + dest->width
+ ||
+ dest->ypos + glyphsrc->yoffset > dest->ypos + dest->height
+ ||
+ -glyphsrc->xoffset >= glyphsrc->width
+ ||
+ -glyphsrc->yoffset >= glyphsrc->height
+ ||
+ /* #### Not sure why this wasn't coped with before but normalizing
+ to zero width or height is definitely wrong. */
+ (dest->xpos + glyphsrc->xoffset + glyphsrc->width > dest->xpos + dest->width
+ &&
+ dest->width - glyphsrc->xoffset <= 0)
+ ||
+ (dest->ypos + glyphsrc->yoffset + glyphsrc->height > dest->ypos + dest->height
+ &&
+ dest->height - glyphsrc->yoffset <= 0))
+ {
+ /* It's all clipped out */
+ return 0;
+ }
+
+ /* Horizontal offsets. This works because xoffset can be -ve as well
+ as +ve. When we enter this function the glyphsrc width and
+ height are set to the actual glyph width and height irrespective
+ of how much can be displayed. We are trying to clip both the
+ offset into the image and the rightmost bounding box. Its
+ possible for the glyph width to be much larger than the area we
+ are displaying into (e.g. a large glyph in a small frame). */
+ if (dest->xpos + glyphsrc->xoffset + glyphsrc->width > dest->xpos + dest->width)
+ {
+ /* glyphsrc offset is +ve we are trying to display offset from the
+ origin (the bounding box contains some space and then the
+ glyph). At most the width we want to display is dest->width -
+ glyphsrc->xoffset. */
+ if (glyphsrc->xoffset > 0)
+ glyphsrc->width = dest->width - glyphsrc->xoffset;
+ /* glyphsrc offset is -ve we are trying to display hard up
+ against the dest corner inset into the glyphsrc by
+ xoffset.*/
+ else if (glyphsrc->xoffset < 0)
+ {
+ glyphsrc->width += glyphsrc->xoffset;
+ glyphsrc->width = min (glyphsrc->width, dest->width);
+ }
+ else
+ glyphsrc->width = dest->width;
+ }
+
+ else if (glyphsrc->xoffset < 0)
+ glyphsrc->width += glyphsrc->xoffset;
+
+ /* Vertical offsets. This works because yoffset can be -ve as well as +ve */
+ if (dest->ypos + glyphsrc->yoffset + glyphsrc->height > dest->ypos + dest->height)
+ {
+ if ((glyphsrc->yoffset > 0) && (dest->height > glyphsrc->yoffset))
+ glyphsrc->height = dest->height - glyphsrc->yoffset;
+ else if (glyphsrc->yoffset < 0)
+ {
+ glyphsrc->height += glyphsrc->yoffset;
+ glyphsrc->height = min (glyphsrc->height, dest->height);
+ }
+ else
+ glyphsrc->height = dest->height;
+ }
+
+ else if (glyphsrc->yoffset < 0)
+ glyphsrc->height += glyphsrc->yoffset;
+
+ return 1;
+}
+
+static void
+redisplay_normalize_display_box (struct display_box* dest,
+ struct display_glyph_area* glyphsrc)
+{
+ /* Adjust the destination area. At the end of this the destination
+ area will exactly enclose the glyph area. The only remaining
+ adjustment will be offsets into the glyph area. */
+
+ /* Horizontal adjustment. */
+ if (glyphsrc->xoffset > 0)
+ {
+ dest->xpos += glyphsrc->xoffset;
+ dest->width -= glyphsrc->xoffset;
+ glyphsrc->xoffset = 0;
+ }
+ else
+ glyphsrc->xoffset = -glyphsrc->xoffset;
+
+ if (glyphsrc->width < dest->width)
+ dest->width = glyphsrc->width;
+
+ /* Vertical adjustment. */
+ if (glyphsrc->yoffset > 0)
+ {
+ dest->ypos += glyphsrc->yoffset;
+ dest->height -= glyphsrc->yoffset;
+ glyphsrc->yoffset = 0;
+ }
+ else
+ glyphsrc->yoffset = -glyphsrc->yoffset;
+
+ if (glyphsrc->height < dest->height)
+ dest->height = glyphsrc->height;
+}
+
+/*****************************************************************************
+ redisplay_display_boxes_in_window_p
+
+ Determine whether the required display_glyph_area is completely inside
+ the window. -1 means the display_box is not in the window. 1 means the
+ display_box and the display_glyph_area are in the window. 0 means
+ the display_box is in the window but the display_glyph_area is not.
+ ****************************************************************************/
+static int
+redisplay_display_boxes_in_window_p (struct window* w,
+ struct display_box* db,
+ struct display_glyph_area* dga)
+{
+ int left = WINDOW_TEXT_LEFT (w);
+ int right = WINDOW_TEXT_RIGHT (w);
+ int top = WINDOW_TEXT_TOP (w);
+ int bottom = WINDOW_TEXT_BOTTOM (w);
+
+ if (db->xpos < left || db->ypos < top
+ || db->xpos + db->width > right
+ || db->ypos + db->height > bottom)
+ /* We are not displaying in a window at all */
+ return -1;
+
+ if (db->xpos + dga->xoffset >= left
+ &&
+ db->ypos + dga->yoffset >= top
+ &&
+ db->xpos + dga->xoffset + dga->width <= right
+ &&
+ db->ypos + dga->yoffset + dga->height <= bottom)
+ return 1;
+
+ return 0;
+}
+
+/*****************************************************************************
+ redisplay_calculate_display_boxes
+
+ Convert from rune/display_line co-ordinates to display_box
+ co-ordinates.
+ ****************************************************************************/
+int
+redisplay_calculate_display_boxes (struct display_line *dl, int xpos,
+ int xoffset, int yoffset, int start_pixpos,
+ int width, struct display_box* dest,
+ struct display_glyph_area* src)
+{
+ dest->xpos = xpos;
+ dest->ypos = DISPLAY_LINE_YPOS (dl);
+ dest->width = width;
+ dest->height = DISPLAY_LINE_HEIGHT (dl);
+
+ src->xoffset = -xoffset;
+ src->width = 0;
+ src->height = 0;
+
+ src->yoffset = -dl->top_clip + yoffset;
+
+ if (start_pixpos >=0 && start_pixpos > xpos)
+ {
+ /* Oops, we're asking for a start outside of the displayable
+ area. */
+ if (start_pixpos > xpos + width)
+ return 0;
+ dest->xpos = start_pixpos;
+ dest->width -= (start_pixpos - xpos);
+ /* Offsets are -ve when we want to clip pixels off the displayed
+ glyph. */
+ src->xoffset -= (start_pixpos - xpos);
+ }
+
+ return 1;
+}
+
projects / chise / xemacs-chise.git.1 / blobdiff