Mercurial > emacs

--- a/src/xdisp.c	Sat May 24 22:08:20 2003 +0000
+++ b/src/xdisp.c	Sat May 24 22:08:54 2003 +0000
@@ -424,8 +424,8 @@

 /* 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
-   there is really a fixed pixel height scroll margin.  */
+   pixel value by multiplying it with FRAME_LINE_HEIGHT, which means
+   that there is really a fixed pixel height scroll margin.  */

 EMACS_INT scroll_margin;

@@ -913,14 +913,13 @@
      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.  */
@@ -930,29 +929,36 @@
      struct window *w;
      int area;
 {
-  struct frame *f = XFRAME (w->frame);
-  int width = XFASTINT (w->width);
+  int cols = XFASTINT (w->total_cols);
+  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))
-	    width -= XFASTINT (w->left_margin_width);
-	  if (INTEGERP (w->right_margin_width))
-	    width -= XFASTINT (w->right_margin_width);
+	  if (INTEGERP (w->left_margin_cols))
+	    cols -= XFASTINT (w->left_margin_cols);
+	  if (INTEGERP (w->right_margin_cols))
+	    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);
-    }
-
-  return width * CANON_X_UNIT (f);
+	{
+	  cols = (INTEGERP (w->right_margin_cols)
+		   ? XFASTINT (w->right_margin_cols) : 0);
+	  pixels = 0;
+	}
+    }
+
+  return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
 }


@@ -964,7 +970,7 @@
      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);

@@ -1003,6 +1009,51 @@
   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
@@ -1014,19 +1065,13 @@
      int area;
 {
   struct frame *f = XFRAME (w->frame);
-  int x = FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
-
-  if (!w->pseudo_window_p)
-    {
-      x += (WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f)
-	    + FRAME_LEFT_FRINGE_WIDTH (f));
-
-      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));
-    }
+  int x;
+
+  if (w->pseudo_window_p)
+    return FRAME_INTERNAL_BORDER_WIDTH (f);
+
+  x = (WINDOW_LEFT_EDGE_X (w)
+       + window_box_left_offset (w, area));

   return x;
 }
@@ -1044,7 +1089,6 @@
   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
@@ -1058,15 +1102,18 @@
      int area;
      int *box_x, *box_y, *box_width, *box_height;
 {
-  struct frame *f = XFRAME (w->frame);
-
-  *box_width = window_box_width (w, area);
-  *box_height = window_box_height (w);
-  *box_x = window_box_left (w, area);
-  *box_y = (FRAME_INTERNAL_BORDER_WIDTH_SAFE (f)
-	    + XFASTINT (w->top) * CANON_Y_UNIT (f));
-  if (WINDOW_WANTS_HEADER_LINE_P (w))
-    *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
+  if (box_width)
+    *box_width = window_box_width (w, area);
+  if (box_height)
+    *box_height = window_box_height (w);
+  if (box_x)
+    *box_x = window_box_left (w, area);
+  if (box_y)
+    {
+      *box_y = WINDOW_TOP_EDGE_Y (w);
+      if (WINDOW_WANTS_HEADER_LINE_P (w))
+	*box_y += CURRENT_HEADER_LINE_HEIGHT (w);
+    }
 }


@@ -1184,7 +1231,7 @@
     {
       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;
@@ -1421,34 +1468,34 @@
 #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_x = PIXEL_TO_CHAR_COL (f, pix_x);
-      pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
+	pix_y -= FRAME_LINE_HEIGHT (f) - 1;
+
+      pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
+      pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);

       if (bounds)
 	STORE_NATIVE_RECT (*bounds,
-			   CHAR_TO_PIXEL_COL (f, pix_x),
-			   CHAR_TO_PIXEL_ROW (f, pix_y),
-			   FONT_WIDTH  (FRAME_FONT (f)) - 1,
-			   FRAME_X_OUTPUT (f)->line_height - 1);
+			   FRAME_COL_TO_PIXEL_X (f, pix_x),
+			   FRAME_LINE_TO_PIXEL_Y (f, pix_y),
+			   FRAME_COLUMN_WIDTH (f) - 1,
+			   FRAME_LINE_HEIGHT (f) - 1);

       if (!noclip)
 	{
 	  if (pix_x < 0)
 	    pix_x = 0;
-	  else if (pix_x > FRAME_WINDOW_WIDTH (f))
-	    pix_x = FRAME_WINDOW_WIDTH (f);
+	  else if (pix_x > FRAME_TOTAL_COLS (f))
+	    pix_x = FRAME_TOTAL_COLS (f);

 	  if (pix_y < 0)
 	    pix_y = 0;
-	  else if (pix_y > f->height)
-	    pix_y = f->height;
+	  else if (pix_y > FRAME_LINES (f))
+	    pix_y = FRAME_LINES (f);
 	}
     }
 #endif
