emacs: src/xdisp.c comparison

comparison src/xdisp.c @ 51209:880539128b51

Make (many) trivial substitutions for renamed and new macros in dispextern.h, frame.h and window.h. (window_box_width): Adapt to per-window fringes and scroll bars, and new fringe vs. display margin position. Note that returned value is no longer guaranteed to be a whole multiple of the frame column width, since per-window fringes may now be any width. (window_box_left_offset): New function like window_box_left, but value is relative to left border of window (rather than frame). (window_box_right_offset): New function like window_box_right, but value is relative to left border of window. (window_box_left): Adapt to per-window fringes and scroll bars, and new fringe vs. display margin position. Simplify by using WINDOW_LEFT_EDGE_X and window_box_left_offset. (window_box): Allow null args for unnecessary return values; change/simplify relevant callers. (x_y_to_hpos_vpos): Adapt to per-window fringes and scroll bars, and new fringe vs. display margin position. Use window_box_left_offset and window_box_right_offset (get_glyph_string_clip_rect): Adapt to per-window fringes and scroll bars, and new fringe vs. display margin position. Use WINDOW_LEFT_EDGE_X and WINDOW_TOTAL_WIDTH. (draw_fringe_bitmap): Rework to handle per-window fringes and new fringe vs. display margin position. (hscroll_window_tree): Use window_box_width instead of window_box. (redisplay_window): Adapt to per-window scroll bars. (draw_glyphs): Rework to handle per-window fringes and scroll bars, and new fringe vs. display margin position. Use WINDOW_LEFT_EDGE_X, WINDOW_TOTAL_WIDTH, and window_box_left. (x_clear_end_of_line): Adapt to per-window fringes and scroll bars, and new fringe vs. display margin position. Fix bug which increased total width of full_width rows by width of scroll bars although window's total width already includes that. (x_fix_overlapping_area): Simplify using window_box_left_offset. (expose_area): Simplify using window_box_left_offset. (x_draw_vertical_border): Handle per-window scroll bar settings, mixing windows with left, right and no scroll bars.

author	Kim F. Storm <storm@cua.dk>
date	Sat, 24 May 2003 22:08:54 +0000
parents	b4f5f0f32f01
children	998639def2d1

comparison

equal deleted inserted replaced

-:86d74f5ea803
+:880539128b51
 static EMACS_INT scroll_conservatively;
 /* Recenter the window whenever point gets within this many lines of
 the top or bottom of the window.  This value is translated into a
-pixel value by multiplying it with CANON_Y_UNIT, which means that
+pixel value by multiplying it with FRAME_LINE_HEIGHT, which means
-there is really a fixed pixel height scroll margin.  */
+that there is really a fixed pixel height scroll margin.  */
 EMACS_INT scroll_margin;
 /* Number of windows showing the buffer of the selected window (or
 another buffer with the same base buffer).  keyboard.c refers to
 INLINE int
 window_text_bottom_y (w)
 struct window *w;
 {
 struct frame *f = XFRAME (w->frame);
-int height = XFASTINT (w->height) * CANON_Y_UNIT (f);
+int height = WINDOW_TOTAL_HEIGHT (w);
 if (WINDOW_WANTS_MODELINE_P (w))
 height -= CURRENT_MODE_LINE_HEIGHT (w);
 return height;
 }
 /* Return the pixel width of display area AREA of window W.  AREA < 0
 means return the total width of W, not including fringes to
 the left and right of the window.  */
 INLINE int
 window_box_width (w, area)
 struct window *w;
 int area;
 {
-struct frame *f = XFRAME (w->frame);
+int cols = XFASTINT (w->total_cols);
-int width = XFASTINT (w->width);
+int pixels = 0;
 if (!w->pseudo_window_p)
 {
-width -= FRAME_SCROLL_BAR_WIDTH (f) + FRAME_FRINGE_COLS (f);
+cols -= WINDOW_SCROLL_BAR_COLS (w);
 if (area == TEXT_AREA)
 	{
-	  if (INTEGERP (w->left_margin_width))
+	  if (INTEGERP (w->left_margin_cols))
-	    width -= XFASTINT (w->left_margin_width);
+	    cols -= XFASTINT (w->left_margin_cols);
-	  if (INTEGERP (w->right_margin_width))
+	  if (INTEGERP (w->right_margin_cols))
-	    width -= XFASTINT (w->right_margin_width);
+	    cols -= XFASTINT (w->right_margin_cols);
+	  pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
 	}
 else if (area == LEFT_MARGIN_AREA)
-	width = (INTEGERP (w->left_margin_width)
+	{
-		 ? XFASTINT (w->left_margin_width) : 0);
+	  cols = (INTEGERP (w->left_margin_cols)
+		   ? XFASTINT (w->left_margin_cols) : 0);
+	  pixels = 0;
+	}
 else if (area == RIGHT_MARGIN_AREA)
-	width = (INTEGERP (w->right_margin_width)
+	{
-		 ? XFASTINT (w->right_margin_width) : 0);
+	  cols = (INTEGERP (w->right_margin_cols)
-}
+		   ? XFASTINT (w->right_margin_cols) : 0);
+	  pixels = 0;
-return width * CANON_X_UNIT (f);
+	}
+}
+return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
 }
 /* Return the pixel height of the display area of window W, not
 including mode lines of W, if any.  */
 INLINE int
 window_box_height (w)
 struct window *w;
 {
 struct frame *f = XFRAME (w->frame);
-int height = XFASTINT (w->height) * CANON_Y_UNIT (f);
+int height = WINDOW_TOTAL_HEIGHT (w);
 xassert (height >= 0);
 /* Note: the code below that determines the mode-line/header-line
 height is essentially the same as that contained in the macro
 /* With a very small font and a mode-line that's taller than
 default, we might end up with a negative height.  */
 return max (0, height);
 }
