emacs: src/window.c comparison

comparison src/window.c @ 51207:7e176ef34c10

Make (many) trivial substitutions for renamed and new macros in dispextern.h, frame.h and window.h. (make_window): Initialize new members left_margin_cols, right_margin_cols, left_fringe_width, right_fringe_width, fringes_outside_margins, scroll_bar_width, and vertical_scroll_bar_type. (coordinates_in_window): Adapted to new fringe/margin positions and per-window fringes and scroll-bars. Fix bug related to incorrectly adjusting coordinates by frame's internal_border_width (the effect normally negible since the internal_border_width is typically 0 or 1 pixel, but very noticeable for an internal_border_width of e.g. 25 pixels). Upon successful return (other than ON_NOTHING), the coordinates are now always properly converted to window relative for the given display element. (window_from_coordinates): Add new parameters wx and wy to return the window relative x and y position in the returned window and part. A null arg means, don't return the position. All callers changed. (adjust_window_margins): New function which may reduce the width of the display margins if a window's text area is too small after resizing or splitting windows. (size_window): Fix bug that did not account for display margin widths when checking the minimum width of a window; use adjust_window_margins. (set_window_buffer): Call Fset_window_fringes and Fset_window_scroll_bars to setup per-window elements. Add new arg KEEP_MARGINS_P. Non-nil means to keep window's existing display margin, fringe widths, and scroll bar settings (e.g. after splitting a window or resizing the frame). All callers changed. (Fset_window_buffer): New arg KEEP_MARGINS. All callers changed. (Fsplit_window): Duplicate original window's display margin, fringe, and scroll-bar settings; then call Fset_window_buffer with KEEP_MARGINS non-nil. This fixes a bug which caused a split window to only preserve the display margins in one of the windows. When splitting horisontally, call adjust_window_margins on both windows to ensure that the text area of the new windows is non too narrow. This fixes a bug which could cause emacs to trap if the width of the split window was less than the width of the display margins. (window_box_text_cols): Renamed from window_internal_width. All uses changed. Adapt to per-window fringes and scroll bars. Fix bug that caused vertical separator to be subtracted also on window frames. Fix another bug that did not reduce the returned value by the columns used for display margins. (window_scroll_line_based): Fix bug related to scrolling too much when display margins are present (implicitly fixed by the fix to window_box_text_cols). (scroll_left, scroll_right): Fix bug related to scrolling too far by default when display margins are present (implicitly fixed by the fix to window_box_text_cols). (struct saved_window): Rename members left to left_col, top to top_line, width to total_cols, height to total_lines, orig_top to orig_top_line, orig_height to orig_total_lines. All uses changed. New members left_margin_cols, right_margin_cols, left_fringe_width, right_fringe_width, fringes_outside_margins, scroll_bar_width, and vertical_scroll_bar_type for saving per-window display elements. (Fset_window_configuration): Restore display margins, fringes, and scroll bar settings. This fixes a bug which caused display margins to be discarded when saving and restoring a window configuration. (save_window_save): Save display margins, fringes, and scroll bar settings. This fixes a bug which caused display margins to be discarded when saving and restoring a window configuration. (Fset_window_margins): Do nothing if display margins are not really changed. Otherwise, call adjust_window_margins to ensure the text area doesn't get too narrow. This fixes a bug which could cause emacs to trap if setting display margins wider than the width of the window. (Fset_window_fringes): New defun to allow user to specifically set this window's fringe widths and position vs. display margins. (Fwindow_fringes): New defun to return window's actual fringe settings. (Fset_window_scroll_bars): New defun to allow user to specifically set this window's scroll bar width and position. (Fwindow_scroll_bars): New defun to return window's actual scroll bar settings. (compare_window_configurations): Also compare display margins, fringes, and scroll bar settings. (syms_of_window): Defsubr new defuns for fringe and scroll bars.

author	Kim F. Storm <storm@cua.dk>
date	Sat, 24 May 2003 22:07:51 +0000
parents	12bbef36ecf1
children	c1daf1c22f97

comparison

equal deleted inserted replaced

-:22a5614b558f
+:7e176ef34c10
 Lisp_Object val;
 register struct window *p;
 p = allocate_window ();
 XSETFASTINT (p->sequence_number, ++sequence_number);
-XSETFASTINT (p->left, 0);
+XSETFASTINT (p->left_col, 0);
-XSETFASTINT (p->top, 0);
+XSETFASTINT (p->top_line, 0);
-XSETFASTINT (p->height, 0);
+XSETFASTINT (p->total_lines, 0);
-XSETFASTINT (p->width, 0);
+XSETFASTINT (p->total_cols, 0);
 XSETFASTINT (p->hscroll, 0);
 XSETFASTINT (p->min_hscroll, 0);
-p->orig_top = p->orig_height = Qnil;
+p->orig_top_line = p->orig_total_lines = Qnil;
 p->start = Fmake_marker ();
 p->pointm = Fmake_marker ();
 XSETFASTINT (p->use_time, 0);
 p->frame = Qnil;
 p->display_table = Qnil;
 XSETWINDOW (val, p);
 XSETFASTINT (p->last_point, 0);
 p->frozen_window_start_p = 0;
 p->height_fixed_p = 0;
 p->last_cursor_off_p = p->cursor_off_p = 0;
+p->left_margin_cols = Qnil;
+p->right_margin_cols = Qnil;
+p->left_fringe_width = Qnil;
+p->right_fringe_width = Qnil;
+p->fringes_outside_margins = Qnil;
+p->scroll_bar_width = Qnil;
+p->vertical_scroll_bar_type = Qt;
 Vwindow_list = Qnil;
 return val;
 }
 DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0,
 doc: /* Return the number of lines in WINDOW (including its mode line).  */)
 (window)
 Lisp_Object window;
 {
-return decode_window (window)->height;
+return decode_window (window)->total_lines;
 }
 DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0,
 doc: /* Return the number of display columns in WINDOW.
 This is the width that is usable columns available for text in WINDOW.
 If you want to find out how many columns WINDOW takes up,
 use  (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).  */)
 (window)
 Lisp_Object window;
 {
-return make_number (window_internal_width (decode_window (window)));
+return make_number (window_box_text_cols (decode_window (window)));
 }
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
 doc: /* Return the number of columns by which WINDOW is scrolled from left margin.  */)
 (window)
 (window)
 Lisp_Object window;
 {
 register struct window *w = decode_window (window);
-return Fcons (w->left, Fcons (w->top,
+return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
-Fcons (make_number (WINDOW_RIGHT_EDGE (w)),
+	 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
-		  Fcons (make_number (XFASTINT (w->top)
+	 Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w)),
-				      + XFASTINT (w->height)),
+	 Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w)),
-			 Qnil))));
+		Qnil))));
 }
 /* Test if the character at column *X, row *Y is within window W.
 If it is not, return ON_NOTHING;
 if it is in the window's text area,
 static enum window_part
 coordinates_in_window (w, x, y)
 register struct window *w;
 register int *x, *y;
 {
-/* Let's make this a global enum later, instead of using numbers
-everywhere.  */
 struct frame *f = XFRAME (WINDOW_FRAME (w));
 int left_x, right_x, top_y, bottom_y;
 enum window_part part;
-int ux = CANON_X_UNIT (f);
+int ux = FRAME_COLUMN_WIDTH (f);
-int x0 = XFASTINT (w->left) * ux;
+int x0 = WINDOW_LEFT_EDGE_X (w);
-int x1 = x0 + XFASTINT (w->width) * ux;
+int x1 = WINDOW_RIGHT_EDGE_X (w);
 /* The width of the area where the vertical line can be dragged.
 (Between mode lines for instance.  */
 int grabbable_width = ux;
-int lmargin_width = 0, rmargin_width = 0;
+int lmargin_width, rmargin_width, text_left, text_right;
 if (*x < x0 || *x >= x1)
 return ON_NOTHING;
 /* In what's below, we subtract 1 when computing right_x because we
 want the rightmost pixel, which is given by left_pixel+width-1.  */
 if (w->pseudo_window_p)
 {
 left_x = 0;
-right_x = XFASTINT (w->width) * CANON_X_UNIT (f) - 1;
+right_x = WINDOW_TOTAL_WIDTH (w) - 1;
-top_y = WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
+top_y = WINDOW_TOP_EDGE_Y (w);
-bottom_y = WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w);
+bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
 }
 else
 {
-left_x = (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w)
+left_x = WINDOW_BOX_LEFT_EDGE_X (w);
-		- FRAME_INTERNAL_BORDER_WIDTH_SAFE (f));
+right_x = WINDOW_BOX_RIGHT_EDGE_X (w) - 1;
-right_x = WINDOW_DISPLAY_RIGHT_EDGE_PIXEL_X (w) - 1;
+top_y = WINDOW_TOP_EDGE_Y (w);
-top_y = (WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w)
+bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
-	       - FRAME_INTERNAL_BORDER_WIDTH_SAFE (f));
+}
-bottom_y = WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y (w);
-}
+/* Outside any interesting row?  */
+if (*y < top_y || *y >= bottom_y)
+return ON_NOTHING;
 /* On the mode line or header line?  If it's near the start of
 the mode or header line of window that's has a horizontal
 sibling, say it's on the vertical line.  That's to be able
 to resize windows horizontally in case we're using toolkit
 if (WINDOW_WANTS_MODELINE_P (w)
 && *y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w)
 && *y < bottom_y)
 {
+part = ON_MODE_LINE;
+header_vertical_border_check:
 /* We're somewhere on the mode line.  We consider the place
 	 between mode lines of horizontally adjacent mode lines
 	 as the vertical border.    If scroll bars on the left,
 	 return the right window.  */