@@ -1530,7 +1577,7 @@
 {
   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)
@@ -1557,21 +1604,20 @@
     }
   else
     {
-      left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
-      if (x < left_area_width)
+      if (x < window_box_left_offset (w, TEXT_AREA))
 	{
 	  *area = LEFT_MARGIN_AREA;
-	  x0 = 0;
-	}
-      else if (x < left_area_width + window_box_width (w, TEXT_AREA))
+	  x0 = window_box_left_offset (w, LEFT_MARGIN_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);
 	}
     }

@@ -1614,12 +1660,12 @@
       /* 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);
     }
 }
@@ -1636,20 +1682,9 @@

   if (s->row->full_width_p)
     {
-      /* Draw full-width.  X coordinates are relative to S->w->left.  */
-      int canon_x = CANON_X_UNIT (s->f);
-
-      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);
+      /* Draw full-width.  X coordinates are relative to S->w->left_col.  */
+      r.x = WINDOW_LEFT_EDGE_X (s->w);
+      r.width = WINDOW_TOTAL_WIDTH (s->w);

       /* Unless displaying a mode or menu bar line, which are always
 	 fully visible, clip to the visible part of the row.  */
@@ -1661,7 +1696,7 @@
   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;
     }
@@ -1671,7 +1706,7 @@
      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
@@ -1681,7 +1716,7 @@
 	 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);

@@ -2087,12 +2122,12 @@
     {
       /* 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));

@@ -2109,7 +2144,7 @@
 	}

       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.  */
@@ -5796,7 +5831,7 @@
   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)
@@ -7107,9 +7142,9 @@
     {
       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;

@@ -7123,7 +7158,7 @@

       /* 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
@@ -7164,45 +7199,45 @@
 	{
 	  /* Let it grow only, until we display an empty message, in which
 	     case the window shrinks again.  */
-	  if (height > XFASTINT (w->height))
-	    {
-	      int old_height = XFASTINT (w->height);
+	  if (height > WINDOW_TOTAL_LINES (w))
+	    {
+	      int old_height = WINDOW_TOTAL_LINES (w);
 	      freeze_window_starts (f, 1);
-	      grow_mini_window (w, height - XFASTINT (w->height));
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
-	    }
-	  else if (height < XFASTINT (w->height)
+	      grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_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))
-	    {
-	      int old_height = XFASTINT (w->height);
+	  if (height > WINDOW_TOTAL_LINES (w))
+	    {
+	      int old_height = WINDOW_TOTAL_LINES (w);
 	      freeze_window_starts (f, 1);
-	      grow_mini_window (w, height - XFASTINT (w->height));
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
-	    }
-	  else if (height < XFASTINT (w->height))
-	    {
-	      int old_height = XFASTINT (w->height);
+	      grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
+	    }
+	  else if (height < WINDOW_TOTAL_LINES (w))
+	    {
+	      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));
-		}
-
-	      window_height_changed_p = XFASTINT (w->height) != old_height;
+		  grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
+		}
+
+	      window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 	    }
 	}

@@ -8105,7 +8140,7 @@
   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)
@@ -8438,7 +8473,7 @@
      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))
@@ -8448,7 +8483,7 @@
       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);
 }


@@ -8470,7 +8505,7 @@

   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)
@@ -8508,13 +8543,13 @@
      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.  */