+/* Return the window-relative coordinate of the left edge of display
+area AREA of window W.  AREA < 0 means return the left edge of the
+whole window, to the right of the left fringe of W.  */
+INLINE int
+window_box_left_offset (w, area)
+struct window *w;
+int area;
+{
+int x;
+if (w->pseudo_window_p)
+return 0;
+x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
+if (area == TEXT_AREA)
+x += (WINDOW_LEFT_FRINGE_WIDTH (w)
+	  + window_box_width (w, LEFT_MARGIN_AREA));
+else if (area == RIGHT_MARGIN_AREA)
+x += (WINDOW_LEFT_FRINGE_WIDTH (w)
+	  + window_box_width (w, LEFT_MARGIN_AREA)
+	  + window_box_width (w, TEXT_AREA)
+	  + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+	     ? 0
+	     : WINDOW_RIGHT_FRINGE_WIDTH (w)));
+else if (area == LEFT_MARGIN_AREA
+	   && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
+x += WINDOW_LEFT_FRINGE_WIDTH (w);
+return x;
+}
+/* Return the window-relative coordinate of the right edge of display
+area AREA of window W.  AREA < 0 means return the left edge of the
+whole window, to the left of the right fringe of W.  */
+INLINE int
+window_box_right_offset (w, area)
+struct window *w;
+int area;
+{
+return window_box_left_offset (w, area) + window_box_width (w, area);
+}
 /* Return the frame-relative coordinate of the left edge of display
 area AREA of window W.  AREA < 0 means return the left edge of the
 whole window, to the right of the left fringe of W.  */
 window_box_left (w, area)
 struct window *w;
 int area;
 {
 struct frame *f = XFRAME (w->frame);
-int x = FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
+int x;
-if (!w->pseudo_window_p)
+if (w->pseudo_window_p)
-{
+return FRAME_INTERNAL_BORDER_WIDTH (f);
-x += (WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f)
-	    + FRAME_LEFT_FRINGE_WIDTH (f));
+x = (WINDOW_LEFT_EDGE_X (w)
++ window_box_left_offset (w, area));
-if (area == TEXT_AREA)
-	x += window_box_width (w, LEFT_MARGIN_AREA);
-else if (area == RIGHT_MARGIN_AREA)
-	x += (window_box_width (w, LEFT_MARGIN_AREA)
-	      + window_box_width (w, TEXT_AREA));
-}
 return x;
 }
 struct window *w;
 int area;
 {
 return window_box_left (w, area) + window_box_width (w, area);
 }
 /* Get the bounding box of the display area AREA of window W, without
 mode lines, in frame-relative coordinates.  AREA < 0 means the
 whole window, not including the left and right fringes of
 the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
 window_box (w, area, box_x, box_y, box_width, box_height)
 struct window *w;
 int area;
 int *box_x, *box_y, *box_width, *box_height;
 {
-struct frame *f = XFRAME (w->frame);
+if (box_width)
+*box_width = window_box_width (w, area);
-*box_width = window_box_width (w, area);
+if (box_height)
 *box_height = window_box_height (w);
-*box_x = window_box_left (w, area);
+if (box_x)
-*box_y = (FRAME_INTERNAL_BORDER_WIDTH_SAFE (f)
+*box_x = window_box_left (w, area);
-	    + XFASTINT (w->top) * CANON_Y_UNIT (f));
+if (box_y)
-if (WINDOW_WANTS_HEADER_LINE_P (w))
+{
-*box_y += CURRENT_HEADER_LINE_HEIGHT (w);
+*box_y = WINDOW_TOP_EDGE_Y (w);
+if (WINDOW_WANTS_HEADER_LINE_P (w))
+	*box_y += CURRENT_HEADER_LINE_HEIGHT (w);
+}
 }
 /* Get the bounding box of the display area AREA of window W, without
 mode lines.  AREA < 0 means the whole window, not including the
 /* Note that we may overshoot because of invisible text.  */
 if (IT_CHARPOS (it) >= charpos)
 {
 int top_y = it.current_y;
 int bottom_y = line_bottom_y (&it);
-int window_top_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
 if (top_y < window_top_y)
 	visible_p = bottom_y > window_top_y;
 else if (top_y < it.last_visible_y)
 	{
 {
 #ifdef HAVE_WINDOW_SYSTEM
 if (FRAME_WINDOW_P (f))
 {
-/* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
+/* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
 	 even for negative values.  */
 if (pix_x < 0)
-	pix_x -= FONT_WIDTH (FRAME_FONT (f)) - 1;
+	pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
 if (pix_y < 0)
-	pix_y -= FRAME_X_OUTPUT(f)->line_height - 1;
+	pix_y -= FRAME_LINE_HEIGHT (f) - 1;
-pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
+pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
-pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
+pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
 if (bounds)
 	STORE_NATIVE_RECT (*bounds,
-			   CHAR_TO_PIXEL_COL (f, pix_x),
+			   FRAME_COL_TO_PIXEL_X (f, pix_x),
-			   CHAR_TO_PIXEL_ROW (f, pix_y),
+			   FRAME_LINE_TO_PIXEL_Y (f, pix_y),
-			   FONT_WIDTH  (FRAME_FONT (f)) - 1,
+			   FRAME_COLUMN_WIDTH (f) - 1,
-			   FRAME_X_OUTPUT (f)->line_height - 1);
+			   FRAME_LINE_HEIGHT (f) - 1);
 if (!noclip)
 	{
 	  if (pix_x < 0)
 	    pix_x = 0;
-	  else if (pix_x > FRAME_WINDOW_WIDTH (f))
+	  else if (pix_x > FRAME_TOTAL_COLS (f))
-	    pix_x = FRAME_WINDOW_WIDTH (f);
+	    pix_x = FRAME_TOTAL_COLS (f);
 	  if (pix_y < 0)
 	    pix_y = 0;
-	  else if (pix_y > f->height)
+	  else if (pix_y > FRAME_LINES (f))
-	    pix_y = f->height;
+	    pix_y = FRAME_LINES (f);
 	}
 }
 #endif
 *x = pix_x;
 int *hpos, *vpos, *area;
 int buffer_only_p;
 {
 struct glyph *glyph, *end;
 struct glyph_row *row = NULL;
-int x0, i, left_area_width;
+int x0, i;
 /* Find row containing Y.  Give up if some row is not enabled.  */
 for (i = 0; i < w->current_matrix->nrows; ++i)
 {
 row = MATRIX_ROW (w->current_matrix, i);
 *area = TEXT_AREA;
 x0 = 0;
 }
 else
 {
-left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
+if (x < window_box_left_offset (w, TEXT_AREA))
-if (x < left_area_width)
 	{
 	  *area = LEFT_MARGIN_AREA;
-	  x0 = 0;
+	  x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
 	}
-else if (x < left_area_width + window_box_width (w, TEXT_AREA))
+else if (x < window_box_right_offset (w, TEXT_AREA))
 	{
 	  *area = TEXT_AREA;
-	  x0 = row->x + left_area_width;
+	  x0 = window_box_left_offset (w, TEXT_AREA);
 	}
 else
 	{
 	  *area = RIGHT_MARGIN_AREA;
-	  x0 = left_area_width + window_box_width (w, TEXT_AREA);
+	  x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
 	}
 }
 /* Find glyph containing X.  */
 glyph = row->glyphs[*area];
 if (w->pseudo_window_p)
 {
 /* A pseudo-window is always full-width, and starts at the
 	 left edge of the frame, plus a frame border.  */
 struct frame *f = XFRAME (w->frame);
-*x -= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
+*x -= FRAME_INTERNAL_BORDER_WIDTH (f);
 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
 }
 else
 {
-*x = FRAME_TO_WINDOW_PIXEL_X (w, *x);
+*x -= WINDOW_LEFT_EDGE_X (w);
 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
 }
 }
 /* EXPORT:
 {
 XRectangle r;
 if (s->row->full_width_p)
 {
-/* Draw full-width.  X coordinates are relative to S->w->left.  */
+/* Draw full-width.  X coordinates are relative to S->w->left_col.  */
-int canon_x = CANON_X_UNIT (s->f);
+r.x = WINDOW_LEFT_EDGE_X (s->w);
+r.width = WINDOW_TOTAL_WIDTH (s->w);
-r.x = WINDOW_LEFT_MARGIN (s->w) * canon_x;
-r.width = XFASTINT (s->w->width) * canon_x;
-if (FRAME_HAS_VERTICAL_SCROLL_BARS (s->f))
-	{
-	  int width = FRAME_SCROLL_BAR_WIDTH (s->f) * canon_x;
-	  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s->f))
-	    r.x -= width;
-	}
-r.x += FRAME_INTERNAL_BORDER_WIDTH (s->f);
 /* Unless displaying a mode or menu bar line, which are always
 	 fully visible, clip to the visible part of the row.  */
 if (s->w->pseudo_window_p)
 	r.height = s->row->visible_height;
 	r.height = s->height;
 }
 else
 {
 /* This is a text line that may be partially visible.  */
-r.x = WINDOW_AREA_TO_FRAME_PIXEL_X (s->w, s->area, 0);
+r.x = window_box_left (s->w, s->area);
 r.width = window_box_width (s->w, s->area);
 r.height = s->row->visible_height;
 }
 /* If S draws overlapping rows, it's sufficient to use the top and
 bottom of the window for clipping because this glyph string
 intentionally draws over other lines.  */
 if (s->for_overlaps_p)
 {
-r.y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
+r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
 r.height = window_text_bottom_y (s->w) - r.y;
 }
 else
 {
 /* Don't use S->y for clipping because it doesn't take partially
 	 visible lines into account.  For example, it can be negative for
 	 partially visible lines at the top of a window.  */
 if (!s->row->full_width_p
 	  && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
-	r.y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
+	r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
 else
 	r.y = max (0, s->row->y);
 /* If drawing a tool-bar window, draw it over the internal border
 	 at the top of the window.  */
 start of this total display area.  */
 if (base_face_id != DEFAULT_FACE_ID)
 {
 /* Mode lines, menu bar in terminal frames.  */
 it->first_visible_x = 0;
-it->last_visible_x = XFASTINT (w->width) * CANON_X_UNIT (it->f);
+it->last_visible_x = WINDOW_TOTAL_WIDTH (w);
 }
 else
 {
 it->first_visible_x
-	= XFASTINT (it->w->hscroll) * CANON_X_UNIT (it->f);
+	= XFASTINT (it->w->hscroll) * FRAME_COLUMN_WIDTH (it->f);
 it->last_visible_x = (it->first_visible_x
 			    + window_box_width (w, TEXT_AREA));
 /* If we truncate lines, leave room for the truncator glyph(s) at
 	 the right margin.  Otherwise, leave room for the continuation
 	  else
 	    it->last_visible_x -= it->continuation_pixel_width;
 	}
 it->header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
-it->current_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w) + w->vscroll;
+it->current_y = WINDOW_HEADER_LINE_HEIGHT (w) + w->vscroll;
 }
 /* Leave room for a border glyph.  */
 if (!FRAME_WINDOW_P (it->f)
 && !WINDOW_RIGHTMOST_P (it->w))
 int start_pos = IT_CHARPOS (*it);
 xassert (dy >= 0);
 /* Estimate how many newlines we must move back.  */
-nlines = max (1, dy / CANON_Y_UNIT (it->f));
+nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
 /* Set the iterator's position that many lines back.  */
 while (nlines-- && IT_CHARPOS (*it) > BEGV)
 back_to_previous_visible_line_start (it);
 if (!FRAME_MINIBUF_ONLY_P (f))
 {
 struct it it;
 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
-int total_height = XFASTINT (root->height) + XFASTINT (w->height);
+int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w);
 int height, max_height;
-int unit = CANON_Y_UNIT (f);
+int unit = FRAME_LINE_HEIGHT (f);
 struct text_pos start;
 struct buffer *old_current_buffer = NULL;
 if (current_buffer != XBUFFER (w->buffer))
 	{
 init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
 /* Compute the max. number of lines specified by the user.  */
 if (FLOATP (Vmax_mini_window_height))
-	max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_HEIGHT (f);
+	max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_LINES (f);
 else if (INTEGERP (Vmax_mini_window_height))
 	max_height = XINT (Vmax_mini_window_height);
 else
 	max_height = total_height / 4;
 if (EQ (Vresize_mini_windows, Qgrow_only))
 	{
 	  /* Let it grow only, until we display an empty message, in which
 	     case the window shrinks again.  */
-	  if (height > XFASTINT (w->height))
+	  if (height > WINDOW_TOTAL_LINES (w))
 	    {
-	      int old_height = XFASTINT (w->height);
+	      int old_height = WINDOW_TOTAL_LINES (w);
 	      freeze_window_starts (f, 1);
-	      grow_mini_window (w, height - XFASTINT (w->height));
+	      grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 	    }
-	  else if (height < XFASTINT (w->height)
+	  else if (height < WINDOW_TOTAL_LINES (w)
 		   && (exact_p || BEGV == ZV))
 	    {
-	      int old_height = XFASTINT (w->height);
+	      int old_height = WINDOW_TOTAL_LINES (w);
 	      freeze_window_starts (f, 0);
 	      shrink_mini_window (w);
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 	    }
 	}
 else
 	{
 	  /* Always resize to exact size needed.  */
-	  if (height > XFASTINT (w->height))
+	  if (height > WINDOW_TOTAL_LINES (w))
 	    {
-	      int old_height = XFASTINT (w->height);
+	      int old_height = WINDOW_TOTAL_LINES (w);
 	      freeze_window_starts (f, 1);
-	      grow_mini_window (w, height - XFASTINT (w->height));
+	      grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 	    }
-	  else if (height < XFASTINT (w->height))
+	  else if (height < WINDOW_TOTAL_LINES (w))
 	    {
-	      int old_height = XFASTINT (w->height);
+	      int old_height = WINDOW_TOTAL_LINES (w);
 	      freeze_window_starts (f, 0);
 	      shrink_mini_window (w);
 	      if (height)
 		{
 		  freeze_window_starts (f, 1);
-		  grow_mini_window (w, height - XFASTINT (w->height));
+		  grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
 		}
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 	    }
 	}
 if (old_current_buffer)
 	set_buffer_internal (old_current_buffer);
 {
 #ifdef USE_GTK
 int do_update = FRAME_EXTERNAL_TOOL_BAR(f);
 #else
 int do_update = WINDOWP (f->tool_bar_window)
-&& XFASTINT (XWINDOW (f->tool_bar_window)->height) > 0;
+&& WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0;
 #endif
 if (do_update)
 {
 Lisp_Object window;
 /* Initialize an iterator for iteration over
 F->desired_tool_bar_string in the tool-bar window of frame F.  */
 init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
 it.first_visible_x = 0;
-it.last_visible_x = FRAME_WINDOW_WIDTH (f) * CANON_X_UNIT (f);
+it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
 while (!ITERATOR_AT_END_P (&it))
 {
 it.glyph_row = w->desired_matrix->rows;
 clear_glyph_row (it.glyph_row);
 display_tool_bar_line (&it);
 }
-return (it.current_y + CANON_Y_UNIT (f) - 1) / CANON_Y_UNIT (f);
+return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 }
 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
 0, 1, 0,
 CHECK_FRAME (frame);
 f = XFRAME (frame);
 if (WINDOWP (f->tool_bar_window)
 || (w = XWINDOW (f->tool_bar_window),
-	  XFASTINT (w->height) > 0))
+	  WINDOW_TOTAL_LINES (w) > 0))
 {
 update_tool_bar (f, 1);
 if (f->n_tool_bar_items)
 	{
 	  build_desired_tool_bar_string (f);
 do anything.  This means you must start with tool-bar-lines
 non-zero to get the auto-sizing effect.  Or in other words, you
 can turn off tool-bars by specifying tool-bar-lines zero.  */
 if (!WINDOWP (f->tool_bar_window)
 || (w = XWINDOW (f->tool_bar_window),
-XFASTINT (w->height) == 0))
+WINDOW_TOTAL_LINES (w) == 0))
 return 0;
 /* Set up an iterator for the tool-bar window.  */
 init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
 it.first_visible_x = 0;
-it.last_visible_x = FRAME_WINDOW_WIDTH (f) * CANON_X_UNIT (f);
+it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
 row = it.glyph_row;
 /* Build a string that represents the contents of the tool-bar.  */
 build_desired_tool_bar_string (f);
 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
 if (IT_STRING_CHARPOS (it) < it.end_charpos)
 	change_height_p = 1;
 /* If there are blank lines at the end, except for a partially
 	 visible blank line at the end that is smaller than
-	 CANON_Y_UNIT, change the tool-bar's height.  */
+	 FRAME_LINE_HEIGHT, change the tool-bar's height.  */
 row = it.glyph_row - 1;
 if (!row->displays_text_p
-	  && row->height >= CANON_Y_UNIT (f))
+	  && row->height >= FRAME_LINE_HEIGHT (f))
 	change_height_p = 1;
 /* If row displays tool-bar items, but is partially visible,
 	 change the tool-bar's height.  */
 if (row->displays_text_p
 /* Resize windows as needed by changing the `tool-bar-lines'
 	 frame parameter.  */
 if (change_height_p
 	  && (nlines = tool_bar_lines_needed (f),
-	      nlines != XFASTINT (w->height)))
+	      nlines != WINDOW_TOTAL_LINES (w)))
 	{
 	  extern Lisp_Object Qtool_bar_lines;
 	  Lisp_Object frame;
-	  int old_height = XFASTINT (w->height);
+	  int old_height = WINDOW_TOTAL_LINES (w);
 	  XSETFRAME (frame, f);
 	  clear_glyph_matrix (w->desired_matrix);
 	  Fmodify_frame_parameters (frame,
 				    Fcons (Fcons (Qtool_bar_lines,
 						  make_number (nlines)),
 					   Qnil));
-	  if (XFASTINT (w->height) != old_height)
+	  if (WINDOW_TOTAL_LINES (w) != old_height)
 	    fonts_changed_p = 1;
 	}
 }
 return change_height_p;
 /* If tool-bar item is not enabled, don't highlight it.  */
 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 if (!NILP (enabled_p))
 {
 /* Compute the x-position of the glyph.  In front and past the
-	 image is a space.  We include this is the highlighted area.  */
+	 image is a space.  We include this in the highlighted area.  */
 row = MATRIX_ROW (w->current_matrix, vpos);
 for (i = x = 0; i < hpos; ++i)
 	x += row->glyphs[TEXT_AREA][i].pixel_width;
 /* Record this as the current active region.  */
 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
 the fringe.  */
 p.bx = -1;
 if (left_p)
 {
-if (p.wd > FRAME_X_LEFT_FRINGE_WIDTH (f))
+int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
-	p.wd = FRAME_X_LEFT_FRINGE_WIDTH (f);
+int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-p.x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
+				   ? LEFT_MARGIN_AREA
-	     - p.wd
+				   : TEXT_AREA));
-	     - (FRAME_X_LEFT_FRINGE_WIDTH (f) - p.wd) / 2);
+if (p.wd > wd)
-if (p.wd < FRAME_X_LEFT_FRINGE_WIDTH (f) || row->height > p.h)
+	p.wd = wd;
+p.x = x - p.wd - (wd - p.wd) / 2;
+if (p.wd < wd || row->height > p.h)
 	{
 	  /* If W has a vertical border to its left, don't draw over it.  */
-	  int border = ((XFASTINT (w->left) > 0
+	  wd -= ((!WINDOW_LEFTMOST_P (w)
-			 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+		  && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
-			? 1 : 0);
+		 ? 1 : 0);
-	  p.bx = (window_box_left (w, -1)
+	  p.bx = x - wd;
-		  - FRAME_X_LEFT_FRINGE_WIDTH (f)
+	  p.nx = wd;
-		  + border);
-	  p.nx = (FRAME_X_LEFT_FRINGE_WIDTH (f) - border);
 	}
 }
 else
 {
-if (p.wd > FRAME_X_RIGHT_FRINGE_WIDTH (f))
+int x = window_box_right (w,
-	p.wd = FRAME_X_RIGHT_FRINGE_WIDTH (f);
+				(WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-p.x = (window_box_right (w, -1)
+				 ? RIGHT_MARGIN_AREA
-	     + (FRAME_X_RIGHT_FRINGE_WIDTH (f) - p.wd) / 2);
+				 : TEXT_AREA));
+int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
+if (p.wd > wd)
+	p.wd = wd;
+p.x = x + (wd - p.wd) / 2;
 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
 	 the fringe.  */
-if (p.wd < FRAME_X_RIGHT_FRINGE_WIDTH (f) || row->height > p.h)
+if (p.wd < wd || row->height > p.h)
 	{
-	  p.bx = window_box_right (w, -1);
+	  p.bx = x;
-	  p.nx = FRAME_X_RIGHT_FRINGE_WIDTH (f);
+	  p.nx = wd;
 	}
 }
 if (p.bx >= 0)
 {
-int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
 p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
 p.ny = row->visible_height;
 }
 /* If row is completely invisible, because of vscrolling, we
 don't have to draw anything.  */
 if (row->visible_height <= 0)
 return;
-if (FRAME_X_LEFT_FRINGE_WIDTH (f) != 0)
+if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
 {
 /* Decide which bitmap to draw in the left fringe.  */
 if (row->overlay_arrow_p)
 	bitmap = OVERLAY_ARROW_BITMAP;
 else if (row->truncated_on_left_p)
 	bitmap = NO_FRINGE_BITMAP;
 draw_fringe_bitmap (w, row, bitmap, 1);
 }
-if (FRAME_X_RIGHT_FRINGE_WIDTH (f) != 0)
+if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
 {
 /* Decide which bitmap to draw in the right fringe.  */
 if (row->truncated_on_right_p)
 	bitmap = RIGHT_TRUNCATION_BITMAP;
 else if (row->continued_p)
 	bitmap = CONTINUED_LINE_BITMAP;
-else if (row->indicate_empty_line_p && FRAME_X_LEFT_FRINGE_WIDTH (f) == 0)
+else if (row->indicate_empty_line_p && WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 	bitmap = ZV_LINE_BITMAP;
 else
 	bitmap = NO_FRINGE_BITMAP;
 draw_fringe_bitmap (w, row, bitmap, 0);
 void
 compute_fringe_widths (f, redraw)
 struct frame *f;
 int redraw;
 {
-int o_left = FRAME_X_LEFT_FRINGE_WIDTH (f);
+int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
-int o_right = FRAME_X_RIGHT_FRINGE_WIDTH (f);
+int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
-int o_cols = FRAME_X_FRINGE_COLS (f);
+int o_cols = FRAME_FRINGE_COLS (f);
 Lisp_Object left_fringe = Fassq (Qleft_fringe, f->param_alist);
 Lisp_Object right_fringe = Fassq (Qright_fringe, f->param_alist);
 int left_fringe_width, right_fringe_width;
 if (left_fringe_width || right_fringe_width)
 {
 int left_wid = left_fringe_width >= 0 ? left_fringe_width : -left_fringe_width;
 int right_wid = right_fringe_width >= 0 ? right_fringe_width : -right_fringe_width;
 int conf_wid = left_wid + right_wid;
-int font_wid = FONT_WIDTH (FRAME_FONT (f));
+int font_wid = FRAME_COLUMN_WIDTH (f);
 int cols = (left_wid + right_wid + font_wid-1) / font_wid;
 int real_wid = cols * font_wid;
 if (left_wid && right_wid)
 	{
 	  if (left_fringe_width < 0)
 	    {
 	      /* Left fringe width is fixed, adjust right fringe if necessary */
-	      FRAME_X_LEFT_FRINGE_WIDTH (f) = left_wid;
+	      FRAME_LEFT_FRINGE_WIDTH (f) = left_wid;
-	      FRAME_X_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
+	      FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
 	    }
 	  else if (right_fringe_width < 0)
 	    {
 	      /* Right fringe width is fixed, adjust left fringe if necessary */
-	      FRAME_X_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
+	      FRAME_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
-	      FRAME_X_RIGHT_FRINGE_WIDTH (f) = right_wid;
+	      FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid;
 	    }
 	  else
 	    {
 	      /* Adjust both fringes with an equal amount.
 		 Note that we are doing integer arithmetic here, so don't
 		 lose a pixel if the total width is an odd number.  */
 	      int fill = real_wid - conf_wid;
-	      FRAME_X_LEFT_FRINGE_WIDTH (f) = left_wid + fill/2;
+	      FRAME_LEFT_FRINGE_WIDTH (f) = left_wid + fill/2;
-	      FRAME_X_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
+	      FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
 	    }
 	}
 else if (left_fringe_width)
 	{
-	  FRAME_X_LEFT_FRINGE_WIDTH (f) = real_wid;
+	  FRAME_LEFT_FRINGE_WIDTH (f) = real_wid;
-	  FRAME_X_RIGHT_FRINGE_WIDTH (f) = 0;
+	  FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
 	}
 else
 	{
-	  FRAME_X_LEFT_FRINGE_WIDTH (f) = 0;
+	  FRAME_LEFT_FRINGE_WIDTH (f) = 0;
-	  FRAME_X_RIGHT_FRINGE_WIDTH (f) = real_wid;
+	  FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
 	}
-FRAME_X_FRINGE_COLS (f) = cols;
+FRAME_FRINGE_COLS (f) = cols;
-FRAME_X_FRINGE_WIDTH (f) = real_wid;
 }
 else
 {
-FRAME_X_LEFT_FRINGE_WIDTH (f) = 0;
+FRAME_LEFT_FRINGE_WIDTH (f) = 0;
-FRAME_X_RIGHT_FRINGE_WIDTH (f) = 0;
+FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
-FRAME_X_FRINGE_COLS (f) = 0;
+FRAME_FRINGE_COLS (f) = 0;
-FRAME_X_FRINGE_WIDTH (f) = 0;
 }
 if (redraw && FRAME_VISIBLE_P (f))
-if (o_left != FRAME_X_LEFT_FRINGE_WIDTH (f) ||
+if (o_left != FRAME_LEFT_FRINGE_WIDTH (f) ||
-	o_right != FRAME_X_RIGHT_FRINGE_WIDTH (f) ||
+	o_right != FRAME_RIGHT_FRINGE_WIDTH (f) ||
-	o_cols != FRAME_X_FRINGE_COLS (f))
+	o_cols != FRAME_FRINGE_COLS (f))
 redraw_frame (f);
 }
 #endif /* HAVE_WINDOW_SYSTEM */
 	hscrolled_p |= hscroll_window_tree (w->hchild);
 else if (WINDOWP (w->vchild))
 	hscrolled_p |= hscroll_window_tree (w->vchild);
 else if (w->cursor.vpos >= 0)
 	{
-	  int h_margin, text_area_x, text_area_y;
+	  int h_margin;
-	  int text_area_width, text_area_height;
+	  int text_area_width;
 	  struct glyph_row *current_cursor_row
 	    = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 	  struct glyph_row *desired_cursor_row
 	    = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
 	  struct glyph_row *cursor_row
 	    = (desired_cursor_row->enabled_p
 	       ? desired_cursor_row
 	       : current_cursor_row);
-	  window_box (w, TEXT_AREA, &text_area_x, &text_area_y,
+	  text_area_width = window_box_width (w, TEXT_AREA);
-		      &text_area_width, &text_area_height);
 	  /* Scroll when cursor is inside this scroll margin.  */
-	  h_margin = hscroll_margin * CANON_X_UNIT (XFRAME (w->frame));
+	  h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
 	  if ((XFASTINT (w->hscroll)
 	       && w->cursor.x <= h_margin)
 	      || (cursor_row->enabled_p
 		  && cursor_row->truncated_on_right_p
 	      current_buffer = saved_current_buffer;
 	      /* Position cursor in window.  */
 	      if (!hscroll_relative_p && hscroll_step_abs == 0)
 		hscroll = max (0, it.current_x - text_area_width / 2)
-		    	  / CANON_X_UNIT (it.f);
+		    	  / FRAME_COLUMN_WIDTH (it.f);
 	      else if (w->cursor.x >= text_area_width - h_margin)
 		{
 		  if (hscroll_relative_p)
 		    wanted_x = text_area_width * (1 - hscroll_step_rel)
 		      	       - h_margin;
 		  else
 		    wanted_x = text_area_width
-		      	       - hscroll_step_abs * CANON_X_UNIT (it.f)
+		      	       - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 		      	       - h_margin;
 		  hscroll
-		    = max (0, it.current_x - wanted_x) / CANON_X_UNIT (it.f);
+		    = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 		}
 	      else
 		{
 		  if (hscroll_relative_p)
 		    wanted_x = text_area_width * hscroll_step_rel
 		      	       + h_margin;
 		  else
-		    wanted_x = hscroll_step_abs * CANON_X_UNIT (it.f)
+		    wanted_x = hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 		      	       + h_margin;
 		  hscroll
-		    = max (0, it.current_x - wanted_x) / CANON_X_UNIT (it.f);
+		    = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 		}
 	      hscroll = max (hscroll, XFASTINT (w->min_hscroll));
 	      /* Don't call Fset_window_hscroll if value hasn't
 		 changed because it will prevent redisplay
 else if (/* Cursor position hasn't changed.  */
 	       PT == XFASTINT (w->last_point)
 	       /* Make sure the cursor was last displayed
 		  in this window.  Otherwise we have to reposition it.  */
 	       && 0 <= w->cursor.vpos
-	       && XINT (w->height) > w->cursor.vpos)
+	       && WINDOW_TOTAL_LINES (w) > w->cursor.vpos)
 	{
 	  if (!must_finish)
 	    {
 	      do_pending_window_change (1);
 if (accurate_p)
 {
 w->window_end_valid = w->buffer;
 #if 0 /* This is incorrect with variable-height lines.  */
 xassert (XINT (w->window_end_vpos)
-	       < (XINT (w->height)
+	       < (WINDOW_TOTAL_LINES (w)
 		  - (WINDOW_WANTS_MODELINE_P (w) ? 1 : 0)));
 #endif
 w->update_mode_line = Qnil;
 }
 }
 /* Compute scroll margin height in pixels.  We scroll when point is
 within this distance from the top or bottom of the window.  */
 if (scroll_margin > 0)
 {
-this_scroll_margin = min (scroll_margin, XINT (w->height) / 4);
+this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
-this_scroll_margin *= CANON_Y_UNIT (f);
+this_scroll_margin *= FRAME_LINE_HEIGHT (f);
 }
 else
 this_scroll_margin = 0;
 /* Compute how much we should try to scroll maximally to bring point
 but no scroll_step is set.  Choose an arbitrary one.  Maybe
 there should be a variable for this.  */
 scroll_max = 10;
 else
 scroll_max = 0;
-scroll_max *= CANON_Y_UNIT (f);
+scroll_max *= FRAME_LINE_HEIGHT (f);
 /* Decide whether we have to scroll down.  Start at the window end
 and move this_scroll_margin up to find the position of the scroll
 margin.  */
 window_end = Fwindow_end (window, Qt);
 if (scroll_conservatively)
 	/* Set AMOUNT_TO_SCROLL to at least one line,
 	   and at most scroll_conservatively lines.  */
 	amount_to_scroll
-	  = min (max (dy, CANON_Y_UNIT (f)),
+	  = min (max (dy, FRAME_LINE_HEIGHT (f)),
-		 CANON_Y_UNIT (f) * scroll_conservatively);
+		 FRAME_LINE_HEIGHT (f) * scroll_conservatively);
 else if (scroll_step || temp_scroll_step)
 	amount_to_scroll = scroll_max;
 else
 	{
 	  aggressive = current_buffer->scroll_up_aggressively;
-	  height = (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w)
+	  height = WINDOW_BOX_TEXT_HEIGHT (w);
-		    - WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w));
 	  if (NUMBERP (aggressive))
 	    amount_to_scroll = XFLOATINT (aggressive) * height;
 	}
 if (amount_to_scroll <= 0)
 	  /* Compute new window start.  */
 	  start_display (&it, w, startp);
 	  if (scroll_conservatively)
 	    amount_to_scroll =
-	      max (dy, CANON_Y_UNIT (f) * max (scroll_step, temp_scroll_step));
+	      max (dy, FRAME_LINE_HEIGHT (f) * max (scroll_step, temp_scroll_step));
 	  else if (scroll_step || temp_scroll_step)
 	    amount_to_scroll = scroll_max;
 	  else
 	    {
 	      aggressive = current_buffer->scroll_down_aggressively;
-	      height = (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w)
+	      height = WINDOW_BOX_TEXT_HEIGHT (w);
-			- WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w));
 	      if (NUMBERP (aggressive))
 		amount_to_scroll = XFLOATINT (aggressive) * height;
 	    }
 	  if (amount_to_scroll <= 0)
 reseat_at_previous_visible_line_start (&it);
 /* If the line start is "too far" away from the window start,
 say it takes too much time to compute a new window start.  */
 if (CHARPOS (start_pos) - IT_CHARPOS (it)
-	  < XFASTINT (w->height) * XFASTINT (w->width))
+	  < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w))
 	{
 	  int min_distance, distance;
 	  /* Move forward by display lines to find the new window
 	     start.  If window width was enlarged, the new start can
 #endif
 /* Scroll if point within this distance from the top or bottom
 	 of the window.  This is a pixel value.  */
 this_scroll_margin = max (0, scroll_margin);
-this_scroll_margin = min (this_scroll_margin, XFASTINT (w->height) / 4);
+this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
-this_scroll_margin *= CANON_Y_UNIT (f);
+this_scroll_margin *= FRAME_LINE_HEIGHT (f);
 /* Start with the row the cursor was displayed during the last
 	 not paused redisplay.  Give up if that row is not valid.  */
 if (w->last_cursor.vpos < 0
 	  || w->last_cursor.vpos >= w->current_matrix->nrows)
 because the loop in redisplay_internal expects that.  */
 need_larger_matrices:
 ;
 finish_scroll_bars:
-if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
 {
 /* Set the thumb's position and size.  */
 set_vertical_scroll_bar (w);
 /* Note that we actually used the scroll bar attached to this
 	  /* Disable lines that must be updated.  */
 	  for (i = 0; i < it.vpos; ++i)
 	    (start_row + i)->enabled_p = 0;
 	  /* Re-compute Y positions.  */
-	  min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+	  min_y = WINDOW_HEADER_LINE_HEIGHT (w);
 	  max_y = it.last_visible_y;
 	  for (row = start_row + nrows_scrolled;
 	       row < bottom_row;
 	       ++row)
 	    {
 nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
 			- start_vpos);
 it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
 		 - nrows_scrolled);
 it.current_y = (first_row_to_display->y - first_reusable_row->y
-		      + WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w));
+		      + WINDOW_HEADER_LINE_HEIGHT (w));
 /* Display lines beginning with first_row_to_display in the
 desired matrix.  Set last_text_row to the last row displayed
 that displays text.  */
 it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
 	  w->cursor.y -= first_reusable_row->y;
 	}
 /* Scroll the display.  */
 run.current_y = first_reusable_row->y;