-part = ON_MODE_LINE;
+if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
+	  || WINDOW_RIGHTMOST_P (w))
-if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
 	{
-	  if (abs (*x - x0) < grabbable_width)
+	  if (!WINDOW_LEFTMOST_P (w) && abs (*x - x0) < grabbable_width)
-	    part = ON_VERTICAL_BORDER;
+	    return ON_VERTICAL_BORDER;
 	}
-else if (!WINDOW_RIGHTMOST_P (w) && abs (*x - x1) < grabbable_width)
+else
-	part = ON_VERTICAL_BORDER;
+	{
-}
+	  if (abs (*x - x1) < grabbable_width)
-else if (WINDOW_WANTS_HEADER_LINE_P (w)
+	    return ON_VERTICAL_BORDER;
-	   && *y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
+	}
-	   && *y >= top_y)
+return part;
+}
+if (WINDOW_WANTS_HEADER_LINE_P (w)
+&& *y >= top_y
+&& *y < top_y + CURRENT_HEADER_LINE_HEIGHT (w))
 {
 part = ON_HEADER_LINE;
+goto header_vertical_border_check;
-if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
+}
-	{
-	  if (abs (*x - x0) < grabbable_width)
+/* Outside any interesting column?  */
-	    part = ON_VERTICAL_BORDER;
+if (*x < left_x || *x > right_x)
-	}
+return ON_NOTHING;
-else if (!WINDOW_RIGHTMOST_P (w) && abs (*x - x1) < grabbable_width)
-	part = ON_VERTICAL_BORDER;
+lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
-}
+rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
-/* Outside anything interesting?  */
-else if (*y < top_y
+text_left = window_box_left (w, TEXT_AREA);
-	   || *y >= bottom_y
+text_right = text_left + window_box_width (w, TEXT_AREA);
-	   || *x < (left_x
-		    - FRAME_LEFT_FRINGE_WIDTH (f)
+if (FRAME_WINDOW_P (f))
-		    - FRAME_LEFT_SCROLL_BAR_WIDTH (f) * ux)
-	   || *x > (right_x
-		    + FRAME_RIGHT_FRINGE_WIDTH (f)
-		    + FRAME_RIGHT_SCROLL_BAR_WIDTH (f) * ux))
-{
-part = ON_NOTHING;
-}
-else if (FRAME_WINDOW_P (f))
 {
 if (!w->pseudo_window_p
-	  && !FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+	  && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
 	  && !WINDOW_RIGHTMOST_P (w)
-	  && (abs (*x - right_x - FRAME_RIGHT_FRINGE_WIDTH (f)) < grabbable_width))
+	  && (abs (*x - right_x) < grabbable_width))
-	{
+	return ON_VERTICAL_BORDER;
-	  part = ON_VERTICAL_BORDER;
-	}
-else if (*x < left_x || *x > right_x)
-	{
-	  /* Other lines than the mode line don't include fringes and
-	     scroll bars on the left.  */
-	  /* Convert X and Y to window-relative pixel coordinates.  */
-	  *x -= left_x;
-	  *y -= top_y;
-	  part = *x < left_x ? ON_LEFT_FRINGE : ON_RIGHT_FRINGE;
-	}
-else
-	{
-	  lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
-	  rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
-	  /* You can never be on a margin area if its width is zero.  */
-	  if (lmargin_width
-	      && *x <= window_box_right (w, LEFT_MARGIN_AREA))
-	    part = ON_LEFT_MARGIN;
-	  else if (rmargin_width
-		   && *x >= window_box_left (w, RIGHT_MARGIN_AREA))
-	    part = ON_RIGHT_MARGIN;
-	  else
-	    {
-	      part = ON_TEXT;
-	      *x -= left_x;
-	      *y -= top_y;
-	    }
-	}
 }
 else
 {
 /* Need to say "*x > right_x" rather than >=, since on character
 	 terminals, the vertical line's x coordinate is right_x.  */
-if (*x < left_x || *x > right_x)
+if (!w->pseudo_window_p
-	{
+	  && !WINDOW_RIGHTMOST_P (w)
-	  /* Other lines than the mode line don't include fringes and
+	  && *x > right_x - ux)
-	     scroll bars on the left.  */
-	  /* Convert X and Y to window-relative pixel coordinates.  */
-	  *x -= left_x;
-	  *y -= top_y;
-	  part = *x < left_x ? ON_LEFT_FRINGE : ON_RIGHT_FRINGE;
-	}
-/* Here, too, "*x > right_x" is because of character terminals.  */
-else if (!w->pseudo_window_p
-	       && !WINDOW_RIGHTMOST_P (w)
-	       && *x > right_x - ux)
 	{
 	  /* On the border on the right side of the window?  Assume that
 	     this area begins at RIGHT_X minus a canonical char width.  */
-	  part = ON_VERTICAL_BORDER;
+	  return ON_VERTICAL_BORDER;
 	}
-else
+}
-	{
-	  lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
+if (*x < text_left)
-	  rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
+{
-	  /* You can never be on a margin area if its width is zero.
+if (lmargin_width > 0
-	     This is especially important for character terminals.  */
+	  && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-	  if (lmargin_width
+	      ? (*x >= left_x + WINDOW_LEFT_FRINGE_WIDTH (w))
-	      && *x <= window_box_right (w, LEFT_MARGIN_AREA))
+	      : (*x < left_x + lmargin_width)))
-	    part = ON_LEFT_MARGIN;
+	return ON_LEFT_MARGIN;
-	  else if (rmargin_width
-		   && *x >= window_box_left (w, RIGHT_MARGIN_AREA))
+/* Convert X and Y to window-relative pixel coordinates.  */
-	    part = ON_RIGHT_MARGIN;
+*x -= left_x;
-	  else
+*y -= top_y;
-	    {
+return ON_LEFT_FRINGE;
-	      part = ON_TEXT;
+}
-	      /* Convert X and Y to window-relative pixel coordinates.  */
-	      *x -= left_x;
+if (*x >= text_right)
-	      *y -= top_y;
+{
-	    }
+if (rmargin_width > 0
-	}
+	  && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-}
+	      ? (*x < right_x - WINDOW_RIGHT_FRINGE_WIDTH (w))
+	      : (*x >= right_x - rmargin_width)))
-return part;
+	return ON_RIGHT_MARGIN;
+/* Convert X and Y to window-relative pixel coordinates.  */
+*x -= left_x + WINDOW_LEFT_FRINGE_WIDTH (w);
+*y -= top_y;
+return ON_RIGHT_FRINGE;
+}
+/* Everything special ruled out - must be on text area */
+*x -= left_x + WINDOW_LEFT_FRINGE_WIDTH (w);
+*y -= top_y;
+return ON_TEXT;
 }
 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
 Scoordinates_in_window_p, 2, 2, 0,
 CHECK_CONS (coordinates);
 lx = Fcar (coordinates);
 ly = Fcdr (coordinates);
 CHECK_NUMBER_OR_FLOAT (lx);
 CHECK_NUMBER_OR_FLOAT (ly);
-x = PIXEL_X_FROM_CANON_X (f, lx);
+x = FRAME_PIXEL_X_FROM_CANON_X (f, lx);
-y = PIXEL_Y_FROM_CANON_Y (f, ly);
+y = FRAME_PIXEL_Y_FROM_CANON_Y (f, ly);
 switch (coordinates_in_window (w, &x, &y))
 {
 case ON_NOTHING:
 return Qnil;
 case ON_TEXT:
 /* X and Y are now window relative pixel coordinates.  Convert
 	 them to canonical char units before returning them.  */
-return Fcons (CANON_X_FROM_PIXEL_X (f, x),
+return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f, x),
-		    CANON_Y_FROM_PIXEL_Y (f, y));
+		    FRAME_CANON_Y_FROM_PIXEL_Y (f, y));
 case ON_MODE_LINE:
 return Qmode_line;
 case ON_VERTICAL_BORDER:
 return continue_p;
 }
 /* Find the window containing frame-relative pixel position X/Y and
-return it as a Lisp_Object.  If X, Y is on one of the window's
+return it as a Lisp_Object.
-special `window_part' elements, set *PART to the id of that element.
+If X, Y is on one of the window's special `window_part' elements,
+set *PART to the id of that element, and return X and Y converted
+to window relative coordinates in WX and WY.
 If there is no window under X, Y return nil and leave *PART
 unmodified.  TOOL_BAR_P non-zero means detect tool-bar windows.
 This function was previously implemented with a loop cycling over
 windows with Fnext_window, and starting with the frame's selected
 tree of F when this function is called asynchronously from
 note_mouse_highlight.  The original loop didn't terminate in this
 case.  */
 Lisp_Object
