emacs-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

resizing frames and windows


From: martin rudalics
Subject: resizing frames and windows
Date: Mon, 28 Apr 2008 16:57:21 +0200
User-agent: Mozilla Thunderbird 1.0 (Windows/20041206)

Dear developers,

attached find a patch for dispnew.c, window.h, and window.c which tries
to fix some problems wrt window resizing.  Please tell me whether it
applies and whether you can build Emacs with it (I currently cannot do
that with the most recent development sources).

In addition please try to answer the following questions (the two
functions at the bottom might be useful for these tests):

(1) Maximize a frame, create some minimal windows (one-line,
    two-columns) in it, and demaximize the frame.  Are all windows
    preserved?

(2) Same as (1) but try to create a no-way-out configuration where
    demaximizing the frame cannot avoid deleting some window(s) - for
    example, because you have two side-by-side windows and the
    demaximized frame can accomodate at most one such window.  Does
    resizing behave reasonably?

(3) Save the window-configurations of (1) and (2) in a maximized frame,
    demaximize the frame, change the layout arbitrarily, and set the
    window configuration to the saved one.  Does the resulting
    configuration appear reasonable?

(4) Split some window vertically, and repeatedly apply
    `my-enlarge-window'.  Is the other window deleted when its height
    drops below `window-min-height'?  Does it for other (possibly
    invalid) values of `window-min-height'?

(5) Split some window horizontally, and repeatedly apply
    `my-enlarge-window-horizontally'.  Is the other window deleted when
    its width drops below `window-min-width'?  Does it for other
    (possibly invalid) values of `window-min-width'?

(6) Create a one-line window at the bottom of the frame and try to
    resize the minibuffer.  Is the one-line window's modeline retained?

(7) After all these tests: Does customizing `window-min-height' and
    `window-min-width' work as expected?

Some of these issues were more or less broken in Emacsen I built over
the previous months.  Please help me to eliminate these problems.

Pretty please.


(defun my-enlarge-window ()
  (interactive)
  (let ((window-min-height 1))
    (enlarge-window 1)))

(defun my-enlarge-window-horizontally ()
  (interactive)
  (let ((window-min-width 2))
    (enlarge-window 1 t)))
*** dispnew.c   Mon Mar 10 00:49:46 2008
--- dispnew.c   Mon Apr 28 10:53:18 2008
***************
*** 6341,6347 ****
                             (newheight
                              - 1
                              - FRAME_TOP_MARGIN (f)),
!                             0);
          XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top_line,
                       newheight - 1);
          set_window_height (FRAME_MINIBUF_WINDOW (f), 1, 0);
--- 6341,6347 ----
                             (newheight
                              - 1
                              - FRAME_TOP_MARGIN (f)),
!                            2);
          XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top_line,
                       newheight - 1);
          set_window_height (FRAME_MINIBUF_WINDOW (f), 1, 0);
***************
*** 6349,6355 ****
        else
        /* Frame has just one top-level window.  */
        set_window_height (FRAME_ROOT_WINDOW (f),
!                          newheight - FRAME_TOP_MARGIN (f), 0);
  
        if (FRAME_TERMCAP_P (f) && !pretend)
        FrameRows (FRAME_TTY (f)) = newheight;
--- 6349,6355 ----
        else
        /* Frame has just one top-level window.  */
        set_window_height (FRAME_ROOT_WINDOW (f),
!                          newheight - FRAME_TOP_MARGIN (f), 2);
  
        if (FRAME_TERMCAP_P (f) && !pretend)
        FrameRows (FRAME_TTY (f)) = newheight;
***************
*** 6357,6363 ****
  
    if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
      {
!       set_window_width (FRAME_ROOT_WINDOW (f), new_frame_total_cols, 0);
        if (FRAME_HAS_MINIBUF_P (f))
        set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_total_cols, 0);
  
--- 6357,6363 ----
  
    if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
      {
!       set_window_width (FRAME_ROOT_WINDOW (f), new_frame_total_cols, 2);
        if (FRAME_HAS_MINIBUF_P (f))
        set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_total_cols, 0);
  
*** window.h    Mon Jan 28 19:05:10 2008
--- window.h    Mon Apr 28 10:54:02 2008
***************
*** 222,229 ****
      /* If redisplay in this window goes beyond this buffer position,
         must run the redisplay-end-trigger-hook.  */
      Lisp_Object redisplay_end_trigger;
!     /* Non-nil means don't delete this window for becoming "too small".  */
!     Lisp_Object too_small_ok;
  
      /* Original window height and top before mini-window was
         enlarged. */
--- 222,230 ----
      /* If redisplay in this window goes beyond this buffer position,
         must run the redisplay-end-trigger-hook.  */
      Lisp_Object redisplay_end_trigger;
!     /* Non-nil means resizing windows will attempt to resize this window
!        proportionally.  */
!     Lisp_Object resize_proportionally;
  
      /* Original window height and top before mini-window was
         enlarged. */
***************
*** 337,356 ****
  #define WINDOW_FRAME_LINE_HEIGHT(W) \
    (FRAME_LINE_HEIGHT (WINDOW_XFRAME ((W))))
  
! 
! /* Return the frame width in canonical column units.
     This includes scroll bars and fringes.  */
  
  #define WINDOW_TOTAL_COLS(W) \
    (XFASTINT ((W)->total_cols))
  
! /* Return the frame height in canonical line units.
     This includes header and mode lines, if any.  */
  
  #define WINDOW_TOTAL_LINES(W) \
    (XFASTINT ((W)->total_lines))
  
- 
  /* Return the total pixel width of window W.  */
  
  #define WINDOW_TOTAL_WIDTH(W) \
--- 338,355 ----
  #define WINDOW_FRAME_LINE_HEIGHT(W) \
    (FRAME_LINE_HEIGHT (WINDOW_XFRAME ((W))))
  
! /* Return the width of window W in canonical column units.
     This includes scroll bars and fringes.  */
  
  #define WINDOW_TOTAL_COLS(W) \
    (XFASTINT ((W)->total_cols))
  
! /* Return the height of window W in canonical line units.
     This includes header and mode lines, if any.  */
  
  #define WINDOW_TOTAL_LINES(W) \
    (XFASTINT ((W)->total_lines))
  
  /* Return the total pixel width of window W.  */
  
  #define WINDOW_TOTAL_WIDTH(W) \