@@ -8541,10 +8576,10 @@

       /* 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,
@@ -8557,11 +8592,11 @@
 	 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);
@@ -8569,7 +8604,7 @@
 				    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;
 	}
     }
@@ -8782,7 +8817,7 @@
   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;
@@ -8909,41 +8944,46 @@
   p.bx = -1;
   if (left_p)
     {
-      if (p.wd > FRAME_X_LEFT_FRINGE_WIDTH (f))
-	p.wd = FRAME_X_LEFT_FRINGE_WIDTH (f);
-      p.x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
-	     - p.wd
-	     - (FRAME_X_LEFT_FRINGE_WIDTH (f) - p.wd) / 2);
-      if (p.wd < FRAME_X_LEFT_FRINGE_WIDTH (f) || row->height > p.h)
+      int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
+      int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+				   ? LEFT_MARGIN_AREA
+				   : TEXT_AREA));
+      if (p.wd > wd)
+	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
-			 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
-			? 1 : 0);
-	  p.bx = (window_box_left (w, -1)
-		  - FRAME_X_LEFT_FRINGE_WIDTH (f)
-		  + border);
-	  p.nx = (FRAME_X_LEFT_FRINGE_WIDTH (f) - border);
-	}
-    }
-  else
-    {
-      if (p.wd > FRAME_X_RIGHT_FRINGE_WIDTH (f))
-	p.wd = FRAME_X_RIGHT_FRINGE_WIDTH (f);
-      p.x = (window_box_right (w, -1)
-	     + (FRAME_X_RIGHT_FRINGE_WIDTH (f) - p.wd) / 2);
+	  wd -= ((!WINDOW_LEFTMOST_P (w)
+		  && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
+		 ? 1 : 0);
+	  p.bx = x - wd;
+	  p.nx = wd;
+	}
+    }
+  else
+    {
+      int x = window_box_right (w,
+				(WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+				 ? RIGHT_MARGIN_AREA
+				 : 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)
-	{
-	  p.bx = window_box_right (w, -1);
-	  p.nx = FRAME_X_RIGHT_FRINGE_WIDTH (f);
+      if (p.wd < wd || row->height > p.h)
+	{
+	  p.bx = x;
+	  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;
@@ -8973,7 +9013,7 @@
   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)
@@ -8990,14 +9030,14 @@
       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;
@@ -9014,9 +9054,9 @@
      struct frame *f;
      int redraw;
 {
-  int o_left = FRAME_X_LEFT_FRINGE_WIDTH (f);
-  int o_right = FRAME_X_RIGHT_FRINGE_WIDTH (f);
-  int o_cols = FRAME_X_FRINGE_COLS (f);
+  int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
+  int o_right = FRAME_RIGHT_FRINGE_WIDTH (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);
@@ -9037,7 +9077,7 @@
       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)
@@ -9045,14 +9085,14 @@
 	  if (left_fringe_width < 0)
 	    {
 	      /* Left fringe width is fixed, adjust right fringe if necessary */
-	      FRAME_X_LEFT_FRINGE_WIDTH (f) = left_wid;
-	      FRAME_X_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
+	      FRAME_LEFT_FRINGE_WIDTH (f) = 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_X_RIGHT_FRINGE_WIDTH (f) = right_wid;
+	      FRAME_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
+	      FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid;
 	    }
 	  else
 	    {
@@ -9060,35 +9100,33 @@
 		 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_X_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
+	      FRAME_LEFT_FRINGE_WIDTH (f) = left_wid + 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_X_RIGHT_FRINGE_WIDTH (f) = 0;
-	}
-      else
-	{
-	  FRAME_X_LEFT_FRINGE_WIDTH (f) = 0;
-	  FRAME_X_RIGHT_FRINGE_WIDTH (f) = real_wid;
-	}
-      FRAME_X_FRINGE_COLS (f) = cols;
-      FRAME_X_FRINGE_WIDTH (f) = real_wid;
-    }
-  else
-    {
-      FRAME_X_LEFT_FRINGE_WIDTH (f) = 0;
-      FRAME_X_RIGHT_FRINGE_WIDTH (f) = 0;
-      FRAME_X_FRINGE_COLS (f) = 0;
-      FRAME_X_FRINGE_WIDTH (f) = 0;
+	  FRAME_LEFT_FRINGE_WIDTH (f) = real_wid;
+	  FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
+	}
+      else
+	{
+	  FRAME_LEFT_FRINGE_WIDTH (f) = 0;
+	  FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
+	}
+      FRAME_FRINGE_COLS (f) = cols;
+    }
+  else
+    {
+      FRAME_LEFT_FRINGE_WIDTH (f) = 0;
+      FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
+      FRAME_FRINGE_COLS (f) = 0;
     }

   if (redraw && FRAME_VISIBLE_P (f))