-window_from_coordinates (f, x, y, part, tool_bar_p)
+window_from_coordinates (f, x, y, part, wx, wy, tool_bar_p)
 struct frame *f;
 int x, y;
 enum window_part *part;
+int *wx, *wy;
 int tool_bar_p;
 {
 Lisp_Object window;
 struct check_window_data cw;
 enum window_part dummy;
 /* If not found above, see if it's in the tool bar window, if a tool
 bar exists.  */
 if (NILP (window)
 && tool_bar_p
 && WINDOWP (f->tool_bar_window)
-&& XINT (XWINDOW (f->tool_bar_window)->height) > 0
+&& WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0
 && (coordinates_in_window (XWINDOW (f->tool_bar_window), &x, &y)
 	  != ON_NOTHING))
 {
 *part = ON_TEXT;
 window = f->tool_bar_window;
 }
+if (wx) *wx = x;
+if (wy) *wy = y;
 return window;
 }
 DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
 /* Check that arguments are integers or floats.  */
 CHECK_NUMBER_OR_FLOAT (x);
 CHECK_NUMBER_OR_FLOAT (y);
 return window_from_coordinates (f,
-				  PIXEL_X_FROM_CANON_X (f, x),
+				  FRAME_PIXEL_X_FROM_CANON_X (f, x),
-				  PIXEL_Y_FROM_CANON_Y (f, y),
+				  FRAME_PIXEL_Y_FROM_CANON_Y (f, y),
-				  0, 0);
+				  0, 0, 0, 0);
 }
 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
 doc: /* Return current value of point in WINDOW.
 For a nonselected window, this is the value point would have
 root_window for that frame.  */
 if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
 FRAME_ROOT_WINDOW (XFRAME (o->frame)) = replacement;
-p->left = o->left;
+p->left_col = o->left_col;
-p->top = o->top;
+p->top_line = o->top_line;
-p->width = o->width;
+p->total_cols = o->total_cols;
-p->height = o->height;
+p->total_lines = o->total_lines;
 p->desired_matrix = p->current_matrix = 0;
 p->vscroll = 0;
 bzero (&p->cursor, sizeof (p->cursor));
 bzero (&p->last_cursor, sizeof (p->last_cursor));
 bzero (&p->phys_cursor, sizeof (p->phys_cursor));
 p->pseudo_window_p = 0;
 XSETFASTINT (p->window_end_vpos, 0);
 XSETFASTINT (p->window_end_pos, 0);
 p->window_end_valid = Qnil;
 p->frozen_window_start_p = 0;
-p->orig_top = p->orig_height = Qnil;
+p->orig_top_line = p->orig_total_lines = Qnil;
 p->next = tem = o->next;
 if (!NILP (tem))
 XWINDOW (tem)->prev = replacement;
 /* If p gives its space to its next sibling, that sibling needs
 	 to have its top/left side pulled back to where p's is.
 	 set_window_{height,width} will re-position the sibling's
 	 children.  */
 sib = p->next;
-XWINDOW (sib)->top = p->top;
+XWINDOW (sib)->top_line = p->top_line;
-XWINDOW (sib)->left = p->left;
+XWINDOW (sib)->left_col = p->left_col;
 }
 /* Stretch that sibling.  */
 if (!NILP (par->vchild))
 set_window_height (sib,
-		       XFASTINT (XWINDOW (sib)->height) + XFASTINT (p->height),
+		       XFASTINT (XWINDOW (sib)->total_lines) + XFASTINT (p->total_lines),
 		       1);
 if (!NILP (par->hchild))
 set_window_width (sib,
-		      XFASTINT (XWINDOW (sib)->width) + XFASTINT (p->width),
+		      XFASTINT (XWINDOW (sib)->total_cols) + XFASTINT (p->total_cols),
 		      1);
 /* If parent now has only one child,
 put the child into the parent's place.  */
 tem = par->hchild;
 		    /* If we're deleting the buffer displayed in the
 		       only window on the frame, find a new buffer to
 		       display there.  */
 		    Lisp_Object buffer;
 		    buffer = Fother_buffer (obj, Qnil, w->frame);
-		    Fset_window_buffer (window, buffer);
+		    Fset_window_buffer (window, buffer, Qnil);
 		    if (EQ (window, selected_window))
 		      Fset_buffer (w->buffer);
 		  }
 		else
 		  Fdelete_window (window);
 	      if (NILP (best_window))
 		best_window = window;
 	      else
 		{
 		  struct window *b = XWINDOW (best_window);
-		  if (XFASTINT (w->height) * XFASTINT (w->width)
+		  if (XFASTINT (w->total_lines) * XFASTINT (w->total_cols)
-		      > XFASTINT (b->height) * XFASTINT (b->width))
+		      > XFASTINT (b->total_lines) * XFASTINT (b->total_cols))
 		    best_window = window;
 		}
 	    }
 	    break;
 		  }
 		else
 		  {
 		    /* Otherwise show a different buffer in the window.  */
 		    w->dedicated = Qnil;
-		    Fset_window_buffer (window, buffer);
+		    Fset_window_buffer (window, buffer, Qnil);
 		    if (EQ (window, selected_window))
 		      Fset_buffer (w->buffer);
 		  }
 	      }
 	    break;
 else
 CHECK_LIVE_WINDOW (window);
 w = XWINDOW (window);
 startpos = marker_position (w->start);
-top = XFASTINT (w->top) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
+top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
 if (MINI_WINDOW_P (w) && top > 0)
 error ("Can't expand minibuffer to full frame");
 window_loop (DELETE_OTHER_WINDOWS, window, 0, WINDOW_FRAME (w));
 /* Try to minimize scrolling, by setting the window start to the point
 will cause the text at the old window start to be at the same place
 on the frame.  But don't try to do this if the window start is
 outside the visible portion (as might happen when the display is
 not current, due to typeahead).  */