*** window.c    Wed Apr  2 22:15:44 2008
--- window.c    Mon Apr 28 11:08:24 2008
***************
*** 65,73 ****
  static void window_scroll P_ ((Lisp_Object, int, int, int));
  static void window_scroll_pixel_based P_ ((Lisp_Object, int, int, int));
  static void window_scroll_line_based P_ ((Lisp_Object, int, int, int));
! static int window_min_size_1 P_ ((struct window *, int));
! static int window_min_size_2 P_ ((struct window *, int));
! static int window_min_size P_ ((struct window *, int, int, int *));
  static void size_window P_ ((Lisp_Object, int, int, int, int, int));
  static int freeze_window_start P_ ((struct window *, void *));
  static int window_fixed_size_p P_ ((struct window *, int, int));
--- 65,73 ----
  static void window_scroll P_ ((Lisp_Object, int, int, int));
  static void window_scroll_pixel_based P_ ((Lisp_Object, int, int, int));
  static void window_scroll_line_based P_ ((Lisp_Object, int, int, int));
! static int window_min_size_1 P_ ((struct window *, int, int));
! static int window_min_size_2 P_ ((struct window *, int, int));
! static int window_min_size P_ ((struct window *, int, int, int, int *));
  static void size_window P_ ((Lisp_Object, int, int, int, int, int));
  static int freeze_window_start P_ ((struct window *, void *));
  static int window_fixed_size_p P_ ((struct window *, int, int));
***************
*** 299,304 ****
--- 299,305 ----
    p->fringes_outside_margins = Qnil;
    p->scroll_bar_width = Qnil;
    p->vertical_scroll_bar_type = Qt;
+   p->resize_proportionally = Qnil;
  
    Vwindow_list = Qnil;
    return val;
***************
*** 2550,2567 ****
  #define MIN_SAFE_WINDOW_WIDTH  (2)
  #define MIN_SAFE_WINDOW_HEIGHT (1)
  
! /* Make sure that window_min_height and window_min_width are
!    not too small; if they are, set them to safe minima.  */
  
! static void
! check_min_window_sizes ()
! {
!   /* Smaller values might permit a crash.  */
!   if (window_min_width < MIN_SAFE_WINDOW_WIDTH)
!     window_min_width = MIN_SAFE_WINDOW_WIDTH;
!   if (window_min_height < MIN_SAFE_WINDOW_HEIGHT)
!     window_min_height = MIN_SAFE_WINDOW_HEIGHT;
! }
  
  /* If *ROWS or *COLS are too small a size for FRAME, set them to the
     minimum allowable size.  */
--- 2551,2561 ----
  #define MIN_SAFE_WINDOW_WIDTH  (2)
  #define MIN_SAFE_WINDOW_HEIGHT (1)
  
! /* For wp non-zero the total number of columns of window w.  Otherwise
!    the total number of lines of w.  */
  
! #define WINDOW_TOTAL_SIZE(w, wp) \
!   (wp ? WINDOW_TOTAL_COLS (w) : WINDOW_TOTAL_LINES (w))
  
  /* If *ROWS or *COLS are too small a size for FRAME, set them to the
     minimum allowable size.  */