-    if (o_left != FRAME_X_LEFT_FRINGE_WIDTH (f) ||
-	o_right != FRAME_X_RIGHT_FRINGE_WIDTH (f) ||
-	o_cols != FRAME_X_FRINGE_COLS (f))
+    if (o_left != FRAME_LEFT_FRINGE_WIDTH (f) ||
+	o_right != FRAME_RIGHT_FRINGE_WIDTH (f) ||
+	o_cols != FRAME_FRINGE_COLS (f))
       redraw_frame (f);
 }

@@ -9146,8 +9184,8 @@
 	hscrolled_p |= hscroll_window_tree (w->vchild);
       else if (w->cursor.vpos >= 0)
 	{
-	  int h_margin, text_area_x, text_area_y;
-	  int text_area_width, text_area_height;
+	  int h_margin;
+	  int text_area_width;
 	  struct glyph_row *current_cursor_row
 	    = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 	  struct glyph_row *desired_cursor_row
@@ -9157,11 +9195,10 @@
 	       ? desired_cursor_row
 	       : current_cursor_row);

-	  window_box (w, TEXT_AREA, &text_area_x, &text_area_y,
-		      &text_area_width, &text_area_height);
+	  text_area_width = window_box_width (w, TEXT_AREA);

 	  /* 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)
@@ -9198,7 +9235,7 @@
 	      /* 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)
@@ -9206,10 +9243,10 @@
 		      	       - 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
 		{
@@ -9217,10 +9254,10 @@
 		    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));

@@ -9869,7 +9906,7 @@
 	       /* 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)
 	    {
@@ -10273,7 +10310,7 @@
       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;
@@ -10736,8 +10773,8 @@
      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 *= CANON_Y_UNIT (f);
+      this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
+      this_scroll_margin *= FRAME_LINE_HEIGHT (f);
     }
   else
     this_scroll_margin = 0;
@@ -10755,7 +10792,7 @@
     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
@@ -10806,15 +10843,14 @@
 	/* 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)),
-		 CANON_Y_UNIT (f) * scroll_conservatively);
+	  = min (max (dy, FRAME_LINE_HEIGHT (f)),
+		 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)
-		    - WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w));
+	  height = WINDOW_BOX_TEXT_HEIGHT (w);
 	  if (NUMBERP (aggressive))
 	    amount_to_scroll = XFLOATINT (aggressive) * height;
 	}
@@ -10866,14 +10902,13 @@

 	  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)
-			- WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w));
+	      height = WINDOW_BOX_TEXT_HEIGHT (w);
 	      if (NUMBERP (aggressive))
 		amount_to_scroll = XFLOATINT (aggressive) * height;
 	    }
@@ -10963,7 +10998,7 @@
       /* 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;

@@ -11081,8 +11116,8 @@
       /* 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 *= CANON_Y_UNIT (f);
+      this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
+      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.  */
@@ -11942,7 +11977,7 @@
   ;
  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);
@@ -12177,7 +12212,7 @@
 	    (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;
@@ -12292,7 +12327,7 @@
       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
@@ -12323,7 +12358,7 @@

       /* 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;

@@ -12340,7 +12375,7 @@

       /* 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)
 	{
@@ -12592,7 +12627,7 @@
      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];
@@ -13133,9 +13168,8 @@
     int this_scroll_margin, cursor_height;

     this_scroll_margin = max (0, scroll_margin);
-    this_scroll_margin = min (this_scroll_margin,
-			      XFASTINT (w->height) / 4);
-    this_scroll_margin *= CANON_Y_UNIT (it.f);
+    this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
+    this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
     cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;

     if ((w->cursor.y < this_scroll_margin
@@ -13170,8 +13204,8 @@
 	     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 end = (XFASTINT (w->top)
+	  int from = WINDOW_TOP_EDGE_LINE (w) + first_unchanged_at_end_vpos;
+	  int end = (WINDOW_TOP_EDGE_LINE (w)
 		     + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0)
 		     + window_internal_height (w));

@@ -13861,7 +13895,7 @@
       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;
@@ -13892,8 +13926,8 @@
       /* Compute how much of the line is visible.  */
       row->visible_height = row->height;

-      min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (it->w);
-      max_y = WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (it->w);
+      min_y = WINDOW_HEADER_LINE_HEIGHT (it->w);
+      max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);

       if (row->y < min_y)
 	row->visible_height -= min_y - row->y;