-run.desired_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+run.desired_y = WINDOW_HEADER_LINE_HEIGHT (w);
 run.height = it.last_visible_y - run.current_y;
 dy = run.current_y - run.desired_y;
 if (run.height)
 	{
 	  update_end (f);
 	}
 /* Adjust Y positions of reused rows.  */
 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
-min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+min_y = WINDOW_HEADER_LINE_HEIGHT (w);
 max_y = it.last_visible_y;
 for (row = first_reusable_row; row < first_row_to_display; ++row)
 	{
 	  row->y -= dy;
 	  row->visible_height = row->height;
 have, by definition, to be the same as glyph pointers in the
 corresponding frame matrix.  Note that frame matrices have no
 marginal areas (see build_frame_matrix).  */
 window_row = w->current_matrix->rows;
 window_row_end = window_row + w->current_matrix->nrows;
-frame_row = f->current_matrix->rows + XFASTINT (w->top);
+frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
 while (window_row < window_row_end)
 {
 struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
 struct glyph *end = window_row->glyphs[LAST_AREA];
 /* Don't let the cursor end in the scroll margins.  */
 {
 int this_scroll_margin, cursor_height;
 this_scroll_margin = max (0, scroll_margin);
-this_scroll_margin = min (this_scroll_margin,
+this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
-			      XFASTINT (w->height) / 4);
+this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
-this_scroll_margin *= CANON_Y_UNIT (it.f);
 cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
 if ((w->cursor.y < this_scroll_margin
 	 && CHARPOS (start) > BEGV)
 	/* Don't take scroll margin into account at the bottom because
 	{
 	  /* Terminal frame.  In this case, dvpos gives the number of
 	     lines to scroll by; dvpos < 0 means scroll up.  */
 	  int first_unchanged_at_end_vpos
 	    = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
-	  int from = XFASTINT (w->top) + first_unchanged_at_end_vpos;
+	  int from = WINDOW_TOP_EDGE_LINE (w) + first_unchanged_at_end_vpos;
-	  int end = (XFASTINT (w->top)
+	  int end = (WINDOW_TOP_EDGE_LINE (w)
 		     + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0)
 		     + window_internal_height (w));
 	  /* Perform the operation on the screen.  */
 	  if (dvpos > 0)
 	 place the cursor on it.  If so, the row's height hasn't been
 	 computed yet.  */
 if (row->height == 0)
 	{
 	  if (it->max_ascent + it->max_descent == 0)
-	    it->max_descent = it->max_phys_descent = CANON_Y_UNIT (it->f);
+	    it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
 	  row->ascent = it->max_ascent;
 	  row->height = it->max_ascent + it->max_descent;
 	  row->phys_ascent = it->max_phys_ascent;
 	  row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 	}
 	}
 /* Compute how much of the line is visible.  */
 row->visible_height = row->height;
-min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (it->w);
+min_y = WINDOW_HEADER_LINE_HEIGHT (it->w);
-max_y = WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (it->w);
+max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
 if (row->y < min_y)
 	row->visible_height -= min_y - row->y;
 if (row->y + row->height > max_y)
 	row->visible_height -= row->y + row->height - max_y;
 #ifdef USE_X_TOOLKIT
 xassert (!FRAME_WINDOW_P (f));
 init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
 it.first_visible_x = 0;
-it.last_visible_x = FRAME_WINDOW_WIDTH (f) * CANON_X_UNIT (f);
+it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
 #else /* not USE_X_TOOLKIT */
 if (FRAME_WINDOW_P (f))
 {
 /* Menu bar lines are displayed in the desired matrix of the
 	 dummy window menu_bar_window.  */
 xassert (WINDOWP (f->menu_bar_window));
 menu_w = XWINDOW (f->menu_bar_window);
 init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
 		     MENU_FACE_ID);
 it.first_visible_x = 0;
-it.last_visible_x = FRAME_WINDOW_WIDTH (f) * CANON_X_UNIT (f);
+it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
 }
 else
 {
 /* This is a TTY frame, i.e. character hpos/vpos are used as
 	 pixel x/y.  */
 init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
 		     MENU_FACE_ID);
 it.first_visible_x = 0;
-it.last_visible_x = FRAME_WIDTH (f);
+it.last_visible_x = FRAME_COLS (f);
 }
 #endif /* not USE_X_TOOLKIT */
 if (! mode_line_inverse_video)
 /* Force the menu-bar to be displayed in the default face.  */
 {
 	int startpos = XMARKER (w->start)->charpos;
 	int startpos_byte = marker_byte_position (w->start);
 	int line, linepos, linepos_byte, topline;
 	int nlines, junk;
-	int height = XFASTINT (w->height);
+	int height = WINDOW_TOTAL_LINES (w);
 	/* If we decided that this buffer isn't suitable for line numbers,
 	   don't forget that too fast.  */
 	if (EQ (w->base_line_pos, w->buffer))
 	  goto no_value;
 end of the drawing area.  */
 if (row->full_width_p)
 {
 /* X is relative to the left edge of W, without scroll bars
 	 or fringes.  */
-int window_left_x = WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f);
+x += WINDOW_LEFT_EDGE_X (w);
+last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
-x += window_left_x;
-area_width = XFASTINT (w->width) * CANON_X_UNIT (f);
-last_x = window_left_x + area_width;
-if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
-	{
-	  int width = FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
-	  if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
-	    last_x += width;
-	  else
-	    x -= width;
-	}
-x += FRAME_INTERNAL_BORDER_WIDTH (f);
-/* ++KFS: W32 and MAC versions had -= in next line (bug??)  */
-last_x += FRAME_INTERNAL_BORDER_WIDTH (f);
 }
 else
 {
-x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, x);
+int area_left = window_box_left (w, area);
+x += area_left;
 area_width = window_box_width (w, area);
-last_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, area_width);
+last_x = area_left + area_width;
 }
 /* Build a doubly-linked list of glyph_string structures between
 head and tail from what we have to draw.  Note that the macro
 BUILD_GLYPH_STRINGS will modify its start parameter.  That's
 && !overlaps_p)
 {
 int x0 = head ? head->x : x;
 int x1 = tail ? tail->x + tail->background_width : x;
-x0 = FRAME_TO_WINDOW_PIXEL_X (w, x0);
+int text_left = window_box_left (w, TEXT_AREA);
-x1 = FRAME_TO_WINDOW_PIXEL_X (w, x1);
+x0 -= text_left;
+x1 -= text_left;
-/* ++KFS: W32 and MAC versions had following test here:
-	 if (!row->full_width_p && XFASTINT (w->left_margin_width) != 0)
+notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
-*/
-if (XFASTINT (w->left_margin_width) != 0)
-	{
-	  int left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
-	  x0 -= left_area_width;
-	  x1 -= left_area_width;
-	}
-notice_overwritten_cursor (w, area, x0, x1,
 				 row->y, MATRIX_ROW_BOTTOM_Y (row));
 }
 /* Value is the x-position up to which drawn, relative to AREA of W.
 This doesn't include parts drawn because of overhangs.  */