***************
*** 2608,2614 ****
  
        if (width_p)
        {
!         /* A horiz. combination is fixed-width if all of if its
             children are.  */
          while (c && window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
--- 2602,2608 ----
  
        if (width_p)
        {
!         /* A horizontal combination is fixed-width if all of if its
             children are.  */
          while (c && window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
***************
*** 2616,2622 ****
        }
        else
        {
!         /* A horiz. combination is fixed-height if one of if its
             children is.  */
          while (c && !window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
--- 2610,2616 ----
        }
        else
        {
!         /* A horizontal combination is fixed-height if one of if its
             children is.  */
          while (c && !window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
***************
*** 2629,2635 ****
  
        if (width_p)
        {
!         /* A vert. combination is fixed-width if one of if its
             children is.  */
          while (c && !window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
--- 2623,2629 ----
  
        if (width_p)
        {
!         /* A vertical combination is fixed-width if one of if its
             children is.  */
          while (c && !window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
***************
*** 2637,2643 ****
        }
        else
        {
!         /* A vert. combination is fixed-height if all of if its
             children are.  */
          while (c && window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
--- 2631,2637 ----
        }
        else
        {
!         /* A vertical combination is fixed-height if all of if its
             children are.  */
          while (c && window_fixed_size_p (c, width_p, 0))
            c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
***************
*** 2689,2808 ****
    return fixed_p;
  }
  
! /* Return the minimum size for leaf window W.  WIDTH_P non-zero means
!    take into account fringes and the scrollbar of W.  WIDTH_P zero means
!    take into account mode-line of W.  Return 1 for the minibuffer.  */
  
  static int
! window_min_size_2 (w, width_p)
       struct window *w;
!      int width_p;
  {
!   int size;
!   
    if (width_p)
!     size = max (window_min_width,
!               (MIN_SAFE_WINDOW_WIDTH
                 + WINDOW_FRINGE_COLS (w)
!                + WINDOW_SCROLL_BAR_COLS (w)));
    else if (MINI_WINDOW_P (w))
!     size = 1;
    else
!     size = max (window_min_height,
!               (MIN_SAFE_WINDOW_HEIGHT
!                /* Don't count the header-line here.  It would break
!                   splitting a window with a header-line when the new
!                   window shall have a height of two (calculator does
!                   that). */
!                + (WINDOW_WANTS_MODELINE_P (w) ? 1 : 0)));
! 
!   return size;
  }
  
! /* Return the minimum size of window W, not taking fixed-width windows
!    into account.  WIDTH_P non-zero means return the minimum width,
!    otherwise return the minimum height.  If W is a combination window,
!    compute the minimum size from the minimum sizes of W's children.  */
  
  static int
! window_min_size_1 (w, width_p)
       struct window *w;
!      int width_p;
  {
    struct window *c;
    int size;
  
    if (!NILP (w->hchild))
      {
        c = XWINDOW (w->hchild);
        size = 0;
  
        if (width_p)
        {
!         /* The min width of a horizontal combination is
!            the sum of the min widths of its children.  */
          while (c)
            {
!             size += window_min_size_1 (c, width_p);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
        else
        {
!         /* The min height a horizontal combination equals
!            the maximum of all min height of its children.  */
          while (c)
            {
!             int min_size = window_min_size_1 (c, width_p);
!             size = max (min_size, size);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
      }
    else if (!NILP (w->vchild))
      {
        c = XWINDOW (w->vchild);
        size = 0;
  
        if (width_p)
        {
!         /* The min width of a vertical combination is
!            the maximum of the min widths of its children.  */
          while (c)
            {
!             int min_size = window_min_size_1 (c, width_p);
!             size = max (min_size, size);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
        else
        {
!         /* The min height of a vertical combination equals
!            the sum of the min height of its children.  */
          while (c)
            {
!             size += window_min_size_1 (c, width_p);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
      }
    else
!     size = window_min_size_2 (w, width_p);
  
    return size;
  }
  
- 
  /* Return the minimum size of window W, taking fixed-size windows into
!    account.  WIDTH_P non-zero means return the minimum width,
!    otherwise return the minimum height.  IGNORE_FIXED_P non-zero means
!    ignore if W is fixed-size.  Set *FIXED to 1 if W is fixed-size
!    unless FIXED is null.  */
  
  static int
! window_min_size (w, width_p, ignore_fixed_p, fixed)
       struct window *w;
!      int width_p, ignore_fixed_p, *fixed;
  {
    int size, fixed_p;
  
--- 2683,2812 ----
    return fixed_p;
  }
  
! /* Return minimum size of leaf window W.  WIDTH_P non-zero means return
!    the minimum width of W, WIDTH_P zero means return the minimum height
!    of W.  SAFE_P non-zero means ignore window-min-height|width but just
!    return values that won't crash Emacs and don't hide components like
!    fringes, scrollbars, or modelines.  If WIDTH_P is zero and W is the
!    minibuffer window, always return 1.  */
  
  static int
! window_min_size_2 (w, width_p, safe_p)
       struct window *w;
!      int width_p, safe_p;
  {
!   /* We should consider buffer-local values of window_min_height and
!      window_min_width here.  */
    if (width_p)
!     {
!       int safe_size = (MIN_SAFE_WINDOW_WIDTH
                 + WINDOW_FRINGE_COLS (w)
!                      + WINDOW_SCROLL_BAR_COLS (w));
! 
!       return safe_p ? safe_size : max (window_min_width, safe_size);
!     }
    else if (MINI_WINDOW_P (w))
!     return 1;
    else
!     {
!       int safe_size = (MIN_SAFE_WINDOW_HEIGHT
!                      + ((BUFFERP (w->buffer)
!                          && !NILP (XBUFFER (w->buffer)->mode_line_format))
!                         ? 1 : 0));
! 
!       return safe_p ? safe_size : max (window_min_height, safe_size);
!     }
  }
  
! /* Return minimum size of window W, not taking fixed-width windows into
!    account.  WIDTH_P non-zero means return the minimum width, otherwise
!    return the minimum height.  SAFE_P non-zero means ignore
!    window-min-height|width but just return values that won't crash Emacs
!    and don't hide components like fringes, scrollbars, or modelines.  If
!    W is a combination window, compute the minimum size from the minimum
!    sizes of W's children.  */
  
  static int
! window_min_size_1 (w, width_p, safe_p)
       struct window *w;
!      int width_p, safe_p;
  {
    struct window *c;
    int size;
  
    if (!NILP (w->hchild))
      {
+       /* W is a horizontal combination.  */
        c = XWINDOW (w->hchild);
        size = 0;
  
        if (width_p)
        {
!         /* The minimum width of a horizontal combination is the sum of
!            the minimum widths of its children.  */
          while (c)
            {
!             size += window_min_size_1 (c, 1, safe_p);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
        else
        {
!         /* The minimum height of a horizontal combination is the
!            maximum of the minimum heights of its children.  */
          while (c)
            {
!             size = max (window_min_size_1 (c, 0, safe_p), size);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
      }
    else if (!NILP (w->vchild))
      {
+       /* W is a vertical combination.  */
        c = XWINDOW (w->vchild);
        size = 0;
  
        if (width_p)
        {
!         /* The minimum width of a vertical combination is the maximum
!            of the minimum widths of its children.  */
          while (c)
            {
!             size = max (window_min_size_1 (c, 1, safe_p), size);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
        else
        {
!         /* The minimum height of a vertical combination is the sum of
!            the minimum height of its children.  */
          while (c)
            {
!             size += window_min_size_1 (c, 0, safe_p);
              c = WINDOWP (c->next) ? XWINDOW (c->next) : NULL;
            }
        }
      }
    else
!     /* W is a leaf window.  */
!     size = window_min_size_2 (w, width_p, safe_p);
  
    return size;
  }
  
  /* Return the minimum size of window W, taking fixed-size windows into
!    account.  WIDTH_P non-zero means return the minimum width, otherwise
!    return the minimum height.  SAFE_P non-zero means ignore
!    window-min-height|width but just return values that won't crash Emacs
!    and don't hide components like fringes, scrollbars, or modelines.
!    IGNORE_FIXED_P non-zero means ignore if W is fixed-size.  Set *FIXED
!    to 1 if W is fixed-size unless FIXED is null.  */
  
  static int
! window_min_size (w, width_p, safe_p, ignore_fixed_p, fixed)
       struct window *w;
!      int width_p, safe_p, ignore_fixed_p, *fixed;
  {
    int size, fixed_p;
  
***************
*** 2815,2823 ****
      *fixed = fixed_p;
  
    if (fixed_p)
!     size = width_p ? XFASTINT (w->total_cols) : XFASTINT (w->total_lines);
    else
!     size = window_min_size_1 (w, width_p);
  
    return size;
  }
--- 2819,2827 ----
      *fixed = fixed_p;
  
    if (fixed_p)
!     size = WINDOW_TOTAL_SIZE (w, width_p);
    else
!     size = window_min_size_1 (w, width_p, safe_p);
  
    return size;
  }
***************
*** 2859,2893 ****
    return 1;
  }
  
! /* Calculate new sizes for windows in the list FORWARD when the window size
!    goes from TOTAL to SIZE.  TOTAL must be greater than SIZE.
!    The number of windows in FORWARD is NCHILDREN, and the number that
!    can shrink is SHRINKABLE.
!    The minimum size a window can have is MIN_SIZE.
!    If we are shrinking fixed windows, RESIZE_FIXED_P is non-zero.
!    If we are shrinking columns, WIDTH_P is non-zero, otherwise we are
!    shrinking rows.
  
     This function returns an allocated array of new sizes that the caller
!    must free.  The size -1 means the window is fixed and RESIZE_FIXED_P
!    is zero.  Array index 0 refers to the first window in FORWARD, 1 to
!    the second, and so on.
! 
!    This function tries to keep windows at least at the minimum size
!    and resize other windows before it resizes any window to zero (i.e.
!    delete that window).
! 
!    Windows are resized proportional to their size, so bigger windows
!    shrink more than smaller windows.  */
  static int *
! shrink_windows (total, size, nchildren, shrinkable,
!                 min_size, resize_fixed_p, forward, width_p)
!      int total, size, nchildren, shrinkable, min_size;
!      int resize_fixed_p, width_p;
       Lisp_Object forward;
  {
    int available_resize = 0;
!   int *new_sizes;
    struct window *c;
    Lisp_Object child;
    int smallest = total;
--- 2863,2900 ----
    return 1;
  }
  
! /* Calculate new sizes for windows in the list FORWARD when their
!    compound size goes from TOTAL to SIZE.  TOTAL must be greater than
!    SIZE.  The number of windows in FORWARD is NCHILDREN, and the number
!    that can shrink is SHRINKABLE.  Fixed-size windows may be shrunk if
!    and only if RESIZE_FIXED_P is non-zero.  WIDTH_P non-zero means
!    shrink columns, otherwise shrink lines.
! 
!    SAFE_P zero means windows may be sized down to window-min-height
!    lines (window-min-window columns for WIDTH_P non-zero).  SAFE_P
!    non-zero means windows may be sized down to their minimum safe sizes
!    taking into account the space needed to display modelines, fringes,
!    and scrollbars.
  
     This function returns an allocated array of new sizes that the caller
!    must free.  A size -1 means the window is fixed and RESIZE_FIXED_P is
!    zero.  A size zero means the window shall be deleted.  Array index 0
!    refers to the first window in FORWARD, 1 to the second, and so on.
! 
!    This function resizes windows proportionally to their size.  It also
!    tries to preserve smaller windows by resizing larger windows before
!    resizing any window to zero.  If resize_proportionally is non-nil for
!    a specific window, it will attempt to strictly resize that window
!    proportionally, even at the expense of deleting smaller windows.  */
  static int *
! shrink_windows (total, size, nchildren, shrinkable, resize_fixed_p,
!               forward, width_p, safe_p)
!      int total, size, nchildren, shrinkable;
!      int resize_fixed_p, width_p, safe_p;
       Lisp_Object forward;
  {
    int available_resize = 0;
!   int *new_sizes, *min_sizes;
    struct window *c;
    Lisp_Object child;
    int smallest = total;
***************
*** 2896,2916 ****
    int i;
  
    new_sizes = xmalloc (sizeof (*new_sizes) * nchildren);
  
    for (i = 0, child = forward; !NILP (child); child = c->next, ++i)
      {
        int child_size;
  
        c = XWINDOW (child);
!       child_size = width_p ? XINT (c->total_cols) : XINT (c->total_lines);
  
!       if (! resize_fixed_p && window_fixed_size_p (c, width_p, 0))
          new_sizes[i] = -1;
        else
          {
            new_sizes[i] = child_size;
!           if (child_size > min_size)
!             available_resize += child_size - min_size;
          }
      }
    /* We might need to shrink some windows to zero.  Find the smallest
--- 2903,2926 ----
    int i;
  
    new_sizes = xmalloc (sizeof (*new_sizes) * nchildren);
+   min_sizes = xmalloc (sizeof (*min_sizes) * nchildren);
  
    for (i = 0, child = forward; !NILP (child); child = c->next, ++i)
      {
        int child_size;
  
        c = XWINDOW (child);
!       child_size = WINDOW_TOTAL_SIZE (c, width_p);
  
!       if (!resize_fixed_p && window_fixed_size_p (c, width_p, 0))
          new_sizes[i] = -1;
        else
          {
            new_sizes[i] = child_size;
!           min_sizes[i] = window_min_size_1 (c, width_p, safe_p);
!           if (child_size > min_sizes[i]
!             && NILP (c->resize_proportionally))
!             available_resize += child_size - min_sizes[i];
          }
      }
    /* We might need to shrink some windows to zero.  Find the smallest
***************
*** 2927,2934 ****
            {
              /* Resize this window down to zero.  */
              new_sizes[i] = 0;
!             if (smallest > min_size)
!               available_resize -= smallest - min_size;
              available_resize += smallest;
              --shrinkable;
              total_removed += smallest;
--- 2937,2944 ----
            {
              /* Resize this window down to zero.  */
              new_sizes[i] = 0;
!             if (smallest > min_sizes[i])
!               available_resize -= smallest - min_sizes[i];
              available_resize += smallest;
              --shrinkable;
              total_removed += smallest;
***************
*** 2946,2956 ****
       proportional to its size.  */
    for (i = 0; i < nchildren; ++i)
      {
!       if (new_sizes[i] > min_size)
          {
!           int to_shrink = total_shrink*new_sizes[i]/total;
!           if (new_sizes[i] - to_shrink < min_size)
!             to_shrink = new_sizes[i] - min_size;
            new_sizes[i] -= to_shrink;
            total_removed += to_shrink;
          }
--- 2956,2967 ----
       proportional to its size.  */
    for (i = 0; i < nchildren; ++i)
      {
!       if (new_sizes[i] > min_sizes[i])
          {
!           int to_shrink = total_shrink * new_sizes[i] / total;
! 
!           if (new_sizes[i] - to_shrink < min_sizes[i])
!             to_shrink = new_sizes[i] - min_sizes[i];
            new_sizes[i] -= to_shrink;
            total_removed += to_shrink;
          }
***************
*** 2971,2977 ****
            }
  
        for (i = 0; i < nchildren; ++i)
!         if (new_sizes[i] > min_size)
            {
              --new_sizes[i];
              ++total_removed;
--- 2982,2988 ----
            }
  
        for (i = 0; i < nchildren; ++i)
!         if (new_sizes[i] > min_sizes[i])
            {
              --new_sizes[i];
              ++total_removed;
***************
*** 2981,2987 ****
              break;
            }
  
- 
        /* Special case, only one window left.  */
        if (nonzero_sizes == 1)
          break;
--- 2992,2997 ----
***************
*** 3001,3022 ****
          }
      }
  
    return new_sizes;
  }
  
  /* 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
!    keep their proportionate size relative to WINDOW.
  
     If FIRST_ONLY is 1, change only the first of WINDOW's children when
     they are in series.  If LAST_ONLY is 1, change only the last of
     WINDOW's children when they are in series.
  
     Propagate WINDOW's top or left edge position to children.  Delete
!    windows that become too small unless NODELETE_P is non-zero.
! 
!    If NODELETE_P is 2, that means we do delete windows that are
!    too small, even if they were too small before!  */
  
  static void
  size_window (window, size, width_p, nodelete_p, first_only, last_only)
--- 3011,3034 ----
          }
      }
  
+   xfree (min_sizes);
+ 
    return new_sizes;
  }
  
  /* 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 keep
!    their proportionate size relative to WINDOW.
  
     If FIRST_ONLY is 1, change only the first of WINDOW's children when
     they are in series.  If LAST_ONLY is 1, change only the last of
     WINDOW's children when they are in series.
  
     Propagate WINDOW's top or left edge position to children.  Delete
!    windows that become too small unless NODELETE_P is 1.  When
!    NODELETE_P equals 2 do not honor settings for window-min-height and
!    window-min-width when resizing windows but use safe defaults instead.
!    This should give better behavior when resizing frames.  */
  
  static void
  size_window (window, size, width_p, nodelete_p, first_only, last_only)
***************
*** 3027,3073 ****
    struct window *w = XWINDOW (window);
    struct window *c;
    Lisp_Object child, *forward, *sideward;
!   int old_size, min_size, safe_min_size;
  
-   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 = WINDOW_TOTAL_COLS (w);
!       min_size = window_min_width;
!       safe_min_size = window_min_size_2 (w, 1);
!     }
!   else
!     {
!       old_size = XINT (w->total_lines);
!       min_size = window_min_height;
!       safe_min_size = window_min_size_2 (w, 0);
!     }
! 
!   if (old_size < min_size && nodelete_p != 2)
!     w->too_small_ok = Qt;
! 
!   /* Move the following test here since otherwise the
!      preceding test doesn't make sense.  martin. */
!   if (nodelete_p == 2)
!     nodelete_p = 0;
! 
!   /* 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;
!       if (min_size < safe_min_size)
!       min_size = safe_min_size;
!       if (size < min_size)
!       {
!         delete_window (window);
!         return;
!       }
      }
  
    /* Set redisplay hints.  */
--- 3039,3054 ----
    struct window *w = XWINDOW (window);
    struct window *c;
    Lisp_Object child, *forward, *sideward;
!   int old_size = WINDOW_TOTAL_SIZE (w, width_p);
  
    size = max (0, size);
  
!   /* Delete WINDOW if it's too small.  */
!   if (nodelete_p != 1 && !NILP (w->parent)
!       && size < window_min_size_1 (w, width_p, nodelete_p == 2))
      {
!       delete_window (window);
!       return;
      }
  
    /* Set redisplay hints.  */
***************
*** 3117,3125 ****
          last_child = child;
        }
  
!       child_size = XINT (width_p ? c->total_cols : c->total_lines);
!       size_window (last_child,
!                  size - old_size + child_size,
                   width_p, nodelete_p, first_only, last_only);
      }
    else if (!NILP (*forward) && first_only)
--- 3098,3105 ----
          last_child = child;
        }
  
!       child_size = WINDOW_TOTAL_SIZE (c, width_p);
!       size_window (last_child, size - old_size + child_size,
                   width_p, nodelete_p, first_only, last_only);
      }
    else if (!NILP (*forward) && first_only)
***************
*** 3135,3143 ****
        else
        c->top_line = w->top_line;
  
!       child_size = XINT (width_p ? c->total_cols : c->total_lines);
!       size_window (child,
!                  size - old_size + child_size,
                   width_p, nodelete_p, first_only, last_only);
      }
    else if (!NILP (*forward))
--- 3115,3122 ----
        else
        c->top_line = w->top_line;
  
!       child_size = WINDOW_TOTAL_SIZE (c, width_p);
!       size_window (child, size - old_size + child_size,
                   width_p, nodelete_p, first_only, last_only);
      }
    else if (!NILP (*forward))
***************
*** 3155,3161 ****
          int child_size;
  
          c = XWINDOW (child);
!         child_size = width_p ? XINT (c->total_cols) : XINT (c->total_lines);
          total += child_size;
  
          if (window_fixed_size_p (c, width_p, 0))
--- 3134,3140 ----
          int child_size;
  
          c = XWINDOW (child);
!         child_size = WINDOW_TOTAL_SIZE (c, width_p);
          total += child_size;
  
          if (window_fixed_size_p (c, width_p, 0))
***************
*** 3174,3181 ****
         value of extra takes care of rounding errors.  */
        n = resize_fixed_p ? nchildren : nchildren - nfixed;
        if (size < total && n > 1)
!         new_sizes = shrink_windows (total, size, nchildren, n, min_size,
!                                     resize_fixed_p, *forward, width_p);
        else
          {
            each = (size - total) / n;
--- 3153,3161 ----
         value of extra takes care of rounding errors.  */
        n = resize_fixed_p ? nchildren : nchildren - nfixed;
        if (size < total && n > 1)
!         new_sizes = shrink_windows (total, size, nchildren, n,
!                                     resize_fixed_p, *forward, width_p,
!                                   nodelete_p == 2);
        else
          {
            each = (size - total) / n;
***************
*** 3190,3196 ****
          int new_size, old_size;
  
          c = XWINDOW (child);
!         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
--- 3170,3176 ----
          int new_size, old_size;
  
          c = XWINDOW (child);
!         old_size = WINDOW_TOTAL_SIZE (c, width_p);
          new_size = old_size;
  
          /* The top or left edge position of this child equals the
***************
*** 3207,3213 ****
              extra = 0;
            }
  
!         /* Set new height.  Note that size_window also propagates
             edge positions to children, so it's not a no-op if we
             didn't change the child's size.  */
          size_window (child, new_size, width_p, 1, first_only, last_only);
--- 3187,3193 ----
              extra = 0;
            }
  
!         /* Set new size.  Note that size_window also propagates
             edge positions to children, so it's not a no-op if we
             didn't change the child's size.  */
          size_window (child, new_size, width_p, 1, first_only, last_only);
***************
*** 3223,3243 ****
        xassert (size == last_pos - first_pos);
  
        /* Now delete any children that became too small.  */
!       if (!nodelete_p)
        for (child = *forward; !NILP (child); child = c->next)
          {
            int child_size;
            c = XWINDOW (child);
!           child_size = width_p ? XINT (c->total_cols) : XINT (c->total_lines);
!           size_window (child, child_size, width_p, 2, first_only, last_only);
          }
      }
  }
  
  /* Set WINDOW's height to HEIGHT, and recursively change the height of
!    WINDOW's children.  NODELETE non-zero means don't delete windows
!    that become too small in the process.  (The caller should check
!    later and do so if appropriate.)  */
  
  void
  set_window_height (window, height, nodelete)
--- 3203,3228 ----
        xassert (size == last_pos - first_pos);
  
        /* Now delete any children that became too small.  */
!       if (nodelete_p != 1)
        for (child = *forward; !NILP (child); child = c->next)
          {
            int child_size;
+ 
            c = XWINDOW (child);
!           child_size = WINDOW_TOTAL_SIZE (c, width_p);
!           size_window (child, child_size, width_p, nodelete_p,
!                        first_only, last_only);
          }
      }
  }
  
  /* Set WINDOW's height to HEIGHT, and recursively change the height of
!    WINDOW's children.  NODELETE zero means windows that have become
!    smaller than window-min-height in the process may be deleted.
!    NODELETE 1 means never delete windows that become too small in the
!    process.  (The caller should check later and do so if appropriate.)
!    NODELETE 2 means delete only windows that have become too small to be
!    displayed correctly.  */
  
  void
  set_window_height (window, height, nodelete)
***************
*** 3248,3258 ****
    size_window (window, height, 0, nodelete, 0, 0);
  }
  
- 
  /* Set WINDOW's width to WIDTH, and recursively change the width of
!    WINDOW's children.  NODELETE non-zero means don't delete windows
!    that become too small in the process.  (The caller should check
!    later and do so if appropriate.)  */
  
  void
  set_window_width (window, width, nodelete)
--- 3233,3245 ----
    size_window (window, height, 0, nodelete, 0, 0);
  }
  
  /* Set WINDOW's width to WIDTH, and recursively change the width of
!    WINDOW's children.  NODELETE zero means windows that have become
!    smaller than window-min-width in the process may be deleted.
!    NODELETE 1 means never delete windows that become too small in the
!    process.  (The caller should check later and do so if appropriate.)
!    NODELETE 2 means delete only windows that have become too small to be
!    displayed correctly.  */
  
  void
  set_window_width (window, width, nodelete)
***************
*** 3359,3365 ****
      }
        }
    }
!   
    run_funs (global_wcch);
    unbind_to (count, Qnil);
  }
--- 3346,3352 ----
      }
        }
    }