-new_top = XFASTINT (w->top) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
+new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
 if (new_top != top
 && startpos >= BUF_BEGV (XBUFFER (w->buffer))
 && startpos <= BUF_ZV (XBUFFER (w->buffer)))
 {
 struct position pos;
 if (fixed)
 *fixed = fixed_p;
 if (fixed_p)
-size = width_p ? XFASTINT (w->width) : XFASTINT (w->height);
+size = width_p ? XFASTINT (w->total_cols) : XFASTINT (w->total_lines);
 else
 size = window_min_size_1 (w, width_p);
 return size;
+}
+/* Adjust the margins of window W if text area is too small.
+Return 1 if window width is ok after adjustment; 0 if window
+is still too narrow.  */
+static int
+adjust_window_margins (w)
+struct window *w;
+{
+int box_cols = (WINDOW_TOTAL_COLS (w)
+		  - WINDOW_FRINGE_COLS (w)
+		  - WINDOW_SCROLL_BAR_COLS (w));
+int margin_cols = (WINDOW_LEFT_MARGIN_COLS (w)
+		     + WINDOW_RIGHT_MARGIN_COLS (w));
+if (box_cols - margin_cols >= MIN_SAFE_WINDOW_WIDTH)
+return 1;
+if (margin_cols < 0 || box_cols < MIN_SAFE_WINDOW_WIDTH)
+return 0;
+/* Window's text area is too narrow, but reducing the window
+margins will fix that.  */
+margin_cols = box_cols - MIN_SAFE_WINDOW_WIDTH;
+if (WINDOW_RIGHT_MARGIN_COLS (w) > 0)
+{
+if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
+	w->left_margin_cols = w->right_margin_cols
+	  = make_number (margin_cols/2);
+else
+	w->right_margin_cols = make_number (margin_cols);
+}
+else
+w->left_margin_cols = make_number (margin_cols);
+return 1;
 }
 /* Set WINDOW's height or width to SIZE.  WIDTH_P non-zero means set
 WINDOW's width.  Resize WINDOW's children, if any, so that they
 int size, width_p, nodelete_p;
 {
 struct window *w = XWINDOW (window);
 struct window *c;
 Lisp_Object child, *forward, *sideward;
-int old_size, min_size;
+int old_size, min_size, safe_min_size;
+/* We test nodelete_p != 2 and nodelete_p != 1 below, so it
+seems like it's too soon to do this here.  ++KFS.  */
 if (nodelete_p == 2)
 nodelete_p = 0;
 check_min_window_sizes ();
 size = max (0, size);
 /* If the window has been "too small" at one point,
 don't delete it for being "too small" in the future.
 Preserve it as long as that is at all possible.  */
 if (width_p)
 {
-old_size = XINT (w->width);
+old_size = WINDOW_TOTAL_COLS (w);
 min_size = window_min_width;
+/* Ensure that there is room for the scroll bar and fringes!
+We may reduce display margins though.  */
+safe_min_size = (MIN_SAFE_WINDOW_WIDTH
+		       + WINDOW_FRINGE_COLS (w)
+		       + WINDOW_SCROLL_BAR_COLS (w));
 }
 else
 {
-old_size = XINT (w->height);
+old_size = XINT (w->total_lines);
 min_size = window_min_height;
+safe_min_size = MIN_SAFE_WINDOW_HEIGHT;
 }
 if (old_size < min_size && nodelete_p != 2)
 w->too_small_ok = Qt;
 /* Maybe delete WINDOW if it's too small.  */
 if (nodelete_p != 1 && !NILP (w->parent))
 {
 if (!MINI_WINDOW_P (w) && !NILP (w->too_small_ok))
 	min_size = width_p ? MIN_SAFE_WINDOW_WIDTH : MIN_SAFE_WINDOW_HEIGHT;
-else
+if (min_size < safe_min_size)
-	min_size = width_p ? window_min_width : window_min_height;
+	min_size = safe_min_size;
 if (size < min_size)
 	{
 	  delete_window (window);
 	  return;
 	}
 if (width_p)
 {
 sideward = &w->vchild;
 forward = &w->hchild;
-w->width = make_number (size);
+w->total_cols = make_number (size);
+adjust_window_margins (w);
 }
 else
 {
 sideward = &w->hchild;
 forward = &w->vchild;
-w->height = make_number (size);
+w->total_lines = make_number (size);
-w->orig_height = Qnil;
+w->orig_total_lines = Qnil;
 }
 if (!NILP (*sideward))
 {
 for (child = *sideward; !NILP (child); child = c->next)
 	{
 	  c = XWINDOW (child);
 	  if (width_p)
-	    c->left = w->left;
+	    c->left_col = w->left_col;
 	  else
-	    c->top = w->top;
+	    c->top_line = w->top_line;
 	  size_window (child, size, width_p, nodelete_p);
 	}
 }
 else if (!NILP (*forward))
 {
 for (child = *forward; !NILP (child); child = c->next, ++nchildren)
 	{
 	  int child_size;
 	  c = XWINDOW (child);
-	  child_size = width_p ? XINT (c->width) : XINT (c->height);
+	  child_size = width_p ? XINT (c->total_cols) : XINT (c->total_lines);
 	  total += child_size;
 	  if (window_fixed_size_p (c, width_p, 0))
 	    {
 	      fixed_size += child_size;
 n = resize_fixed_p ? nchildren : nchildren - nfixed;
 each = (size - total) / n;
 extra = (size - total) - n * each;
 /* Compute new children heights and edge positions.  */
-first_pos = width_p ? XINT (w->left) : XINT (w->top);
+first_pos = width_p ? XINT (w->left_col) : XINT (w->top_line);
 last_pos = first_pos;
 for (child = *forward; !NILP (child); child = c->next)
 	{
 	  int new_size, old_size;
 	  c = XWINDOW (child);
-	  old_size = width_p ? XFASTINT (c->width) : XFASTINT (c->height);
+	  old_size = width_p ? XFASTINT (c->total_cols) : XFASTINT (c->total_lines);
 	  new_size = old_size;
 	  /* The top or left edge position of this child equals the
 	     bottom or right edge of its predecessor.  */
 	  if (width_p)
-	    c->left = make_number (last_pos);
+	    c->left_col = make_number (last_pos);
 	  else
-	    c->top = make_number (last_pos);
+	    c->top_line = make_number (last_pos);
 	  /* If this child can be resized, do it.  */
 	  if (resize_fixed_p || !window_fixed_size_p (c, width_p, 0))
 	    {
 	      new_size = old_size + each + extra;
 if (!nodelete_p)
 	for (child = *forward; !NILP (child); child = c->next)
 	  {
 	    int child_size;
 	    c = XWINDOW (child);
-	    child_size = width_p ? XINT (c->width) : XINT (c->height);
+	    child_size = width_p ? XINT (c->total_cols) : XINT (c->total_lines);
 	    size_window (child, child_size, width_p, 2);
 	  }
 }
 }
 Lisp_Object window;
 int n;
 {
 struct window *w = XWINDOW (window);
-XSETFASTINT (w->top, XFASTINT (w->top) + n);
+XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
-XSETFASTINT (w->height, XFASTINT (w->height) - n);
+XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
-if (INTEGERP (w->orig_top))
+if (INTEGERP (w->orig_top_line))
-XSETFASTINT (w->orig_top, XFASTINT (w->orig_top) + n);
+XSETFASTINT (w->orig_top_line, XFASTINT (w->orig_top_line) + n);
-if (INTEGERP (w->orig_height))
+if (INTEGERP (w->orig_total_lines))
-XSETFASTINT (w->orig_height, XFASTINT (w->orig_height) - n);
+XSETFASTINT (w->orig_total_lines, XFASTINT (w->orig_total_lines) - n);
 /* Handle just the top child in a vertical split.  */
 if (!NILP (w->vchild))
 change_window_heights (w->vchild, n);
 }
 /* Make WINDOW display BUFFER as its contents.  RUN_HOOKS_P non-zero
 means it's allowed to run hooks.  See make_frame for a case where
-it's not allowed.  */
+it's not allowed.  KEEP_MARGINS_P non-zero means that the current
+margins, fringes, and scroll-bar settings of the window are not
+reset from the buffer's local settings.  */
 void
-set_window_buffer (window, buffer, run_hooks_p)
+set_window_buffer (window, buffer, run_hooks_p, keep_margins_p)
 Lisp_Object window, buffer;
-int run_hooks_p;
+int run_hooks_p, keep_margins_p;
 {
 struct window *w = XWINDOW (window);
 struct buffer *b = XBUFFER (buffer);
 int count = SPECPDL_INDEX ();
 {
 record_unwind_protect (Fset_window_buffer_unwind, Fcurrent_buffer ());
 Fset_buffer (buffer);
 }
-/* Set left and right marginal area width from buffer.  */
+if (!keep_margins_p)
-Fset_window_margins (window, b->left_margin_width, b->right_margin_width);
+{
+/* Set left and right marginal area width etc. from buffer.  */
+/* This may call adjust_window_margins three times, so
+	 temporarily disable window margins.  */
+w->left_margin_cols = w->right_margin_cols = Qnil;
+Fset_window_fringes (window,
+			   b->left_fringe_width, b->right_fringe_width,
+			   b->fringes_outside_margins);
+Fset_window_scroll_bars (window,
+			       b->scroll_bar_width,
+			       b->vertical_scroll_bar_type, Qnil);
+Fset_window_margins (window,
+			   b->left_margin_cols, b->right_margin_cols);
+}
 if (run_hooks_p)
 {
 if (! NILP (Vwindow_scroll_functions))
 	run_hook_with_args_2 (Qwindow_scroll_functions, window,
 unbind_to (count, Qnil);
 }
-DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 2, 0,
+DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
 doc: /* Make WINDOW display BUFFER as its contents.
-BUFFER can be a buffer or buffer name.  */)
+BUFFER can be a buffer or buffer name.
-(window, buffer)
+Optional third arg KEEP_MARGINS non-nil means that WINDOW's current
+display margins, fringe widths, and scroll bar settings are maintained;
+the default is to reset these from BUFFER's local settings or the frame
+defaults.  */)
+(window, buffer, keep_margins)
 register Lisp_Object window, buffer;
 {
 register Lisp_Object tem;
 register struct window *w = decode_window (window);
 	       SDATA (XBUFFER (tem)->name));
 unshow_buffer (w);
 }
-set_window_buffer (window, buffer, 1);
+set_window_buffer (window, buffer, 1, !NILP (keep_margins));
 return Qnil;
 }
 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
 doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
 /* If there are no frames open that have more than a minibuffer,
 we need to create a new frame.  */
 if (pop_up_frames || last_nonminibuf_frame == 0)
 {
 window = Fframe_selected_window (call0 (Vpop_up_frame_function));
-Fset_window_buffer (window, buffer);
+Fset_window_buffer (window, buffer, Qnil);
 return display_buffer_1 (window);
 }
 f = SELECTED_FRAME ();
 if (pop_up_windows
 	  if (!NILP (XWINDOW (window)->next))
 	    other = lower = XWINDOW (window)->next, upper = window;
 	  if (!NILP (other)
 	      && !NILP (Veven_window_heights)
 	      /* Check that OTHER and WINDOW are vertically arrayed.  */
-	      && !EQ (XWINDOW (other)->top, XWINDOW (window)->top)
+	      && !EQ (XWINDOW (other)->top_line, XWINDOW (window)->top_line)
-	      && (XFASTINT (XWINDOW (other)->height)
+	      && (XFASTINT (XWINDOW (other)->total_lines)
-		  > XFASTINT (XWINDOW (window)->height)))
+		  > XFASTINT (XWINDOW (window)->total_lines)))
 	    {
-	      int total = (XFASTINT (XWINDOW (other)->height)
+	      int total = (XFASTINT (XWINDOW (other)->total_lines)
-			   + XFASTINT (XWINDOW (window)->height));
+			   + XFASTINT (XWINDOW (window)->total_lines));
 	      enlarge_window (upper,
-			      total / 2 - XFASTINT (XWINDOW (upper)->height),
+			      total / 2 - XFASTINT (XWINDOW (upper)->total_lines),
 			      0, 0);
 	    }
 	}
 }
 else
 window = Fget_lru_window (Qnil);
