xemacs-beta: src/frame.c comparison

comparison src/frame.c @ 371:cc15677e0335 r21-2b1

Import from CVS: tag r21-2b1

author	cvs
date	Mon, 13 Aug 2007 11:03:08 +0200
parents	a4f53d9b3154
children	8626e4521993

comparison

equal deleted inserted replaced

-:bd866891f083
+:cc15677e0335
 return 1;
 }
 int
-device_matches_console_spec (Lisp_Object device, Lisp_Object console)
+device_matches_console_spec (Lisp_Object frame, Lisp_Object device,
+			     Lisp_Object console)
 {
 if (EQ (console, Qwindow_system))
 return DEVICE_WIN_P (XDEVICE (device));
+if (NILP (console))
+console = (DEVICE_CONSOLE (XDEVICE (FRAME_DEVICE (XFRAME (frame)))));
 if (DEVICEP (console))
 return EQ (device, console);
 if (CONSOLEP (console))
 return EQ (DEVICE_CONSOLE (XDEVICE (device)), console);
 if (valid_console_type_p (console))
 /* Return the next frame in the frame list after FRAME.
 FRAMETYPE and CONSOLE control which frames and devices
 are considered; see `next-frame'. */
-Lisp_Object
+static Lisp_Object
-next_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
+next_frame_internal (Lisp_Object frame, Lisp_Object frametype,
-{
+		     Lisp_Object console, int called_from_delete_device)
-Lisp_Object first = Qnil;
+{
-Lisp_Object devcons, concons;
 int passed = 0;
+int started_over = 0;
+/* If this frame is dead, it won't be in frame_list, and we'll loop
+forever.  Forestall that.  */
 CHECK_LIVE_FRAME (frame);
+while (1)
+{
+Lisp_Object devcons, concons;
 DEVICE_LOOP_NO_BREAK (devcons, concons)
 	{
 	  Lisp_Object device = XCAR (devcons);
 	  Lisp_Object frmcons;
-if (!device_matches_console_spec (device, console))
+	  if (!device_matches_console_spec (frame, device, console))
-	    {
-	      if (EQ (device, FRAME_DEVICE (XFRAME (frame))))
-		passed = 1;
 	    continue;
-	    }
 	  DEVICE_FRAME_LOOP (frmcons, XDEVICE (device))
 	    {
 	      Lisp_Object f = XCAR (frmcons);
 	      if (passed)
 		{
+		  /* #### Doing this here is bad and is now
+unnecessary.  The real bug was that f->iconified
+was never, ever updated unless a user explicitly
+called frame-iconified-p.  That has now been
+fixed.  With this change removed all of the other
+changes made to support this routine having the
+called_from_delete_device arg could be removed.
+But it is too close to release to do that now. */
+#if 0
+		  /* Make sure the visibility and iconified flags are
+up-to-date unless we're being deleted. */
+		  if (!called_from_delete_device)
+		    {
+		      Fframe_iconified_p (f);
+		      Fframe_visible_p (f);
+		    }
+#endif
+		  /* Decide whether this frame is eligible to be returned.  */
+		  /* If we've looped all the way around without finding any
+		     eligible frames, return the original frame.  */
+		  if (EQ (f, frame))
+		    return f;
 		  if (frame_matches_frametype (f, frametype))
 		    return f;
 		}
-	  else
-	    {
 	      if (EQ (frame, f))
-		{
+		passed++;
-		passed = 1;
 	    }
-	      else
-		{
-		  if (NILP (first) && frame_matches_frametype (f, frametype))
-		    first = f;
-		}
 	}
-}
+/* We hit the end of the list, and need to start over again. */
-}
+if (started_over)
+	return Qnil;
-if (NILP (first))
+started_over++;
-/* We went through the whole frame list without finding a single
+}
-acceptable frame.  Return the original frame.  */
+}
-return frame;
-else
+Lisp_Object
-/* There were no acceptable frames in the list after FRAME; otherwise,
+next_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
-we would have returned directly from the loop.  Since FIRST is the last
+{
-acceptable frame in the list, return it.  */
+return next_frame_internal (frame, frametype, console, 0);
-return first;
 }
 /* Return the previous frame in the frame list before FRAME.
 FRAMETYPE and CONSOLE control which frames and devices
 are considered; see `next-frame'. */
 Lisp_Object
-previous_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
+prev_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
 {
 Lisp_Object devcons, concons;
-Lisp_Object last = Qnil;
+Lisp_Object prev;
+/* If this frame is dead, it won't be in frame_list, and we'll loop
+forever.  Forestall that.  */
 CHECK_LIVE_FRAME (frame);
+prev = Qnil;
 DEVICE_LOOP_NO_BREAK (devcons, concons)
 {
 Lisp_Object device = XCAR (devcons);
 Lisp_Object frmcons;
-if (!device_matches_console_spec (device, console))
+if (!device_matches_console_spec (frame, device, console))
-	{
-	  if (EQ (device, FRAME_DEVICE (XFRAME (frame)))
-	      && !NILP (last))
-	    return last;
 	continue;
-	}
 DEVICE_FRAME_LOOP (frmcons, XDEVICE (device))
 	{
 	  Lisp_Object f = XCAR (frmcons);
-	  if (EQ (frame, f))
+	  if (EQ (frame, f) && !NILP (prev))
-	    {
+	    return prev;
-	      if (!NILP (last))
-		return last;
+	  /* Decide whether this frame is eligible to be returned,
-	    }
+	     according to frametype.  */
-	  else
-	    {
 	  if (frame_matches_frametype (f, frametype))
-		last = f;
+	    prev = f;
 	}
 }
-}
+/* We've scanned the entire list.  */
-if (NILP (last))
+if (NILP (prev))
 /* We went through the whole frame list without finding a single
 acceptable frame.  Return the original frame.  */
 return frame;
 else
 /* There were no acceptable frames in the list before FRAME; otherwise,
-we would have returned directly from the loop.  Since LAST is the last
+we would have returned directly from the loop.  Since PREV is the last
 acceptable frame in the list, return it.  */
-return last;
+return prev;
 }
 DEFUN ("next-frame", Fnext_frame, 0, 3, 0, /*
 Return the next frame of the right type in the frame list after FRAME.
 FRAMETYPE controls which frames are eligible to be returned; all
 */
 (frame, frametype, console))
 {
 XSETFRAME (frame, decode_frame (frame));
-return previous_frame (frame, frametype, console);
+return prev_frame (frame, frametype, console);
 }
 /* Return any frame for which PREDICATE is non-zero, or return Qnil
 if there aren't any. */
 /* Return 1 if it is ok to delete frame F;
 0 if all frames aside from F are invisible.
 (Exception: if F is a stream frame, it's OK to delete if
 any other frames exist.) */
+static int
+other_visible_frames_internal (struct frame *f, int called_from_delete_device)
+{
+Lisp_Object frame;
+XSETFRAME (frame, f);
+if (FRAME_STREAM_P (f))
+return !EQ (frame, next_frame_internal (frame, Qt, Qt,
+					    called_from_delete_device));
+return !EQ (frame, next_frame_internal (frame, Qvisible_iconic_nomini, Qt,
+					  called_from_delete_device));
+}
 int
 other_visible_frames (struct frame *f)
 {
-Lisp_Object frame;
+return other_visible_frames_internal (f, 0);
-XSETFRAME (frame, f);
-if (FRAME_STREAM_P (f))
-return !EQ (frame, next_frame (frame, Qt, Qt));
-return !EQ (frame, next_frame (frame, Qvisible_iconic_nomini, Qt));
 }
 /* Delete frame F.
 If FORCE is non-zero, allow deletion of the only frame.
 only frame.  However, this would let people shoot themselves by
 deleting all frames which were either visible or iconified and thus
 losing any way of communicating with the still running XEmacs process.
 So we put it back.  */
 if (!force && !allow_deletion_of_last_visible_frame &&
-!other_visible_frames (f))
+!other_visible_frames_internal (f, called_from_delete_device))
 error ("Attempt to delete the sole visible or iconified frame");
 /* Does this frame have a minibuffer, and is it the surrogate
 minibuffer for any other frame?  */
 if (FRAME_HAS_MINIBUF_P (f))
 	 Otherwise, find another visible frame; if none, just take any frame.
 First try the same device, then the same console. */
 next = DEVMETH_OR_GIVEN (d, get_frame_parent, (f), Qnil);
 if (NILP (next) || EQ (next, frame) || ! FRAME_LIVE_P (XFRAME (next)))
-	next = next_frame (frame, Qvisible, device);
+	next = next_frame_internal (frame, Qvisible, device,
+				    called_from_delete_device);
 if (NILP (next) || EQ (next, frame))
-	next = next_frame (frame, Qvisible, console);
+	next = next_frame_internal (frame, Qvisible, console,
+				    called_from_delete_device);
 if (NILP (next) || EQ (next, frame))
-	next = next_frame (frame, Qvisible, Qt);
+	next = next_frame_internal (frame, Qvisible, Qt,
+				    called_from_delete_device);
 if (NILP (next) || EQ (next, frame))
-	next = next_frame (frame, Qt, device);
+	next = next_frame_internal (frame, Qt, device,
+				    called_from_delete_device);
 if (NILP (next) || EQ (next, frame))
-	next = next_frame (frame, Qt, console);
+	next = next_frame_internal (frame, Qt, console,
+				    called_from_delete_device);
 if (NILP (next) || EQ (next, frame))
-	next = next_frame (frame, Qt, Qt);
+	next = next_frame_internal (frame, Qt, Qt, called_from_delete_device);
 /* if we haven't found another frame at this point
 	 then there aren't any. */
 if (NILP (next) || EQ (next, frame))
 	;
 	   * device then we still need to change DEVICE_SELECTED_FRAME(d)
 	   * to a live frame, if there are any left on this device.
 	   */
 	  if (!EQ (device, FRAME_DEVICE(XFRAME(next))))
 	    {
-		Lisp_Object next_f = next_frame (frame, Qt, device);
+		Lisp_Object next_f =
+		    next_frame_internal (frame, Qt, device,
+					 called_from_delete_device);
 		if (NILP (next_f) || EQ (next_f, frame))
 		  ;
 		else
 		  set_device_selected_frame (d, next_f);
 	    }
 (window, x, y))
 {
 struct window *w;
 int pix_x, pix_y;
-CHECK_LIVE_WINDOW (window);
+CHECK_WINDOW (window);
 CHECK_INT (x);
 CHECK_INT (y);
 /* Warping the mouse will cause EnterNotify and Focus events under X. */
 w = XWINDOW (window);
 */
 (window, x, y))
 {
 struct window *w;
-CHECK_LIVE_WINDOW (window);
+CHECK_WINDOW (window);
 CHECK_INT (x);
 CHECK_INT (y);
 /* Warping the mouse will cause EnterNotify and Focus events under X. */
 w = XWINDOW (window);

Mercurial > hg > xemacs-beta

comparison src/frame.c @ 371:cc15677e0335 r21-2b1