emacs: src/window.c comparison

comparison src/window.c @ 90488:4094c5298ae1

Merge from emacs--devo--0 Patches applied: * emacs--devo--0 (patch 314-319) - Update from CVS - Merge from gnus--rel--5.10 * gnus--rel--5.10 (patch 107) - Update from CVS Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-78

author	Miles Bader <miles@gnu.org>
date	Tue, 20 Jun 2006 07:35:06 +0000
parents	138027c8c982 58383949ec48
children	8a8e69664178

comparison

equal deleted inserted replaced

-:ef80dfaa8269
+:4094c5298ae1
 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 P_ ((struct window *, int, int, int *));
-static void size_window P_ ((Lisp_Object, 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));
 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 *));
 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.  Propagate
+keep their proportionate size relative to WINDOW.
-WINDOW's top or left edge position to children.  Delete windows
-that become too small unless NODELETE_P is non-zero.
+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)
+size_window (window, size, width_p, nodelete_p, first_only, last_only)
 Lisp_Object window;
 int size, width_p, nodelete_p;
+int first_only, last_only;
 {
 struct window *w = XWINDOW (window);
 struct window *c;
 Lisp_Object child, *forward, *sideward;
 int old_size, min_size, safe_min_size;
 w->orig_total_lines = Qnil;
 }
 if (!NILP (*sideward))
 {
+/* We have a chain of parallel siblings whose size should all change.  */
 for (child = *sideward; !NILP (child); child = c->next)
 	{
 	  c = XWINDOW (child);
 	  if (width_p)
 	    c->left_col = w->left_col;
 	  else
 	    c->top_line = w->top_line;
-	  size_window (child, size, width_p, nodelete_p);
+	  size_window (child, size, width_p, nodelete_p,
-	}
+		       first_only, last_only);
+	}
+}
+else if (!NILP (*forward) && last_only)
+{
+/* Change the last in a series of siblings.  */
+Lisp_Object last_child;
+int child_size;
+for (child = *forward; !NILP (child); child = c->next)
+	{
+	  c = XWINDOW (child);
+	  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)
+{
+/* Change the first in a series of siblings.  */
+int child_size;
+child = *forward;
+c = XWINDOW (child);
+if (width_p)
+	c->left_col = w->left_col;
+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))
 {
 int fixed_size, each, extra, n;
 int resize_fixed_p, nfixed;
 int last_pos, first_pos, nchildren, total;
 int *new_sizes = NULL;
-/* Determine the fixed-size portion of the this window, and the
+/* Determine the fixed-size portion of this window, and the
 	 number of child windows.  */
 fixed_size = nchildren = nfixed = total = 0;
 for (child = *forward; !NILP (child); child = c->next, ++nchildren)
 	{
 	  int child_size;
 	    }
 	  /* 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);
+	  size_window (child, new_size, width_p, 1, first_only, last_only);
 	  /* Remember the bottom/right edge position of this child; it
 	     will be used to set the top/left edge of the next child.  */
 last_pos += new_size;
 	}
 	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);
+	    size_window (child, child_size, width_p, 2, first_only, last_only);
 	  }
 }
 }
 /* Set WINDOW's height to HEIGHT, and recursively change the height of
 set_window_height (window, height, nodelete)
 Lisp_Object window;
 int height;
 int nodelete;
 {
-size_window (window, height, 0, nodelete);
+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
 set_window_width (window, width, nodelete)
 Lisp_Object window;
 int width;
 int nodelete;
 {
-size_window (window, width, 1, nodelete);
+size_window (window, width, 1, nodelete, 0, 0);
 }
 /* Change window heights in windows rooted in WINDOW by N lines.  */
 void
 {
 Lisp_Object first_parallel = Qnil;
 if (NILP (window))
 	{
-	  /* This can happen if WINDOW on the previous iteration was
+	  /* This happens if WINDOW on the previous iteration was
-	     at top level of the tree and we did not exit.  */
+	     at top level of the window tree.  */
 	  Fset_window_configuration (old_config);
 	  error ("Specified window edge is fixed");
 	}
 p = XWINDOW (window);
 	 direction.  If so, set FIRST_PARALLEL to the first one.  */
 if (horiz_flag)
 	{
 	  if (! NILP (parent) && !NILP (XWINDOW (parent)->vchild))
 	    first_parallel = XWINDOW (parent)->vchild;
+	  else if (NILP (parent) && !NILP (p->next))
+	    {
+	      /* Handle the vertical chain of main window and minibuffer
+		 which has no parent.  */
+	      first_parallel = window;
+	      while (! NILP (XWINDOW (first_parallel)->prev))
+		first_parallel = XWINDOW (first_parallel)->prev;
+	    }
 	}
 else
 	{
 	  if (! NILP (parent) && !NILP (XWINDOW (parent)->hchild))
 	    first_parallel = XWINDOW (parent)->hchild;
 	}
 /* If this level's succession is in the desired dimension,
-	 and this window is the last one, its trailing edge is fixed.  */
+	 and this window is the last one, and there is no higher level,
-if (NILP (XWINDOW (window)->next) && NILP (first_parallel))
+	 its trailing edge is fixed.  */
+if (NILP (XWINDOW (window)->next) && NILP (first_parallel)
+	  && NILP (parent))
 	{
 	  Fset_window_configuration (old_config);
 	  error ("Specified window edge is fixed");
 	}
 }
 	      XSETINT (CURBEG (p->next),
 		       XINT (CURBEG (p->next)) + delta);
 	      size_window (p->next, XINT (CURSIZE (p->next)) - delta,
-			   horiz_flag, 0);
+			   horiz_flag, 0, 1, 0);
 	      break;
 	    }
 	}
 else
 	/* Here we have a chain of parallel siblings, in the other dimension.
 	for (child = first_parallel;
 	     ! NILP (child);
 	     child = XWINDOW (child)->next)
 	  if (! EQ (child, window))
 	    size_window (child, XINT (CURSIZE (child)) + delta,
-			 horiz_flag, 0);
+			 horiz_flag, 0, 0, 1);
 window = parent;
 }
 /* If we made a window so small it got deleted,

Mercurial > emacs

comparison src/window.c @ 90488:4094c5298ae1