-Fset_window_buffer (window, buffer);
+Fset_window_buffer (window, buffer, Qnil);
 return display_buffer_1 (window);
 }
 void
 temp_output_buffer_show (buf)
 if (!NILP (horflag))
 	/* Calculate the size of the left-hand window, by dividing
 	   the usable space in columns by two.
 	   We round up, since the left-hand window may include
 	   a dividing line, while the right-hand may not.  */
-	size_int = (XFASTINT (o->width) + 1) >> 1;
+	size_int = (XFASTINT (o->total_cols) + 1) >> 1;
 else
-	size_int = XFASTINT (o->height) >> 1;
+	size_int = XFASTINT (o->total_lines) >> 1;
 }
 else
 {
 CHECK_NUMBER (size);
 size_int = XINT (size);
 if (NILP (horflag))
 {
 if (size_int < window_min_height)
 	error ("Window height %d too small (after splitting)", size_int);
-if (size_int + window_min_height > XFASTINT (o->height))
+if (size_int + window_min_height > XFASTINT (o->total_lines))
 	error ("Window height %d too small (after splitting)",
-	       XFASTINT (o->height) - size_int);
+	       XFASTINT (o->total_lines) - size_int);
 if (NILP (o->parent)
 	  || NILP (XWINDOW (o->parent)->vchild))
 	{
 	  make_dummy_parent (window);
 	  new = o->parent;
 else
 {
 if (size_int < window_min_width)
 	error ("Window width %d too small (after splitting)", size_int);
-if (size_int + window_min_width > XFASTINT (o->width))
+if (size_int + window_min_width > XFASTINT (o->total_cols))
 	error ("Window width %d too small (after splitting)",
-	       XFASTINT (o->width) - size_int);
+	       XFASTINT (o->total_cols) - size_int);
 if (NILP (o->parent)
 	  || NILP (XWINDOW (o->parent)->hchild))
 	{
 	  make_dummy_parent (window);
 	  new = o->parent;
 p->parent = o->parent;
 p->buffer = Qt;
 p->window_end_valid = Qnil;
 bzero (&p->last_cursor, sizeof p->last_cursor);
+/* Duplicate special geometry settings.  */
+p->left_margin_cols = o->left_margin_cols;
+p->right_margin_cols = o->right_margin_cols;
+p->left_fringe_width = o->left_fringe_width;
+p->right_fringe_width = o->right_fringe_width;
+p->fringes_outside_margins = o->fringes_outside_margins;
+p->scroll_bar_width = o->scroll_bar_width;
+p->vertical_scroll_bar_type = o->vertical_scroll_bar_type;
 /* Apportion the available frame space among the two new windows */
 if (!NILP (horflag))
 {
-p->height = o->height;
+p->total_lines = o->total_lines;
-p->top = o->top;
+p->top_line = o->top_line;
-XSETFASTINT (p->width, XFASTINT (o->width) - size_int);
+XSETFASTINT (p->total_cols, XFASTINT (o->total_cols) - size_int);
-XSETFASTINT (o->width, size_int);
+XSETFASTINT (o->total_cols, size_int);
-XSETFASTINT (p->left, XFASTINT (o->left) + size_int);
+XSETFASTINT (p->left_col, XFASTINT (o->left_col) + size_int);
+adjust_window_margins (p);
+adjust_window_margins (o);
 }
 else
 {
-p->left = o->left;
+p->left_col = o->left_col;
-p->width = o->width;
+p->total_cols = o->total_cols;
-XSETFASTINT (p->height, XFASTINT (o->height) - size_int);
+XSETFASTINT (p->total_lines, XFASTINT (o->total_lines) - size_int);
-XSETFASTINT (o->height, size_int);
+XSETFASTINT (o->total_lines, size_int);
-XSETFASTINT (p->top, XFASTINT (o->top) + size_int);
+XSETFASTINT (p->top_line, XFASTINT (o->top_line) + size_int);
 }
 /* Adjust glyph matrices.  */
 adjust_glyphs (fo);
-Fset_window_buffer (new, o->buffer);
+Fset_window_buffer (new, o->buffer, Qt);
 return new;
 }
 DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 3, "p",
 doc: /* Make current window ARG lines bigger.
 int
 window_height (window)
 Lisp_Object window;
 {
 register struct window *p = XWINDOW (window);
-return XFASTINT (p->height);
+return WINDOW_TOTAL_LINES (p);
 }
 int
 window_width (window)
 Lisp_Object window;
 {
 register struct window *p = XWINDOW (window);
-return XFASTINT (p->width);
+return WINDOW_TOTAL_COLS (p);
 }
 #define CURBEG(w) \
-*(widthflag ? &(XWINDOW (w)->left) : &(XWINDOW (w)->top))
+*(widthflag ? &(XWINDOW (w)->left_col) : &(XWINDOW (w)->top_line))
 #define CURSIZE(w) \
-*(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
+*(widthflag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
 /* Enlarge WINDOW by DELTA.  WIDTHFLAG non-zero means
 increase its width.  Siblings of the selected window are resized to
 fulfill the size request.  If they become too small in the process,
 XSETFASTINT (w->last_modified, 0);
 XSETFASTINT (w->last_overlay_modified, 0);
 windows_or_buffers_changed++;
 FRAME_WINDOW_SIZES_CHANGED (XFRAME (WINDOW_FRAME (w))) = 1;
-old_height = XFASTINT (w->height);
+old_height = XFASTINT (w->total_lines);
-XSETFASTINT (w->height, height);
+XSETFASTINT (w->total_lines, height);
 if (!NILP (w->hchild))
 {
 for (child = w->hchild; !NILP (child); child = c->next)
 	{
 	  c = XWINDOW (child);
-	  c->top = w->top;
+	  c->top_line = w->top_line;
 	  shrink_window_lowest_first (c, height);
 	}
 }
 else if (!NILP (w->vchild))
 {
 for (child = last_child; delta && !NILP (child); child = c->prev)
 	{
 	  int this_one;
 	  c = XWINDOW (child);
-	  this_one = XFASTINT (c->height) - MIN_SAFE_WINDOW_HEIGHT;
+	  this_one = XFASTINT (c->total_lines) - MIN_SAFE_WINDOW_HEIGHT;
 	  if (this_one > delta)
 	    this_one = delta;
-	  shrink_window_lowest_first (c, XFASTINT (c->height) - this_one);
+	  shrink_window_lowest_first (c, XFASTINT (c->total_lines) - this_one);
 	  delta -= this_one;
 	}
 /* Compute new positions.  */
-last_top = XINT (w->top);
+last_top = XINT (w->top_line);
 for (child = w->vchild; !NILP (child); child = c->next)
 	{
 	  c = XWINDOW (child);
-	  c->top = make_number (last_top);
+	  c->top_line = make_number (last_top);
-	  shrink_window_lowest_first (c, XFASTINT (c->height));
+	  shrink_window_lowest_first (c, XFASTINT (c->total_lines));
-	  last_top += XFASTINT (c->height);
+	  last_top += XFASTINT (c->total_lines);
 	}
 }
 }
 /* Save, restore, or check positions and sizes in the window tree
 rooted at W.  ACTION says what to do.
-If ACTION is CHECK_ORIG_SIZES, check if orig_top and orig_height
+If ACTION is CHECK_ORIG_SIZES, check if orig_top_line and
-members are valid for all windows in the window tree.  Value is
+orig_total_lines members are valid for all windows in the window
-non-zero if they are valid.
+tree.  Value is non-zero if they are valid.
 If ACTION is SAVE_ORIG_SIZES, save members top and height in
-orig_top and orig_height for all windows in the tree.
+orig_top_line and orig_total_lines for all windows in the tree.
-If ACTION is RESTORE_ORIG_SIZES, restore top and height from
+If ACTION is RESTORE_ORIG_SIZES, restore top and height from values
-values stored in orig_top and orig_height for all windows.  */
+stored in orig_top_line and orig_total_lines for all windows.  */
 static int
 save_restore_orig_size (w, action)
 struct window *w;
 enum save_restore_action action;
 	}
 switch (action)
 	{
 	case CHECK_ORIG_SIZES:
-	  if (!INTEGERP (w->orig_top) || !INTEGERP (w->orig_height))
+	  if (!INTEGERP (w->orig_top_line) || !INTEGERP (w->orig_total_lines))
 	    return 0;
 	  break;
 	case SAVE_ORIG_SIZES:
-	  w->orig_top = w->top;
+	  w->orig_top_line = w->top_line;
-	  w->orig_height = w->height;
+	  w->orig_total_lines = w->total_lines;
 XSETFASTINT (w->last_modified, 0);
 XSETFASTINT (w->last_overlay_modified, 0);
 	  break;
 	case RESTORE_ORIG_SIZES:
-	  xassert (INTEGERP (w->orig_top) && INTEGERP (w->orig_height));
+	  xassert (INTEGERP (w->orig_top_line) && INTEGERP (w->orig_total_lines));
-	  w->top = w->orig_top;
+	  w->top_line = w->orig_top_line;
-	  w->height = w->orig_height;
+	  w->total_lines = w->orig_total_lines;
-	  w->orig_height = w->orig_top = Qnil;
+	  w->orig_total_lines = w->orig_top_line = Qnil;
 XSETFASTINT (w->last_modified, 0);
 XSETFASTINT (w->last_overlay_modified, 0);
 	  break;
 	default:
 other windows.  */
 root = XWINDOW (FRAME_ROOT_WINDOW (f));
 if (delta)
 {
 int min_height = window_min_size (root, 0, 0, 0);
-if (XFASTINT (root->height) - delta < min_height)
+if (XFASTINT (root->total_lines) - delta < min_height)
 	/* Note that the root window may already be smaller than
 	   min_height.  */
-	delta = max (0, XFASTINT (root->height) - min_height);
+	delta = max (0, XFASTINT (root->total_lines) - min_height);
 }
 if (delta)
 {
 /* Save original window sizes and positions, if not already done.  */
 if (!save_restore_orig_size (root, CHECK_ORIG_SIZES))
 	save_restore_orig_size (root, SAVE_ORIG_SIZES);
 /* Shrink other windows.  */
-shrink_window_lowest_first (root, XFASTINT (root->height) - delta);
+shrink_window_lowest_first (root, XFASTINT (root->total_lines) - delta);
 /* Grow the mini-window.  */
-w->top = make_number (XFASTINT (root->top) + XFASTINT (root->height));
+w->top_line = make_number (XFASTINT (root->top_line) + XFASTINT (root->total_lines));
-w->height = make_number (XFASTINT (w->height) + delta);
+w->total_lines = make_number (XFASTINT (w->total_lines) + delta);
 XSETFASTINT (w->last_modified, 0);
 XSETFASTINT (w->last_overlay_modified, 0);
 adjust_glyphs (f);
 }
 save_restore_orig_size (root, RESTORE_ORIG_SIZES);
 adjust_glyphs (f);
 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 windows_or_buffers_changed = 1;
 }