-x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
+if (row->full_width_p)
-if (!row->full_width_p)
+x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
-{
+else
-/* ++KFS: W32 and MAC versions only had this test here:
+x_reached -= window_box_left (w, area);
-	 if (area > LEFT_MARGIN_AREA)
-*/
-if (area > LEFT_MARGIN_AREA && XFASTINT (w->left_margin_width) != 0)
-	x_reached -= window_box_width (w, LEFT_MARGIN_AREA);
-if (area > TEXT_AREA)
-	x_reached -= window_box_width (w, TEXT_AREA);
-}
 RELEASE_HDC (hdc, f);
 return x_reached;
 }
 /* Compute the width of the stretch.  */
 if (prop = Fplist_get (plist, QCwidth),
 NUMVAL (prop) > 0)
 /* Absolute width `:width WIDTH' specified and valid.  */
-width = NUMVAL (prop) * CANON_X_UNIT (it->f);
+width = NUMVAL (prop) * FRAME_COLUMN_WIDTH (it->f);
 else if (prop = Fplist_get (plist, QCrelative_width),
 	   NUMVAL (prop) > 0)
 {
 /* Relative width `:relative-width FACTOR' specified and valid.
 	 Compute the width of the characters having the `glyph'
 x_produce_glyphs (&it2);
 width = NUMVAL (prop) * it2.pixel_width;
 }
 else if (prop = Fplist_get (plist, QCalign_to),
 	   NUMVAL (prop) > 0)
-width = NUMVAL (prop) * CANON_X_UNIT (it->f) - it->current_x;
+width = NUMVAL (prop) * FRAME_COLUMN_WIDTH (it->f) - it->current_x;
 else
 /* Nothing specified -> width defaults to canonical char width.  */
-width = CANON_X_UNIT (it->f);
+width = FRAME_COLUMN_WIDTH (it->f);
 /* Compute height.  */
 if (prop = Fplist_get (plist, QCheight),
 NUMVAL (prop) > 0)
-height = NUMVAL (prop) * CANON_Y_UNIT (it->f);
+height = NUMVAL (prop) * FRAME_LINE_HEIGHT (it->f);
 else if (prop = Fplist_get (plist, QCrelative_height),
 	   NUMVAL (prop) > 0)
 height = FONT_HEIGHT (font) * NUMVAL (prop);
 else
 height = FONT_HEIGHT (font);
 	      it->descent += face->box_line_width;
 	    }
 	}
 else if (it->char_to_display == '\t')
 	{
-	  int tab_width = it->tab_width * CANON_X_UNIT (it->f);
+	  int tab_width = it->tab_width * FRAME_COLUMN_WIDTH (it->f);
 	  int x = it->current_x + it->continuation_lines_width;
 	  int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
 	  /* If the distance from the current position to the next tab
 	     stop is less than a canonical character width, use the
 	     tab stop after that.  */
-	  if (next_tab_x - x < CANON_X_UNIT (it->f))
+	  if (next_tab_x - x < FRAME_COLUMN_WIDTH (it->f))
 	    next_tab_x += tab_width;
 	  it->pixel_width = next_tab_x - x;
 	  it->nglyphs = 1;
 	  it->ascent = it->phys_ascent = FONT_BASE (font) + boff;
 	  if (font_not_found_p || !pcm)
 	    {
 	      int charset = CHAR_CHARSET (it->char_to_display);
 	      it->glyph_not_available_p = 1;
-	      it->pixel_width = (FONT_WIDTH (FRAME_FONT (it->f))
+	      it->pixel_width = (FRAME_COLUMN_WIDTH (it->f)
 				 * CHARSET_WIDTH (charset));
 	      it->phys_ascent = FONT_BASE (font) + boff;
 	      it->phys_descent = FONT_DESCENT (font) - boff;
 	    }
 	  else
 xassert (updated_window && updated_row);
 f = XFRAME (w->frame);
 if (updated_row->full_width_p)
-{
+max_x = WINDOW_TOTAL_WIDTH (w);
-max_x = XFASTINT (w->width) * CANON_X_UNIT (f);
-if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
-	  && !w->pseudo_window_p)
-	max_x += FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
-}
 else
 max_x = window_box_width (w, updated_area);
 max_y = window_text_bottom_y (w);
 /* TO_X == 0 means don't do anything.  TO_X < 0 means clear to end
 from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
 to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
 }
 else
 {
-from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
+int area_left = window_box_left (w, updated_area);
-to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
+from_x += area_left;
-}
+to_x += area_left;
+}
-min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+min_y = WINDOW_HEADER_LINE_HEIGHT (w);
 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
 /* Prevent inadvertently clearing to end of the X window.  */
 if (to_x > from_x && to_y > from_y)
 {
 int i, x;
 BLOCK_INPUT;
-if (area == LEFT_MARGIN_AREA)
+x = window_box_left_offset (w, area);
-x = 0;
+if (area == TEXT_AREA)
-else if (area == TEXT_AREA)
+x += row->x;
-x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
-else
-x = (window_box_width (w, LEFT_MARGIN_AREA)
-	 + window_box_width (w, TEXT_AREA));
 for (i = 0; i < row->used[area];)
 {
 if (row->glyphs[area][i].overlaps_vertically_p)
 	{
 /* Maybe clear the display under the cursor.  */
 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
 {
 int x, y;
-int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
 cursor_glyph = get_phys_cursor_glyph (w);
 if (cursor_glyph == NULL)
 	goto mark_cursor_off;
 dpyinfo->mouse_face_deferred_gc = 1;
 return;
 }
 /* Which window is that in?  */
-window = window_from_coordinates (f, x, y, &part, 1);
+window = window_from_coordinates (f, x, y, &part, 0, 0, 1);
 /* If we were displaying active text in another window, clear that.  */
 if (! EQ (window, dpyinfo->mouse_face_window))
 clear_mouse_face (dpyinfo);
 else
 {
 /* Set START_X to the window-relative start position for drawing glyphs of
 	 AREA.  The first glyph of the text area can be partially visible.
 	 The first glyphs of other areas cannot.  */
-if (area == LEFT_MARGIN_AREA)
+start_x = window_box_left_offset (w, area);
-	start_x = 0;
+if (area == TEXT_AREA)
-else if (area == TEXT_AREA)
+	start_x += row->x;
-	start_x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
-else
-	start_x = (window_box_width (w, LEFT_MARGIN_AREA)
-		   + window_box_width (w, TEXT_AREA));
 x = start_x;
 /* Find the first glyph that must be redrawn.  */
 while (first < end
 	     && x + first->pixel_width < r->x)
 x_draw_vertical_border (w)
 struct window *w;
 {
 struct frame *f = XFRAME (WINDOW_FRAME (w));
+/* We could do better, if we knew what type of scroll-bar the adjacent
+windows (on either side) have...  But we don't :-(
+However, I think this works ok.  ++KFS 2003-04-25 */
 /* Redraw borders between horizontally adjacent windows.  Don't
 do it for frames with vertical scroll bars because either the
 right scroll bar of a window, or the left scroll bar of its
 neighbor will suffice as a border.  */
 if (!WINDOW_RIGHTMOST_P (w)
-&& !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+&& !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
 {
 int x0, x1, y0, y1;
 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
-x1 += FRAME_X_RIGHT_FRINGE_WIDTH (f);
 y1 -= 1;
 rif->draw_vertical_window_border (w, x1, y0, y1);
+}
+else if (!WINDOW_LEFTMOST_P (w)
+	   && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
+{
+int x0, x1, y0, y1;
+window_box_edges (w, -1, &x0, &y0, &x1, &y1);
+y1 -= 1;
+rif->draw_vertical_window_border (w, x0, y0, y1);
 }
 }
 /* Redraw the part of window W intersection rectangle FR.  Pixel
 SET_FRAME_GARBAGED (f);
 return 0;
 }
 /* Frame-relative pixel rectangle of W.  */
-wr.x = XFASTINT (w->left) * CANON_X_UNIT (f);
+wr.x = WINDOW_LEFT_EDGE_X (w);
-wr.y = XFASTINT (w->top) * CANON_Y_UNIT (f);
+wr.y = WINDOW_TOP_EDGE_Y (w);
-wr.width = XFASTINT (w->width) * CANON_X_UNIT (f);
+wr.width = WINDOW_TOTAL_WIDTH (w);
-wr.height = XFASTINT (w->height) * CANON_Y_UNIT (f);
+wr.height = WINDOW_TOTAL_HEIGHT (w);
 if (x_intersect_rectangles (fr, &wr, &r))
 {
 int yb = window_text_bottom_y (w);
 struct glyph_row *row;
 }
 if (w == 0 || h == 0)
 {
 r.x = r.y = 0;
-r.width = CANON_X_UNIT (f) * f->width;
+r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f);
-r.height = CANON_Y_UNIT (f) * f->height;
+r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f);
 }
 else
 {
 r.x = x;
 r.y = y;
 if (!noninteractive)
 {
 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
 int i;
-XWINDOW (root_window)->top = make_number (FRAME_TOP_MARGIN (f));
+XWINDOW (root_window)->top_line = make_number (FRAME_TOP_MARGIN (f));
 set_window_height (root_window,
-			 FRAME_HEIGHT (f) - 1 - FRAME_TOP_MARGIN (f),
+			 FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f),
 			 0);
-mini_w->top = make_number (FRAME_HEIGHT (f) - 1);
+mini_w->top_line = make_number (FRAME_LINES (f) - 1);
 set_window_height (minibuf_window, 1, 0);
-XWINDOW (root_window)->width = make_number (FRAME_WIDTH (f));
+XWINDOW (root_window)->total_cols = make_number (FRAME_COLS (f));
-mini_w->width = make_number (FRAME_WIDTH (f));
+mini_w->total_cols = make_number (FRAME_COLS (f));
 scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
 scratch_glyph_row.glyphs[TEXT_AREA + 1]
 	= scratch_glyphs + MAX_SCRATCH_GLYPHS;

Mercurial > emacs

comparison src/xdisp.c @ 51209:880539128b51