@@ -14649,7 +14683,7 @@
   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))
     {
@@ -14661,7 +14695,7 @@
       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
     {
@@ -14670,7 +14704,7 @@
       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 */

@@ -15742,7 +15776,7 @@
 	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.  */
@@ -17268,30 +17302,15 @@
     {
       /* 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_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);
+      x += WINDOW_LEFT_EDGE_X (w);
+      last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
+    }
+  else
+    {
+      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
@@ -17396,38 +17415,20 @@
       int x0 = head ? head->x : x;
       int x1 = tail ? tail->x + tail->background_width : x;

-      x0 = FRAME_TO_WINDOW_PIXEL_X (w, x0);
-      x1 = FRAME_TO_WINDOW_PIXEL_X (w, x1);
-
-      /* ++KFS: W32 and MAC versions had following test here:
-	 if (!row->full_width_p && XFASTINT (w->left_margin_width) != 0)
-      */
-
-      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,
+      int text_left = window_box_left (w, TEXT_AREA);
+      x0 -= text_left;
+      x1 -= text_left;
+
+      notice_overwritten_cursor (w, TEXT_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)
-    {
-      /* ++KFS: W32 and MAC versions only had this test here:
-	 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);
-    }
+  if (row->full_width_p)
+    x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
+  else
+    x_reached -= window_box_left (w, area);

   RELEASE_HDC (hdc, f);

@@ -17695,7 +17696,7 @@
   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)
     {
@@ -17722,15 +17723,15 @@
     }
   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);
@@ -17957,14 +17958,14 @@
 	}
       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;
@@ -17999,7 +18000,7 @@
 	      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;
@@ -18455,12 +18456,7 @@
   f = XFRAME (w->frame);

   if (updated_row->full_width_p)
-    {
-      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);
-    }
+    max_x = WINDOW_TOTAL_WIDTH (w);
   else
     max_x = window_box_width (w, updated_area);
   max_y = window_text_bottom_y (w);
@@ -18493,11 +18489,12 @@
     }
   else
     {
-      from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
-      to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
-    }
-
-  min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
+      int area_left = window_box_left (w, updated_area);
+      from_x += area_left;
+      to_x += area_left;
+    }
+
+  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);

@@ -18783,13 +18780,9 @@

   BLOCK_INPUT;

-  if (area == LEFT_MARGIN_AREA)
-    x = 0;
-  else if (area == TEXT_AREA)
-    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));
+  x = window_box_left_offset (w, area);
+  if (area == TEXT_AREA)
+    x += row->x;

   for (i = 0; i < row->used[area];)
     {
@@ -18928,7 +18921,7 @@
   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)
@@ -19594,7 +19587,7 @@
     }

   /* 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))
@@ -20078,13 +20071,9 @@
       /* 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 = 0;
-      else if (area == TEXT_AREA)
-	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));
+      start_x = window_box_left_offset (w, area);
+      if (area == TEXT_AREA)
+	start_x += row->x;
       x = start_x;

       /* Find the first glyph that must be redrawn.  */
@@ -20214,21 +20203,34 @@
 {
   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);
+    }
 }


@@ -20263,10 +20265,10 @@
     }

   /* Frame-relative pixel rectangle of W.  */
-  wr.x = XFASTINT (w->left) * CANON_X_UNIT (f);
-  wr.y = XFASTINT (w->top) * CANON_Y_UNIT (f);
-  wr.width = XFASTINT (w->width) * CANON_X_UNIT (f);
-  wr.height = XFASTINT (w->height) * CANON_Y_UNIT (f);
+  wr.x = WINDOW_LEFT_EDGE_X (w);
+  wr.y = WINDOW_TOP_EDGE_Y (w);
+  wr.width = WINDOW_TOTAL_WIDTH (w);
+  wr.height = WINDOW_TOTAL_HEIGHT (w);

   if (x_intersect_rectangles (fr, &wr, &r))
     {
@@ -20441,8 +20443,8 @@
   if (w == 0 || h == 0)
     {
       r.x = r.y = 0;
-      r.width = CANON_X_UNIT (f) * f->width;
-      r.height = CANON_Y_UNIT (f) * f->height;
+      r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f);
+      r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f);
     }
   else
     {
@@ -21007,15 +21009,15 @@
       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));
-      mini_w->width = make_number (FRAME_WIDTH (f));
+      XWINDOW (root_window)->total_cols = make_number (FRAME_COLS (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]