-else if (XFASTINT (w->height) > 1)
+else if (XFASTINT (w->total_lines) > 1)
 {
 /* Distribute the additional lines of the mini-window
 	 among the other windows.  */
 Lisp_Object window;
 XSETWINDOW (window, w);
-enlarge_window (window, 1 - XFASTINT (w->height), 0, 0);
+enlarge_window (window, 1 - XFASTINT (w->total_lines), 0, 0);
 }
 }
 int
 window_internal_height (w)
 struct window *w;
 {
-int ht = XFASTINT (w->height);
+int ht = XFASTINT (w->total_lines);
 if (!MINI_WINDOW_P (w))
 {
 if (!NILP (w->parent)
 	  || !NILP (w->vchild)
 /* Return the number of columns in W.
 Don't count columns occupied by scroll bars or the vertical bar
 separating W from the sibling to its right.  */
 int
-window_internal_width (w)
+window_box_text_cols (w)
 struct window *w;
 {
 struct frame *f = XFRAME (WINDOW_FRAME (w));
-int width = XINT (w->width);
+int width = XINT (w->total_cols);
-if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
 /* Scroll bars occupy a few columns.  */
-width -= FRAME_SCROLL_BAR_COLS (f);
+width -= WINDOW_CONFIG_SCROLL_BAR_COLS (w);
-else if (!WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
+else if (!FRAME_WINDOW_P (f)
+	   && !WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
 /* The column of `|' characters separating side-by-side windows
 occupies one column only.  */
 width -= 1;
-/* On window-systems, areas to the left and right of the window
-are used as fringes.  */
 if (FRAME_WINDOW_P (f))
-width -= FRAME_FRINGE_COLS (f);
+/* On window-systems, fringes and display margins cannot be
+used for normal text.  */
+width -= (WINDOW_FRINGE_COLS (w)
+	      + WINDOW_LEFT_MARGIN_COLS (w)
+	      + WINDOW_RIGHT_MARGIN_COLS (w));
 return width;
 }
 backward.  The result is the new window start.  */
 start_display (&it, w, start);
 if (whole)
 {
 int screen_full = (window_box_height (w)
-			 - next_screen_context_lines * CANON_Y_UNIT (it.f));
+			 - next_screen_context_lines * FRAME_LINE_HEIGHT (it.f));
 int dy = n * screen_full;
 /* Note that move_it_vertically always moves the iterator to the
 start of a line.  So, if the last line doesn't have a newline,
 	 we would end up at the start of the line ending at ZV.  */
 }
 else
 {
 /* Move PT out of scroll margins.  */
 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, XFASTINT (w->total_lines) / 4);
-this_scroll_margin *= CANON_Y_UNIT (it.f);
+this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
 if (n > 0)
 	{
 	  /* We moved the window start towards ZV, so PT may be now
 	     in the scroll margin at the top.  */
 startpos = marker_position (w->start);
 posit = *compute_motion (startpos, 0, 0, 0,
 			   PT, ht, 0,
-			   window_internal_width (w), XINT (w->hscroll),
+			   window_box_text_cols (w), XINT (w->hscroll),
 			   0, w);
 original_vpos = posit.vpos;
 XSETFASTINT (tem, PT);
 tem = Fpos_visible_in_window_p (tem, window, Qnil);
 /* Don't use a scroll margin that is negative or too large.  */
 if (this_scroll_margin < 0)
 	this_scroll_margin = 0;
-if (XINT (w->height) < 4 * scroll_margin)
+if (XINT (w->total_lines) < 4 * scroll_margin)
-	this_scroll_margin = XINT (w->height) / 4;
+	this_scroll_margin = XINT (w->total_lines) / 4;
 set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
 w->start_at_line_beg = bolp;
 w->update_mode_line = Qt;
 XSETFASTINT (w->last_modified, 0);
 Lisp_Object result;
 int hscroll;
 struct window *w = XWINDOW (selected_window);
 if (NILP (arg))
-XSETFASTINT (arg, window_internal_width (w) - 2);
+XSETFASTINT (arg, window_box_text_cols (w) - 2);
 else
 arg = Fprefix_numeric_value (arg);
 hscroll = XINT (w->hscroll) + XINT (arg);
 result = Fset_window_hscroll (selected_window, make_number (hscroll));
 Lisp_Object result;
 int hscroll;
 struct window *w = XWINDOW (selected_window);
 if (NILP (arg))
-XSETFASTINT (arg, window_internal_width (w) - 2);
+XSETFASTINT (arg, window_box_text_cols (w) - 2);
 else
 arg = Fprefix_numeric_value (arg);
 hscroll = XINT (w->hscroll) - XINT (arg);
 result = Fset_window_hscroll (selected_window, make_number (hscroll));
 height++;
 /* Add in empty lines at the bottom of the window.  */
 if (bottom_y < height)
 {
-int uy = CANON_Y_UNIT (it.f);
+int uy = FRAME_LINE_HEIGHT (it.f);
 it.vpos += (height - bottom_y + uy - 1) / uy;
 }
 if (old_buffer)
 set_buffer_internal (old_buffer);
 	  y1 = line_bottom_y (&it);
 	  /* If we can't move down NLINES lines because we hit
 	     the end of the buffer, count in some empty lines.  */
 	  if (it.vpos < nlines)
-	    y1 += (nlines - it.vpos) * CANON_Y_UNIT (it.f);
+	    y1 += (nlines - it.vpos) * FRAME_LINE_HEIGHT (it.f);
 	  h = window_box_height (w) - (y1 - y0);
 	  start_display (&it, w, pt);
 	  move_it_vertically (&it, - h);
 (window)
 Lisp_Object window;
 {
 struct window *w = decode_window (window);
 int pixel_height = window_box_height (w);
-int line_height = pixel_height / CANON_Y_UNIT (XFRAME (w->frame));
+int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (w->frame));
 return make_number (line_height);
 }
 struct save_window_data
 {
 EMACS_INT size_from_Lisp_Vector_struct;
 struct Lisp_Vector *next_from_Lisp_Vector_struct;
-Lisp_Object frame_width, frame_height, frame_menu_bar_lines;
+Lisp_Object frame_cols, frame_lines, frame_menu_bar_lines;
 Lisp_Object frame_tool_bar_lines;
 Lisp_Object selected_frame;
 Lisp_Object current_window;
 Lisp_Object current_buffer;
 Lisp_Object minibuf_scroll_window;
 EMACS_INT size_from_Lisp_Vector_struct;
 struct Lisp_Vector *next_from_Lisp_Vector_struct;
 Lisp_Object window;
 Lisp_Object buffer, start, pointm, mark;
-Lisp_Object left, top, width, height, hscroll, min_hscroll;
+Lisp_Object left_col, top_line, total_cols, total_lines;
+Lisp_Object hscroll, min_hscroll;
 Lisp_Object parent, prev;
 Lisp_Object start_at_line_beg;
 Lisp_Object display_table;
-Lisp_Object orig_top, orig_height;
+Lisp_Object orig_top_line, orig_total_lines;
+Lisp_Object left_margin_cols, right_margin_cols;
+Lisp_Object left_fringe_width, right_fringe_width, fringes_outside_margins;
+Lisp_Object scroll_bar_width, vertical_scroll_bar_type;
 };
-#define SAVED_WINDOW_VECTOR_SIZE 17 /* Arg to Fmake_vector */
+#define SAVED_WINDOW_VECTOR_SIZE 24 /* Arg to Fmake_vector */
 #define SAVED_WINDOW_N(swv,n) \
 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
 /* If the frame has been resized since this window configuration was
 	 made, we change the frame to the size specified in the
 	 configuration, restore the configuration, and then resize it
 	 back.  We keep track of the prevailing height in these variables.  */
-int previous_frame_height = FRAME_HEIGHT (f);
+int previous_frame_lines = FRAME_LINES (f);
-int previous_frame_width =  FRAME_WIDTH  (f);
+int previous_frame_cols =  FRAME_COLS  (f);
 int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
 int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
 /* The mouse highlighting code could get screwed up
 	 if it runs during this.  */
 BLOCK_INPUT;
-if (XFASTINT (data->frame_height) != previous_frame_height
+if (XFASTINT (data->frame_lines) != previous_frame_lines
-	  || XFASTINT (data->frame_width) != previous_frame_width)
+	  || XFASTINT (data->frame_cols) != previous_frame_cols)
-	change_frame_size (f, XFASTINT (data->frame_height),
+	change_frame_size (f, XFASTINT (data->frame_lines),
-			   XFASTINT (data->frame_width), 0, 0, 0);
+			   XFASTINT (data->frame_cols), 0, 0, 0);
 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
 if (XFASTINT (data->frame_menu_bar_lines)
 	  != previous_frame_menu_bar_lines)
 	x_set_menu_bar_lines (f, data->frame_menu_bar_lines, make_number (0));
 #ifdef HAVE_WINDOW_SYSTEM
 	  else
 	    {
 	      w->prev = Qnil;
 	      if (!NILP (w->parent))
 		{
-		  if (EQ (p->width, XWINDOW (w->parent)->width))
+		  if (EQ (p->total_cols, XWINDOW (w->parent)->total_cols))
 		    {
 		      XWINDOW (w->parent)->vchild = p->window;
 		      XWINDOW (w->parent)->hchild = Qnil;
 		    }
 		  else
 		}
 	    }
 	  /* If we squirreled away the buffer in the window's height,
 	     restore it now.  */
-	  if (BUFFERP (w->height))
+	  if (BUFFERP (w->total_lines))
-	    w->buffer = w->height;
+	    w->buffer = w->total_lines;
-	  w->left = p->left;
+	  w->left_col = p->left_col;
-	  w->top = p->top;
+	  w->top_line = p->top_line;
-	  w->width = p->width;
+	  w->total_cols = p->total_cols;
-	  w->height = p->height;
+	  w->total_lines = p->total_lines;
 	  w->hscroll = p->hscroll;
 	  w->min_hscroll = p->min_hscroll;
 	  w->display_table = p->display_table;
-	  w->orig_top = p->orig_top;
+	  w->orig_top_line = p->orig_top_line;
-	  w->orig_height = p->orig_height;
+	  w->orig_total_lines = p->orig_total_lines;
+	  w->left_margin_cols = p->left_margin_cols;
+	  w->right_margin_cols = p->right_margin_cols;
+	  w->left_fringe_width = p->left_fringe_width;
+	  w->right_fringe_width = p->right_fringe_width;
+	  w->fringes_outside_margins = p->fringes_outside_margins;
+	  w->scroll_bar_width = p->scroll_bar_width;
+	  w->vertical_scroll_bar_type = p->vertical_scroll_bar_type;
 	  XSETFASTINT (w->last_modified, 0);
 	  XSETFASTINT (w->last_overlay_modified, 0);
 	  /* Reinstall the saved buffer and pointers into it.  */
 	  if (NILP (p->buffer))
 	do_switch_frame (WINDOW_FRAME (XWINDOW (data->root_window)),
 			 0, 0);
 #endif
 /* Set the screen height to the value it had before this function.  */
-if (previous_frame_height != FRAME_HEIGHT (f)
+if (previous_frame_lines != FRAME_LINES (f)
-	  || previous_frame_width != FRAME_WIDTH (f))
+	  || previous_frame_cols != FRAME_COLS (f))
-	change_frame_size (f, previous_frame_height, previous_frame_width,
+	change_frame_size (f, previous_frame_lines, previous_frame_cols,
 			   0, 0, 0);
 #if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
 if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
 	x_set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
 			      make_number (0));
 if (!NILP (w->vchild))
 delete_all_subwindows (XWINDOW (w->vchild));
 if (!NILP (w->hchild))
 delete_all_subwindows (XWINDOW (w->hchild));
-w->height = w->buffer;       /* See Fset_window_configuration for excuse.  */
+w->total_lines = w->buffer;       /* See Fset_window_configuration for excuse.  */
 if (!NILP (w->buffer))
 unshow_buffer (w);
 /* We set all three of these fields to nil, to make sure that we can
 w = XWINDOW (window);
 XSETFASTINT (w->temslot, i++);
 p->window = window;
 p->buffer = w->buffer;
-p->left = w->left;
+p->left_col = w->left_col;
-p->top = w->top;
+p->top_line = w->top_line;
-p->width = w->width;
+p->total_cols = w->total_cols;
-p->height = w->height;
+p->total_lines = w->total_lines;
 p->hscroll = w->hscroll;
 p->min_hscroll = w->min_hscroll;
 p->display_table = w->display_table;
-p->orig_top = w->orig_top;
+p->orig_top_line = w->orig_top_line;
-p->orig_height = w->orig_height;
+p->orig_total_lines = w->orig_total_lines;
+p->left_margin_cols = w->left_margin_cols;
+p->right_margin_cols = w->right_margin_cols;
+p->left_fringe_width = w->left_fringe_width;
+p->right_fringe_width = w->right_fringe_width;
+p->fringes_outside_margins = w->fringes_outside_margins;
+p->scroll_bar_width = w->scroll_bar_width;
+p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
 if (!NILP (w->buffer))
 	{
 	  /* Save w's value of point in the window configuration.
 	     If w is the selected window, then get the value of point
 	     from the buffer; pointm is garbage in the selected window.  */
 n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
 vec = allocate_other_vector (VECSIZE (struct save_window_data));
 data = (struct save_window_data *)vec;
-XSETFASTINT (data->frame_width, FRAME_WIDTH (f));
+XSETFASTINT (data->frame_cols, FRAME_COLS (f));
-XSETFASTINT (data->frame_height, FRAME_HEIGHT (f));
+XSETFASTINT (data->frame_lines, FRAME_LINES (f));
 XSETFASTINT (data->frame_menu_bar_lines, FRAME_MENU_BAR_LINES (f));
 XSETFASTINT (data->frame_tool_bar_lines, FRAME_TOOL_BAR_LINES (f));
 data->selected_frame = selected_frame;
 data->current_window = FRAME_SELECTED_WINDOW (f);
 XSETBUFFER (data->current_buffer, current_buffer);
 (window, left, right)
 Lisp_Object window, left, right;
 {
 struct window *w = decode_window (window);
+/* TODO: It doesn't make sense to use FLOATs here, since
+the rest of the code assumes they are integers.
+So don't allow floats!  ++KFS */
 if (!NILP (left))
 CHECK_NUMBER_OR_FLOAT (left);
 if (!NILP (right))
 CHECK_NUMBER_OR_FLOAT (right);
 || (FLOATP (right) && XFLOAT_DATA (right) <= 0))
 XSETFASTINT (right, 0);
 if (INTEGERP (right) && XFASTINT (right) == 0)
 right = Qnil;
-w->left_margin_width = left;
+if (!EQ (w->left_margin_cols, left)
-w->right_margin_width = right;
+|| !EQ (w->right_margin_cols, right))
+{
-++windows_or_buffers_changed;
+w->left_margin_cols = left;
-adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
+w->right_margin_cols = right;
+adjust_window_margins (w);
+++windows_or_buffers_changed;
+adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
+}
 return Qnil;
 }
 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
 as nil.  */)
 (window)
 Lisp_Object window;
 {
 struct window *w = decode_window (window);
-return Fcons (w->left_margin_width, w->right_margin_width);
+return Fcons (w->left_margin_cols, w->right_margin_cols);
+}
+/***********************************************************************
+			    Fringes
+***********************************************************************/
+DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
+2, 4, 0,
+doc: /* Set width of fringes of window WINDOW.
+If window is nil, set fringes of the currently selected window.
+Second parameter LEFT-WIDTH specifies the number of pixels to reserve
+for the left fringe.  Third parameter RIGHT-WIDTH does the same for
+the right fringe.  Fourth parameter OUTSIDE-MARGINS non-nil specifies
+that fringes are drawn outside of the display margins; by default, fringes
+are drawn between display marginal areas and the text area.
+A nil width parameter means to use the frame's corresponding fringe width.  */)
+(window, left, right, outside_margins)
+Lisp_Object window, left, right, outside_margins;
+{
+struct window *w = decode_window (window);
+if (!NILP (left))
+CHECK_NUMBER (left);
+if (!NILP (right))
+CHECK_NUMBER (right);
+if (!EQ (w->left_fringe_width, left)
+|| !EQ (w->right_fringe_width, right)
+|| !EQ (w->fringes_outside_margins, outside_margins))
+{
+w->left_fringe_width = left;
+w->right_fringe_width = right;
+w->fringes_outside_margins = outside_margins;
+adjust_window_margins (w);
+clear_glyph_matrix (w->current_matrix);
+w->window_end_valid = Qnil;
+++windows_or_buffers_changed;
+adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
+}
+return Qnil;
+}
+DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
+0, 1, 0,
+doc: /* Get width of fringes of window WINDOW.
+If WINDOW is omitted or nil, use the currently selected window.
+Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).
+If a window specific fringe width is not set, its width will be returned
+as nil.  */)
+(window)
+Lisp_Object window;
+{
+struct window *w = decode_window (window);
+return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
+		Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
+		       Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w) ?
+			       Qt : Qnil), Qnil)));
+}
+/***********************************************************************
+			    Scroll bars
+***********************************************************************/
+DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars, Sset_window_scroll_bars,
+2, 4, 0,
+doc: /* Set width and type of scroll bars of window WINDOW.
+If window is nil, set scroll bars of the currently selected window.
+Second parameter WIDTH specifies the pixel width for the scroll bar;
+this is automatically adjusted to a multiple of the frame column width.
+Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
+bar: left, right, or nil.
+A width of nil and type of t means to use the frame's corresponding value.  */)
+(window, width, vertical_type, horisontal_type)
+Lisp_Object window, width, vertical_type, horisontal_type;
+{
+struct window *w = decode_window (window);
+if (!NILP (width))
+CHECK_NUMBER (width);
+if (XINT (width) == 0)
+vertical_type = Qnil;
+if (!EQ (w->scroll_bar_width, width)
+|| !EQ (w->vertical_scroll_bar_type, vertical_type))
+{
+w->scroll_bar_width = width;
+w->vertical_scroll_bar_type = vertical_type;
+adjust_window_margins (w);
+clear_glyph_matrix (w->current_matrix);
+w->window_end_valid = Qnil;
+++windows_or_buffers_changed;
+adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
+}
+return Qnil;
+}
+DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
+0, 1, 0,
+doc: /* Get width and type of scroll bars of window WINDOW.
+If WINDOW is omitted or nil, use the currently selected window.
+Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORISONTAL-TYPE).  */)
+(window)
+Lisp_Object window;
+{
+struct window *w = decode_window (window);
+return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
+			      ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
+			      : WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
+		Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w)),
+		       Fcons (w->vertical_scroll_bar_type,
+			      Fcons (Qnil, Qnil))));
 }
 /***********************************************************************
 CHECK_WINDOW (window);
 w = XWINDOW (window);
 f = XFRAME (w->frame);
 if (FRAME_WINDOW_P (f))
-result = CANON_Y_FROM_PIXEL_Y (f, -w->vscroll);
+result = FRAME_CANON_Y_FROM_PIXEL_Y (f, -w->vscroll);
 else
 result = make_number (0);
 return result;
 }
 if (FRAME_WINDOW_P (f))
 {
 int old_dy = w->vscroll;
-w->vscroll = - CANON_Y_UNIT (f) * XFLOATINT (vscroll);
+w->vscroll = - FRAME_LINE_HEIGHT (f) * XFLOATINT (vscroll);
 w->vscroll = min (w->vscroll, 0);
 /* Adjust glyph matrix of the frame if the virtual display
 	 area becomes larger than before.  */
 if (w->vscroll < 0 && w->vscroll < old_dy)
 d1 = (struct save_window_data *) XVECTOR (c1);
 d2 = (struct save_window_data *) XVECTOR (c2);
 sw1 = XVECTOR (d1->saved_windows);
 sw2 = XVECTOR (d2->saved_windows);
