xemacs-beta: src/redisplay-output.c comparison

comparison src/redisplay-output.c @ 434:9d177e8d4150 r21-2-25

Import from CVS: tag r21-2-25

author	cvs
date	Mon, 13 Aug 2007 11:30:53 +0200
parents	a5df635868b2
children	84b14dcb0985

comparison

equal deleted inserted replaced

-:892ca416f0fb
+:9d177e8d4150
 			  struct rune *drb);
 static void redraw_cursor_in_window (struct window *w,
 				     int run_end_begin_glyphs);
 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);
 static void redisplay_normalize_display_box (struct display_box* dest,
 					     struct display_glyph_area* src);
 static int redisplay_display_boxes_in_window_p (struct window* w,
 						struct display_box* db,
 						struct display_glyph_area* dga);
 static void redisplay_clear_clipped_region (Lisp_Object locale, face_index findex,
 					    struct display_box* dest,
 					    struct display_glyph_area* glyphsrc,
 					    int fullheight_p, Lisp_Object);
 /*****************************************************************************
 sync_rune_structs
 So I (JV) conjecture
 #### It would really be worth it to arrange for this function to
 be (almost) a single call to memcmp. */
 if ((crb->findex != drb->findex) ||
 (WINDOW_FACE_CACHEL_DIRTY (w, drb->findex)))
 return 0;
 else if (crb->xpos != drb->xpos)
 return 0;
 return 0;
 else if (crb->type == RUNE_HLINE &&
 	   (crb->object.hline.thickness != drb->object.hline.thickness ||
 	    crb->object.hline.yoffset != drb->object.hline.yoffset))
 return 0;
 else if (crb->type == RUNE_DGLYPH &&
 	   (!EQ (crb->object.dglyph.glyph, drb->object.dglyph.glyph) ||
 	    !EQ (crb->object.dglyph.extent, drb->object.dglyph.extent) ||
 	    crb->object.dglyph.xoffset != drb->object.dglyph.xoffset))
 return 0;
 /* Only check dirtiness if we know something has changed. */
 /* Although doing the cachel lookup for every comparison is
 	 very expensive.we have to do it to make sure the cache is
 	 up-to-date. */
 if (GLYPH_CACHEL_DIRTYP (w, gindex))
 	return 0;
 else
 	return 1;
 }
 else
 return 1;
 }
 		  height = DISPLAY_LINE_HEIGHT (ddl);
 		  if (x < ddl->bounds.left_in)
 		    {
 		      findex = ddl->left_margin_findex ?
 			ddl->left_margin_findex
 			: get_builtin_face_cache_index (w, Vleft_margin_face);
 		    }
 		  else if (x < ddl->bounds.right_in)
 		    {
 		      /* no check here because DEFAULT_INDEX == 0 anyway */
 		      findex = ddl->default_findex;
 		    }
 		  else if (x < ddl->bounds.right_out)
 		    {
 		      findex = ddl->right_margin_findex ?
 			ddl->right_margin_findex
 			: get_builtin_face_cache_index (w, Vright_margin_face);
 		    }
 		  else
 		    findex = (face_index) -1;
 	  /* If there was formerly no block over the current
 	     region or if it was a block of a different type, then
 	     output the entire ddb.  Otherwise, compare cdb and
 	     ddb and output only the changed region. */
 	  if (!force && cdb && ddb->type == cdb->type
 	      /* If there was no buffer being display before the
 compare anyway as we might be outputting a gutter. */
 	      &&
 	      (b == old_b || !old_b))
 	    {
 	      must_sync |= compare_display_blocks (w, cdl, ddl, old_block,
 						   block, start_pixpos,
 						   cursor_start, cursor_width,
 					      last_elt,
 					      start_pixpos,
 					      cursor_start, cursor_width,
 					      cursor_height);
 	    }
 	  start_pixpos = next_start_pixpos;
 	}
 }
 /* Clear the internal border if we are next to it and the window
 	  if (ddl->modeline)
 	    {
 	      y -= MODELINE_SHADOW_THICKNESS (w);
 	      height += (2 * MODELINE_SHADOW_THICKNESS (w));
 	    }
 	  if (window_is_leftmost (w))
 	    clear_left_border (w, y, height);
 	  if (window_is_rightmost (w))
 	    clear_right_border (w, y, height);
 	}
 	      cur_dl = y;
 	      first = 1;
 	    }
 	}
-while ((up ? (cur_dl < Dynarr_length (cla)) : (cur_dl >= 0)))
+while (up ? (cur_dl < Dynarr_length (cla)) : (cur_dl >= 0))
 	{
 	  dl = Dynarr_atp (cla, cur_dl);
 	  db = get_display_block_from_line (dl, TEXT);
 	  if (!up && !first)
 if (cachel->being_displayed
 	  &&
 	  cachel->x + cachel->width > x && cachel->x < x + width
 	  &&
 	  cachel->y + cachel->height > y && cachel->y < y + height
 	  &&
 	  !EQ (cachel->subwindow, ignored_window))
 	{
 	  unmap_subwindow (cachel->subwindow);
 	}
 }
 {
 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 (Dynarr_length (FRAME_SUBWINDOW_CACHE (f)))
 {
 redisplay_unmap_subwindows (f, x, y, width, height, 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)
 {
 cases.*/
 sdga.xoffset = -dga->xoffset;
 sdga.yoffset = -dga->yoffset;
 sdga.height = IMAGE_INSTANCE_SUBWINDOW_HEIGHT (p);
 sdga.width = IMAGE_INSTANCE_SUBWINDOW_WIDTH (p);
 if (redisplay_display_boxes_in_window_p (w, 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.
 ****************************************************************************/
 void
 redisplay_output_layout (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)
 {
 {
 /* 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 height = dga->height;
 	  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))
 		}
 	    }
 	  else
 	    style = EDGE_BEVEL_OUT;
 	  MAYBE_DEVMETH (d, bevel_area,
 			 (w, findex, db->xpos,
 			  ypos,
 			  dga->width, height, 2, 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 */
 		{
 		case IMAGE_TEXT:
 		  {
 		    /* #### This is well hacked and could use some
 		       generalisation.*/
 		    if (redisplay_normalize_glyph_area (&cdb, &cdga)
 			&&
 			(frame_really_changed || IMAGE_INSTANCE_DIRTYP (childii)))
 		      {
 			struct display_line dl;	/* this is fake */
 			Lisp_Object string =
 			  IMAGE_INSTANCE_TEXT_STRING (childii);
 			convert_bufbyte_string_into_emchar_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. */
 							  findex, 0, 0, 0, 0));
 			Dynarr_reset (buf);
 		      }
 		  }
 		  break;
 		case IMAGE_MONO_PIXMAP:
 		case IMAGE_COLOR_PIXMAP:
 		  if (frame_really_changed || IMAGE_INSTANCE_DIRTYP (childii))
 		    redisplay_output_pixmap (w, child, &cdb, &cdga, findex,
 					     0, 0, 0, 0);
 		  break;
 		case IMAGE_WIDGET:
 		case IMAGE_SUBWINDOW:
 		  if (frame_really_changed || IMAGE_INSTANCE_DIRTYP (childii))
 		    redisplay_output_subwindow (w, child, &cdb, &cdga, findex,
 						0, 0, 0);
 		  break;
 		case IMAGE_LAYOUT:
 		  redisplay_output_layout (w, child, &cdb, &cdga, findex,
 					   0, 0, 0);
 		  break;
 		case IMAGE_NOTHING:
 		  /* nothing is as nothing does */
 		  break;
 		case IMAGE_POINTER:
 		default:
 		  abort ();
 		}
 	    }
 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)
 {
 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,
 				      (int)IMAGE_INSTANCE_PIXMAP_MASK (p),
 				      Qnil);
 /* This shrinks the display box to exactly enclose the glyph
 	 area. */
 /* 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? */
 	    }
 	}
 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)
 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
 display_glyph_area using the given face. This is a common occurance
 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);
 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_display_box
 Calculate the visible box for displaying src in dest.
 ****************************************************************************/
 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
 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. */
 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 0;
 if (db->xpos + dga->xoffset >= left
 &&
 db->ypos + dga->yoffset >= top
 &&
 db->xpos + dga->xoffset + dga->width <= right
 co-ordinates.
 ****************************************************************************/
 int
 redisplay_calculate_display_boxes (struct display_line *dl, int xpos,
 				   int xoffset, 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;
 if (HAS_DEVMETH_P (d, clear_to_window_end))
 DEVMETH (d, clear_to_window_end, (w, ypos1, ypos2));
 else
 {
 int height = ypos2 - ypos1;
 if (height)
 	{
 	  Lisp_Object window;
 	  int bflag = 0 ; /* (window_needs_vertical_divider (w) ? 0 : 1);*/
 	  layout_bounds bounds;
 	  bounds = calculate_display_line_boundaries (w, bflag);
 	  XSETWINDOW (window, w);
 	  if (window_is_leftmost (w))
 	    redisplay_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
 				    ypos1, FRAME_BORDER_WIDTH (f), height);
 	  if (bounds.left_in - bounds.left_out > 0)
 	    redisplay_clear_region (window,
 				    get_builtin_face_cache_index (w, Vleft_margin_face),
 				    bounds.left_out, ypos1,
 				    bounds.left_in - bounds.left_out, height);
 	  if (bounds.right_in - bounds.left_in > 0)
 	    redisplay_clear_region (window,
 				    DEFAULT_INDEX,
 				    bounds.left_in, ypos1,
 				    bounds.right_in - bounds.left_in, height);
 	  if (bounds.right_out - bounds.right_in > 0)
 	    redisplay_clear_region (window,
 				    get_builtin_face_cache_index (w, Vright_margin_face),
 				    bounds.right_in, ypos1,
 				    bounds.right_out - bounds.right_in, height);
 	  if (window_is_rightmost (w))
 	    redisplay_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
 				    ypos1, FRAME_BORDER_WIDTH (f), height);
 	}
 }
 else
 {
 style = EDGE_BEVEL_OUT;
 }
 MAYBE_DEVMETH (d, bevel_area,
 		 (w, MODELINE_INDEX, x, y, width, height, shadow_thickness,
 		  EDGE_ALL, style));
 }

Mercurial > hg > xemacs-beta

comparison src/redisplay-output.c @ 434:9d177e8d4150 r21-2-25