[Emacs-diffs] Changes to emacs/src/window.c

[Richard M. Stallman]

Index: emacs/src/window.c
diff -c emacs/src/window.c:1.394 emacs/src/window.c:1.395
*** emacs/src/window.c:1.394    Sun Dec 16 15:01:48 2001
--- emacs/src/window.c  Tue Dec 25 05:36:08 2001
***************
*** 79,85 ****
  static void size_window P_ ((Lisp_Object, int, int, int));
  static int freeze_window_start P_ ((struct window *, void *));
  static int window_fixed_size_p P_ ((struct window *, int, int));
! static void enlarge_window P_ ((Lisp_Object, int, int));
  static Lisp_Object window_list P_ ((void));
  static int add_window_to_list P_ ((struct window *, void *));
  static int candidate_window_p P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
--- 79,85 ----
  static void size_window P_ ((Lisp_Object, int, int, int));
  static int freeze_window_start P_ ((struct window *, void *));
  static int window_fixed_size_p P_ ((struct window *, int, int));
! static void enlarge_window P_ ((Lisp_Object, int, int, int));
  static Lisp_Object window_list P_ ((void));
  static int add_window_to_list P_ ((struct window *, void *));
  static int candidate_window_p P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
***************
*** 3043,3049 ****
                           + XFASTINT (XWINDOW (window)->height));
              enlarge_window (upper,
                              total / 2 - XFASTINT (XWINDOW (upper)->height),
!                             0);
            }
        }
      }
--- 3043,3049 ----
                           + XFASTINT (XWINDOW (window)->height));
              enlarge_window (upper,
                              total / 2 - XFASTINT (XWINDOW (upper)->height),
!                             0, 0);
            }
        }
      }
***************
*** 3269,3283 ****
    return new;
  }
  
! DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 2, "p",
         doc: /* Make current window ARG lines bigger.
  From program, optional second arg non-nil means grow sideways ARG columns.
! Interactively, if an argument is not given, make the window one line bigger.  
*/)
!      (arg, side)
!      register Lisp_Object arg, side;
  {
    CHECK_NUMBER (arg);
!   enlarge_window (selected_window, XINT (arg), !NILP (side));
  
    if (! NILP (Vwindow_configuration_change_hook))
      call1 (Vrun_hooks, Qwindow_configuration_change_hook);
--- 3269,3288 ----
    return new;
  }
  
! DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 3, "p",
         doc: /* Make current window ARG lines bigger.
  From program, optional second arg non-nil means grow sideways ARG columns.
! Interactively, if an argument is not given, make the window one line bigger.
! 
! Optional third arg PRESERVE-BEFORE, if non-nil, means do not change the size
! of the siblings above or to the left of the selected window.  Only
! siblings to the right or below are changed.  */)
!      (arg, side, preserve_before)
!      register Lisp_Object arg, side, preserve_before;
  {
    CHECK_NUMBER (arg);
!   enlarge_window (selected_window, XINT (arg), !NILP (side),
!                 !NILP (preserve_before));
  
    if (! NILP (Vwindow_configuration_change_hook))
      call1 (Vrun_hooks, Qwindow_configuration_change_hook);
***************
*** 3293,3299 ****
       register Lisp_Object arg, side;
  {
    CHECK_NUMBER (arg);
!   enlarge_window (selected_window, -XINT (arg), !NILP (side));
  
    if (! NILP (Vwindow_configuration_change_hook))
      call1 (Vrun_hooks, Qwindow_configuration_change_hook);
--- 3298,3304 ----
       register Lisp_Object arg, side;
  {
    CHECK_NUMBER (arg);
!   enlarge_window (selected_window, -XINT (arg), !NILP (side), 0);
  
    if (! NILP (Vwindow_configuration_change_hook))
      call1 (Vrun_hooks, Qwindow_configuration_change_hook);
***************
*** 3325,3339 ****
    *(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
  
  
! /* Enlarge selected_window by DELTA.  WIDTHFLAG non-zero means
     increase its width.  Siblings of the selected window are resized to
!    fullfil the size request.  If they become too small in the process,
!    they will be deleted.  */
  
  static void
! enlarge_window (window, delta, widthflag)
       Lisp_Object window;
!      int delta, widthflag;
  {
    Lisp_Object parent, next, prev;
    struct window *p;
--- 3330,3347 ----
    *(widthflag ? &(XWINDOW (w)->width) : &(XWINDOW (w)->height))
  
  
! /* 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,
!    they will be deleted.
! 
!    If PRESERVE_BEFORE is nonzero, that means don't alter
!    the siblings to the left or above WINDOW.  */
  
  static void
! enlarge_window (window, delta, widthflag, preserve_before)
       Lisp_Object window;
!      int delta, widthflag, preserve_before;
  {
    Lisp_Object parent, next, prev;
    struct window *p;
***************
*** 3378,3393 ****
    {
      register int maxdelta;
  
!     maxdelta = (!NILP (parent) ? (*sizefun) (parent) - XINT (*sizep)
!               : !NILP (p->next) ? ((*sizefun) (p->next)
!                                    - window_min_size (XWINDOW (p->next),
!                                                       widthflag, 0, 0))
!               : !NILP (p->prev) ? ((*sizefun) (p->prev)
!                                    - window_min_size (XWINDOW (p->prev),
!                                                       widthflag, 0, 0))
!               /* This is a frame with only one window, a minibuffer-only
!                  or a minibufferless frame.  */
!               : (delta = 0));
  
      if (delta > maxdelta)
        /* This case traps trying to make the minibuffer
--- 3386,3420 ----
    {
      register int maxdelta;
  
!     /* Compute the maximum size increment this window can have.  */
! 
!     if (preserve_before)
!       {
!       if (!NILP (parent))
!         {
!           maxdelta = (*sizefun) (parent) - XINT (*sizep);
!           /* Subtract size of siblings before, since we can't take that.  */
!           maxdelta -= CURBEG (window) - CURBEG (parent);
!         }
!       else
!         maxdelta = (!NILP (p->next) ? ((*sizefun) (p->next)
!                                        - window_min_size (XWINDOW (p->next),
!                                                           widthflag, 0, 0))
!                     : (delta = 0));
!       }
!     else
!       maxdelta = (!NILP (parent) ? (*sizefun) (parent) - XINT (*sizep)
!                 /* This is a main window followed by a minibuffer.  */
!                 : !NILP (p->next) ? ((*sizefun) (p->next)
!                                      - window_min_size (XWINDOW (p->next),
!                                                         widthflag, 0, 0))
!                 /* This is a minibuffer following a main window.  */
!                 : !NILP (p->prev) ? ((*sizefun) (p->prev)
!                                      - window_min_size (XWINDOW (p->prev),
!                                                         widthflag, 0, 0))
!                 /* This is a frame with only one window, a minibuffer-only
!                    or a minibufferless frame.  */
!                 : (delta = 0));
  
      if (delta > maxdelta)
        /* This case traps trying to make the minibuffer
***************
*** 3405,3420 ****
    if (delta == 0)
      return;
  
!   /* Find the total we can get from other siblings.  */
    maximum = 0;
    for (next = p->next; ! NILP (next); next = XWINDOW (next)->next)
      maximum += (*sizefun) (next) - window_min_size (XWINDOW (next),
                                                    widthflag, 0, 0);
!   for (prev = p->prev; ! NILP (prev); prev = XWINDOW (prev)->prev)
!     maximum += (*sizefun) (prev) - window_min_size (XWINDOW (prev),
!                                                   widthflag, 0, 0);
  
!   /* If we can get it all from them, do so.  */
    if (delta <= maximum)
      {
        Lisp_Object first_unaffected;
--- 3432,3448 ----
    if (delta == 0)
      return;
  
!   /* Find the total we can get from other siblings without deleting them.  */
    maximum = 0;
    for (next = p->next; ! NILP (next); next = XWINDOW (next)->next)
      maximum += (*sizefun) (next) - window_min_size (XWINDOW (next),
                                                    widthflag, 0, 0);
!   if (! preserve_before)
!     for (prev = p->prev; ! NILP (prev); prev = XWINDOW (prev)->prev)
!       maximum += (*sizefun) (prev) - window_min_size (XWINDOW (prev),
!                                                     widthflag, 0, 0);
  
!   /* If we can get it all from them without deleting them, do so.  */
    if (delta <= maximum)
      {
        Lisp_Object first_unaffected;
***************
*** 3427,3433 ****
        /* Look at one sibling at a time,
         moving away from this window in both directions alternately,
         and take as much as we can get without deleting that sibling.  */
!       while (delta != 0 && (!NILP (next) || !NILP (prev)))
        {
          if (! NILP (next))
            {
--- 3455,3462 ----
        /* Look at one sibling at a time,
         moving away from this window in both directions alternately,
         and take as much as we can get without deleting that sibling.  */
!       while (delta != 0
!            && (!NILP (next) || (!preserve_before && !NILP (prev))))
        {
          if (! NILP (next))
            {
***************
*** 3451,3457 ****
          if (delta == 0)
            break;
          
!         if (! NILP (prev))
            {
              int this_one = ((*sizefun) (prev)
                              - window_min_size (XWINDOW (prev),
--- 3480,3486 ----
          if (delta == 0)
            break;
          
!         if (!preserve_before && ! NILP (prev))
            {
              int this_one = ((*sizefun) (prev)
                              - window_min_size (XWINDOW (prev),
***************
*** 3799,3805 ****
         among the other windows.  */
        Lisp_Object window;
        XSETWINDOW (window, w);
!       enlarge_window (window, 1 - XFASTINT (w->height), 0);
      }
  }
  
--- 3828,3834 ----
         among the other windows.  */
        Lisp_Object window;
        XSETWINDOW (window, w);
!       enlarge_window (window, 1 - XFASTINT (w->height), 0, 0);
      }
  }