-if (! EQ (d1->frame_width, d2->frame_width))
+if (! EQ (d1->frame_cols, d2->frame_cols))
 return 0;
-if (! EQ (d1->frame_height, d2->frame_height))
+if (! EQ (d1->frame_lines, d2->frame_lines))
 return 0;
 if (! EQ (d1->frame_menu_bar_lines, d2->frame_menu_bar_lines))
 return 0;
 if (! EQ (d1->selected_frame, d2->selected_frame))
 return 0;
 	return 0;
 /* Verify that the corresponding windows do match.  */
 if (! EQ (p1->buffer, p2->buffer))
 	return 0;
-if (! EQ (p1->left, p2->left))
+if (! EQ (p1->left_col, p2->left_col))
 	return 0;
-if (! EQ (p1->top, p2->top))
+if (! EQ (p1->top_line, p2->top_line))
 	return 0;
-if (! EQ (p1->width, p2->width))
+if (! EQ (p1->total_cols, p2->total_cols))
 	return 0;
-if (! EQ (p1->height, p2->height))
+if (! EQ (p1->total_lines, p2->total_lines))
 	return 0;
 if (! EQ (p1->display_table, p2->display_table))
 	return 0;
 if (! EQ (p1->parent, p2->parent))
 	return 0;
 	  if (NILP (Fequal (p1->pointm, p2->pointm)))
 	    return 0;
 	  if (NILP (Fequal (p1->mark, p2->mark)))
 	    return 0;
 	}