! 
    run_funs (global_wcch);
    unbind_to (count, Qnil);
  }
***************
*** 4124,4135 ****
    else if (window_fixed_size_p (o, !NILP (horflag), 0))
      error ("Attempt to split fixed-size window");
  
-   check_min_window_sizes ();
- 
    if (NILP (horflag))
      {
!       int window_safe_height = window_min_size_2 (o, 0);
!       
        if (size_int < window_safe_height)
        error ("Window height %d too small (after splitting)", size_int);
        if (size_int + window_safe_height > XFASTINT (o->total_lines))
--- 4111,4120 ----
    else if (window_fixed_size_p (o, !NILP (horflag), 0))
      error ("Attempt to split fixed-size window");
  
    if (NILP (horflag))
      {
!       int window_safe_height = window_min_size_2 (o, 0, 0);
! 
        if (size_int < window_safe_height)
        error ("Window height %d too small (after splitting)", size_int);
        if (size_int + window_safe_height > XFASTINT (o->total_lines))
***************
*** 4145,4152 ****
      }
    else
      {
!       int window_safe_width = window_min_size_2 (o, 1);
!       
        if (size_int < window_safe_width)
        error ("Window width %d too small (after splitting)", size_int);
        if (size_int + window_safe_width > XFASTINT (o->total_cols))
--- 4130,4137 ----
      }
    else
      {
!       int window_safe_width = window_min_size_2 (o, 1, 0);
! 
        if (size_int < window_safe_width)
        error ("Window width %d too small (after splitting)", size_int);
        if (size_int + window_safe_width > XFASTINT (o->total_cols))
***************
*** 4277,4288 ****
    *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
  
  
! /* Enlarge WINDOW by DELTA.
!    HORIZ_FLAG nonzero means enlarge it horizontally;
!    zero means do it vertically.
  
     Siblings of the selected window are resized to fulfill the size
!    request.  If they become too small in the process, they will be
     deleted.  */
  
  static void
--- 4262,4272 ----
    *(horiz_flag ? &(XWINDOW (w)->total_cols) : &(XWINDOW (w)->total_lines))
  
  
! /* Enlarge WINDOW by DELTA.  HORIZ_FLAG nonzero means enlarge it
!    horizontally; zero means do it vertically.
  
     Siblings of the selected window are resized to fulfill the size
!    request.  If they become too small in the process, they may be
     deleted.  */
  
  static void
***************
*** 4299,4308 ****
    void (*setsizefun) P_ ((Lisp_Object, int, int))
      = (horiz_flag ? set_window_width : set_window_height);
  
-   /* Check values of window_min_width and window_min_height for
-      validity.  */
-   check_min_window_sizes ();
- 
    /* Give up if this window cannot be resized.  */
    if (window_fixed_size_p (XWINDOW (window), horiz_flag, 1))
      error ("Window is not resizable");
--- 4283,4288 ----
***************
*** 4339,4349 ****
                /* This is a main window followed by a minibuffer.  */
                : !NILP (p->next) ? ((*sizefun) (p->next)
                                     - window_min_size (XWINDOW (p->next),
!                                                       horiz_flag, 0, 0))
                /* This is a minibuffer following a main window.  */
                : !NILP (p->prev) ? ((*sizefun) (p->prev)
                                     - window_min_size (XWINDOW (p->prev),
!                                                       horiz_flag, 0, 0))
                /* This is a frame with only one window, a minibuffer-only
                   or a minibufferless frame.  */
                : (delta = 0));
--- 4319,4329 ----
                /* This is a main window followed by a minibuffer.  */
                : !NILP (p->next) ? ((*sizefun) (p->next)
                                     - window_min_size (XWINDOW (p->next),
!                                                       horiz_flag, 0, 0, 0))
                /* This is a minibuffer following a main window.  */
                : !NILP (p->prev) ? ((*sizefun) (p->prev)
                                     - window_min_size (XWINDOW (p->prev),
!                                                       horiz_flag, 0, 0, 0))
                /* This is a frame with only one window, a minibuffer-only
                   or a minibufferless frame.  */
                : (delta = 0));