+if (! EQ (p1->left_margin_cols, p2->left_margin_cols))
+	return 0;
+if (! EQ (p1->right_margin_cols, p2->right_margin_cols))
+	return 0;
+if (! EQ (p1->left_fringe_width, p2->left_fringe_width))
+	return 0;
+if (! EQ (p1->right_fringe_width, p2->right_fringe_width))
+	return 0;
+if (! EQ (p1->fringes_outside_margins, p2->fringes_outside_margins))
+	return 0;
+if (! EQ (p1->scroll_bar_width, p2->scroll_bar_width))
+	return 0;
+if (! EQ (p1->vertical_scroll_bar_type, p2->vertical_scroll_bar_type))
+	return 0;
 }
 return 1;
 }
 defsubr (&Sset_window_configuration);
 defsubr (&Scurrent_window_configuration);
 defsubr (&Ssave_window_excursion);
 defsubr (&Sset_window_margins);
 defsubr (&Swindow_margins);
+defsubr (&Sset_window_fringes);
+defsubr (&Swindow_fringes);
+defsubr (&Sset_window_scroll_bars);
+defsubr (&Swindow_scroll_bars);
 defsubr (&Swindow_vscroll);
 defsubr (&Sset_window_vscroll);
 defsubr (&Scompare_window_configurations);
 defsubr (&Swindow_list);
 }

Mercurial > emacs

comparison src/window.c @ 51207:7e176ef34c10