***************
*** 4355,4361 ****
        delta = maxdelta;
    }
  
!   if (XINT (*sizep) + delta < window_min_size (XWINDOW (window), horiz_flag, 
0, 0))
      {
        delete_window (window);
        return;
--- 4335,4342 ----
        delta = maxdelta;
    }
  
!   if (XINT (*sizep) + delta < window_min_size (XWINDOW (window),
!                                              horiz_flag, 0, 0, 0))
      {
        delete_window (window);
        return;
***************
*** 4368,4377 ****
    maximum = 0;
    for (next = p->next; WINDOWP (next); next = XWINDOW (next)->next)
      maximum += (*sizefun) (next) - window_min_size (XWINDOW (next),
!                                                   horiz_flag, 0, 0);
    for (prev = p->prev; WINDOWP (prev); prev = XWINDOW (prev)->prev)
      maximum += (*sizefun) (prev) - window_min_size (XWINDOW (prev),
!                                                   horiz_flag, 0, 0);
  
    /* If we can get it all from them without deleting them, do so.  */
    if (delta <= maximum)
--- 4349,4358 ----
    maximum = 0;
    for (next = p->next; WINDOWP (next); next = XWINDOW (next)->next)
      maximum += (*sizefun) (next) - window_min_size (XWINDOW (next),
!                                                   horiz_flag, 0, 0, 0);
    for (prev = p->prev; WINDOWP (prev); prev = XWINDOW (prev)->prev)
      maximum += (*sizefun) (prev) - window_min_size (XWINDOW (prev),
!                                                   horiz_flag, 0, 0, 0);
  
    /* If we can get it all from them without deleting them, do so.  */
    if (delta <= maximum)
***************
*** 4392,4399 ****
          if (! NILP (next))
            {
              int this_one = ((*sizefun) (next)
!                             - window_min_size (XWINDOW (next),
!                                                horiz_flag, 0, &fixed_p));
              if (!fixed_p)
                {
                  if (this_one > delta)
--- 4373,4380 ----
          if (! NILP (next))
            {
              int this_one = ((*sizefun) (next)
!                             - window_min_size (XWINDOW (next), horiz_flag,
!                                                0, 0, &fixed_p));
              if (!fixed_p)
                {
                  if (this_one > delta)
***************
*** 4414,4421 ****
          if (! NILP (prev))
            {
              int this_one = ((*sizefun) (prev)
!                             - window_min_size (XWINDOW (prev),
!                                                horiz_flag, 0, &fixed_p));
              if (!fixed_p)
                {
                  if (this_one > delta)
--- 4395,4402 ----
          if (! NILP (prev))
            {
              int this_one = ((*sizefun) (prev)
!                             - window_min_size (XWINDOW (prev), horiz_flag,
!                                                0, 0, &fixed_p));
              if (!fixed_p)
                {
                  if (this_one > delta)
***************
*** 4474,4480 ****
  
          /* Delete any siblings that come after WINDOW.
             Note that if START is not WINDOW, then WINDOW still
!            Fhas siblings, so WINDOW has not yet replaced its parent.  */
          tem = start;
          while (! EQ (tem, window))
            {
--- 4455,4461 ----
  
          /* Delete any siblings that come after WINDOW.
             Note that if START is not WINDOW, then WINDOW still
!            has siblings, so WINDOW has not yet replaced its parent.  */
          tem = start;
          while (! EQ (tem, window))
            {
***************
*** 4511,4517 ****
  
             The number of children n equals the number of resizable
             children of this window + 1 because we know window itself
!            is resizable (otherwise we would have signalled an error).  */
  
          struct window *w = XWINDOW (window);
          Lisp_Object s;
--- 4492,4502 ----
  
             The number of children n equals the number of resizable
             children of this window + 1 because we know window itself
!            is resizable (otherwise we would have signalled an error).
! 
!            This reasoning is not correct when other windows become too
!            small and shrink_windows refuses to delete them.  Below we
!            use resize_proportionally to work around this problem.  */
  
          struct window *w = XWINDOW (window);
          Lisp_Object s;
***************
*** 4532,4543 ****
          (*setsizefun) (window, XINT (*sizep) + delta1, 0);
  
          /* Squeeze out delta1 lines or columns from our parent,
!            shriking this window and siblings proportionately.
!            This brings parent back to correct size.
!            Delta1 was calculated so this makes this window the desired size,
!            taking it all out of the siblings.  */
          (*setsizefun) (parent, opht, 0);
! 
        }
      }
  
--- 4517,4533 ----
          (*setsizefun) (window, XINT (*sizep) + delta1, 0);
  
          /* Squeeze out delta1 lines or columns from our parent,
!            shrinking this window and siblings proportionately.  This
!            brings parent back to correct size.  Delta1 was calculated
!            so this makes this window the desired size, taking it all
!            out of the siblings.
! 
!            Temporarily set resize_proportionally to Qt to assure that,
!            if necessary, shrink_windows deletes smaller windows rather
!            than shrink this window.  */
!         w->resize_proportionally = Qt;
          (*setsizefun) (parent, opht, 0);
!         w->resize_proportionally = Qnil;
        }
      }
  
***************
*** 4567,4576 ****
    Lisp_Object old_config = Fcurrent_window_configuration (Qnil);
    int delcount = window_deletion_count;
  
-   /* Check values of window_min_width and window_min_height for
-      validity.  */
-   check_min_window_sizes ();
- 
    CHECK_WINDOW (window);
  
    /* Give up if this window cannot be resized.  */
--- 4557,4562 ----
***************
*** 4625,4631 ****
  
        /* Don't make this window too small.  */
        if (XINT (CURSIZE (window)) + delta
!         < window_min_size_2 (XWINDOW (window), horiz_flag))
        {
          Fset_window_configuration (old_config);
          error ("Cannot adjust window size as specified");
--- 4611,4617 ----
  
        /* Don't make this window too small.  */
        if (XINT (CURSIZE (window)) + delta
!         < window_min_size_2 (XWINDOW (window), horiz_flag, 0))
        {
          Fset_window_configuration (old_config);
          error ("Cannot adjust window size as specified");
***************
*** 4778,4790 ****
        for (child = w->vchild; WINDOWP (child); child = XWINDOW (child)->next)
        last_child = child;
  
!       /* Assign new heights.  We leave only MIN_SAFE_WINDOW_HEIGHT.  */
        for (child = last_child; delta && !NILP (child); child = c->prev)
        {
          int this_one;
  
          c = XWINDOW (child);
!         this_one = XFASTINT (c->total_lines) - MIN_SAFE_WINDOW_HEIGHT;
  
          if (this_one > delta)
            this_one = delta;
--- 4764,4776 ----
        for (child = w->vchild; WINDOWP (child); child = XWINDOW (child)->next)
        last_child = child;
  
!       /* Size children down to their safe heights.  */
        for (child = last_child; delta && !NILP (child); child = c->prev)
        {
          int this_one;
  
          c = XWINDOW (child);
!         this_one = XFASTINT (c->total_lines) - window_min_size_1 (c, 0, 1);
  
          if (this_one > delta)
            this_one = delta;
***************
*** 4887,4902 ****
    xassert (MINI_WINDOW_P (w));
    xassert (delta >= 0);
  
-   /* Check values of window_min_width and window_min_height for
-      validity.  */
-   check_min_window_sizes ();
- 
    /* Compute how much we can enlarge the mini-window without deleting
       other windows.  */
    root = XWINDOW (FRAME_ROOT_WINDOW (f));
    if (delta)
      {
!       int min_height = window_min_size (root, 0, 0, 0);
        if (XFASTINT (root->total_lines) - delta < min_height)
        /* Note that the root window may already be smaller than
           min_height.  */
--- 4873,4884 ----
    xassert (MINI_WINDOW_P (w));
    xassert (delta >= 0);
  
    /* Compute how much we can enlarge the mini-window without deleting
       other windows.  */
    root = XWINDOW (FRAME_ROOT_WINDOW (f));
    if (delta)
      {
!       int min_height = window_min_size (root, 0, 0, 0, 0);
        if (XFASTINT (root->total_lines) - delta < min_height)
        /* Note that the root window may already be smaller than
           min_height.  */
***************
*** 6164,6170 ****
    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;
!   Lisp_Object dedicated;
  };
  
  #define SAVED_WINDOW_N(swv,n) \
--- 6146,6152 ----
    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;
!   Lisp_Object dedicated, resize_proportionally;
  };
  
  #define SAVED_WINDOW_N(swv,n) \
***************
*** 6327,6337 ****
                                     * sizeof (struct window *));
        n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
  
-       /* Temporarily avoid any problems with windows that are smaller
-        than they are supposed to be.  */
-       window_min_height = 1;
-       window_min_width = 1;
- 
        /* Kludge Alert!
         Mark all windows now on frame as "deleted".
         Restoring the new configuration "undeletes" any that are in it.
--- 6309,6314 ----
***************
*** 6398,6403 ****
--- 6375,6381 ----
          w->scroll_bar_width = p->scroll_bar_width;
          w->vertical_scroll_bar_type = p->vertical_scroll_bar_type;
          w->dedicated = p->dedicated;
+         w->resize_proportionally = p->resize_proportionally;
          XSETFASTINT (w->last_modified, 0);
          XSETFASTINT (w->last_overlay_modified, 0);
  
***************
*** 6527,6536 ****
    if (!NILP (new_current_buffer))
      Fset_buffer (new_current_buffer);
  
-   /* Restore the minimum heights recorded in the configuration.  */
-   window_min_height = data->min_height;
-   window_min_width = data->min_width;
- 
    Vminibuf_scroll_window = data->minibuf_scroll_window;
    minibuf_selected_window = data->minibuf_selected_window;
  
--- 6505,6510 ----
***************
*** 6666,6671 ****
--- 6640,6646 ----
        p->scroll_bar_width = w->scroll_bar_width;
        p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
        p->dedicated = w->dedicated;
+       p->resize_proportionally = w->resize_proportionally;
        if (!NILP (w->buffer))
        {
          /* Save w's value of point in the window configuration.
***************
*** 6753,6760 ****
    data->minibuf_selected_window = minibuf_level > 0 ? minibuf_selected_window 
: Qnil;
    data->root_window = FRAME_ROOT_WINDOW (f);
    data->focus_frame = FRAME_FOCUS_FRAME (f);
-   data->min_height = window_min_height;
-   data->min_width = window_min_width;
    tem = Fmake_vector (make_number (n_windows), Qnil);
    data->saved_windows = tem;
    for (i = 0; i < n_windows; i++)
--- 6728,6733 ----
***************
*** 7611,7622 ****
    Vsplit_window_preferred_function = Qnil;
  
    DEFVAR_INT ("window-min-height", &window_min_height,
!             doc: /* *Delete any window less than this tall (including its 
mode line).
! The value is in line units. */);
    window_min_height = 4;
  
    DEFVAR_INT ("window-min-width", &window_min_width,
!             doc: /* *Delete any window less than this wide (measured in 
characters).  */);
    window_min_width = 10;
  
    DEFVAR_LISP ("scroll-preserve-screen-position",
--- 7584,7604 ----
    Vsplit_window_preferred_function = Qnil;
  
    DEFVAR_INT ("window-min-height", &window_min_height,
!             doc: /* Allow deleting windows less than this tall.
! The value is measured in line units.  If a window wants a modeline it
! is counted as one line.
! 
! Emacs honors settings of this variable when enlarging or shrinking
! windows vertically.  A value less than 1 is invalid.  */);
    window_min_height = 4;
  
    DEFVAR_INT ("window-min-width", &window_min_width,
!             doc: /* Allow deleting windows less than this wide.
! The value is measured in characters and includes any fringes or
! the scrollbar.
! 
! Emacs honors settings of this variable when enlarging or shrinking
! windows horizontally.  A value less than 2 is invalid.  */);
    window_min_width = 10;
  
    DEFVAR_LISP ("scroll-preserve-screen-position",



reply via email to

[Prev in Thread] Current Thread [Next in Thread]