xemacs-beta: src/frame.c comparison

comparison src/frame.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	5a88923fcbfe
children	e121b013d1f0

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 static void
 print_frame (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 struct frame *frm = XFRAME (obj);
 char buf[200];
 if (print_readably)
 error ("printing unreadable object #<frame %s 0x%x>",
 XSTRING_DATA (frm->name), frm->header.uid);
 sprintf (buf, "#<%s-frame ", !FRAME_LIVE_P (frm) ? "dead" :
 /* This function can GC */
 Lisp_Object device = f->device;
 if (!NILP (mini_window))
 CHECK_LIVE_WINDOW (mini_window);
 if (!NILP (mini_window)
 && !EQ (DEVICE_CONSOLE (XDEVICE (device)),
 	      FRAME_CONSOLE (XFRAME (XWINDOW (mini_window)->frame))))
 error ("frame and minibuffer must be on the same console");
 struct frame *
 decode_frame (Lisp_Object frame)
 {
 if (NILP (frame))
 return selected_frame ();
 CHECK_LIVE_FRAME (frame);
-return (XFRAME (frame));
+return XFRAME (frame);
 }
 struct frame *
 decode_frame_or_selected (Lisp_Object cdf)
 {
 run_hook (Qmouse_leave_buffer_hook);
 #endif
 return do_switch_frame (frame, no_enter, 0);
 }
 /* A load of garbage. */
 xxDEFUN ("ignore-event", Fignore_event, 0, 0, "", /*
 Do nothing, but preserve any prefix argument already specified.
 This is a suitable binding for iconify-frame and make-frame-visible.
 */
 	 ())
 Return the root-window of FRAME.
 If omitted, FRAME defaults to the currently selected frame.
 */
 (frame))
 {
-return (FRAME_ROOT_WINDOW (decode_frame (frame)));
+return FRAME_ROOT_WINDOW (decode_frame (frame));
 }
 DEFUN ("frame-selected-window", Fframe_selected_window, 0, 1, 0, /*
 Return the selected window of frame object FRAME.
 If omitted, FRAME defaults to the currently selected frame.
 */
 (frame))
 {
-return (FRAME_SELECTED_WINDOW (decode_frame (frame)));
+return FRAME_SELECTED_WINDOW (decode_frame (frame));
 }
 void
 set_frame_selected_window (struct frame *f, Lisp_Object window)
 {
 Return the device that FRAME is on.
 If omitted, FRAME defaults to the currently selected frame.
 */
 (frame))
 {
-return (FRAME_DEVICE (decode_frame (frame)));
+return FRAME_DEVICE (decode_frame (frame));
 }
 int
 is_surrogate_for_selected_frame (struct frame *f)
 {
 if (EQ (type, Qvisible_iconic_nomini))
 return ((FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
 	    && !FRAME_MINIBUF_ONLY_P (f));
 if (EQ (type, Qinvisible_iconic_nomini))
 return !FRAME_VISIBLE_P (f) && !FRAME_MINIBUF_ONLY_P (f);
 return 1;
 }
 int
 device_matches_console_spec (Lisp_Object frame, Lisp_Object device,
 		      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;
 		}
 	      if (EQ (frame, f))
 		passed++;
 	    }
 	}
 /* We hit the end of the list, and need to start over again. */
 	continue;
 DEVICE_FRAME_LOOP (frmcons, XDEVICE (device))
 	{
 	  Lisp_Object f = XCAR (frmcons);
 	  if (EQ (frame, f) && !NILP (prev))
 	    return prev;
 	  /* Decide whether this frame is eligible to be returned,
 	     according to frametype.  */
 	  if (frame_matches_frametype (f, frametype))
 	    prev = f;
 */
 (frame, frametype, console))
 {
 XSETFRAME (frame, decode_frame (frame));
-return (next_frame (frame, frametype, console));
+return next_frame (frame, frametype, console);
 }
 DEFUN ("previous-frame", Fprevious_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 (prev_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. */
 		Fselect_frame (next);
 		did_select = 1;
 	    }
 	  /*
 	   * If the new frame we just selected is on a different
 	   * 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 =
 /* If we've deleted the last non-minibuf frame, then try to find
 another one.  */
 if (EQ (frame, CONSOLE_LAST_NONMINIBUF_FRAME (con)))
 {
 Lisp_Object frmcons, devcons;
 set_console_last_nonminibuf_frame (con, Qnil);
 CONSOLE_FRAME_LOOP_NO_BREAK (frmcons, devcons, con)
 	{
 	  Lisp_Object ecran = XCAR (frmcons);
 	  if (!FRAME_MINIBUF_ONLY_P (XFRAME (ecran)))
 	    {
 N.B. Under X \"visible\" means Mapped. It the window is mapped but not
 actually visible on screen then frame_visible returns 'hidden.
 */
 (frame))
 {
-int visible;
 struct frame *f = decode_frame (frame);
-visible = FRAMEMETH_OR_GIVEN (f, frame_visible_p, (f), f->visible);
+int visible = FRAMEMETH_OR_GIVEN (f, frame_visible_p, (f), f->visible);
-return ( visible ? ( visible > 0 ? Qt : Qhidden )
+return visible ? ( visible > 0 ? Qt : Qhidden ) : Qnil;
-			     : Qnil);
 }
 DEFUN ("frame-totally-visible-p", Fframe_totally_visible_p, 0, 1, 0, /*
 Return T if frame is not obscured by any other X windows, NIL otherwise.
 Always returns t for tty frames.
 */
 (frame))
 {
 struct frame *f = decode_frame (frame);
 return (FRAMEMETH_OR_GIVEN (f, frame_totally_visible_p, (f), f->visible)
-			      ? Qt : Qnil);
+	  ? Qt : Qnil);
 }
 DEFUN ("frame-iconified-p", Fframe_iconified_p, 0, 1, 0, /*
 Return t if FRAME is iconified.
 Not all window managers use icons; some merely unmap the window, so this
 {
 struct frame *f = decode_frame (frame);
 if (f->visible)
 return Qnil;
 f->iconified = FRAMEMETH_OR_GIVEN (f, frame_iconified_p, (f), 0);
-return (f->iconified ? Qt : Qnil);
+return f->iconified ? Qt : Qnil;
 }
 DEFUN ("visible-frame-list", Fvisible_frame_list, 0, 1, 0, /*
 Return a list of all frames now \"visible\" (being updated).
 If DEVICE is specified only frames on that device will be returned.
 	   val);
 if (FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
 	signal_simple_error
 	  ("Can't change the surrogate minibuffer of a frame with its own minibuffer", frame);
 /* Install the chosen minibuffer window, with proper buffer.  */
 f->minibuffer_window = val;
 }
 else if (EQ (val, Qt))
 {
 if (SYMBOLP (prop) && EQ (Fbuilt_in_variable_type (prop),
 				Qconst_specifier))
 	call3 (Qset_specifier, Fsymbol_value (prop), val, frame);
 if (SYMBOLP (prop) && !NILP (Fget (prop, Qconst_glyph_variable, Qnil)))
 	call3 (Qset_glyph_image, Fsymbol_value (prop), val, frame);
-if (VECTORP (prop) && vector_length (XVECTOR (prop)) == 2)
+if (VECTORP (prop) && XVECTOR_LENGTH (prop) == 2)
 	{
-	  Lisp_Object face_prop = vector_data (XVECTOR (prop))[1];
+	  Lisp_Object face_prop = XVECTOR_DATA (prop)[1];
 	  CHECK_SYMBOL (face_prop);
 	  call4 (Qset_face_property,
-		 Fget_face (vector_data (XVECTOR (prop))[0]),
+		 Fget_face (XVECTOR_DATA (prop)[0]),
 		 face_prop, val, frame);
 	}
 }
 MAYBE_FRAMEMETH (f, set_frame_properties, (f, plist));
 	  || EQ (prop, Qwidth)
 	  || (SYMBOLP (prop) && EQ (Fbuilt_in_variable_type (prop),
 				    Qconst_specifier))
 	  || (SYMBOLP (prop) && !NILP (Fget (prop, Qconst_glyph_variable,
 					     Qnil)))
-	  || (VECTORP (prop) && vector_length (XVECTOR (prop)) == 2)
+	  || (VECTORP (prop) && XVECTOR_LENGTH (prop) == 2)
 	  || FRAMEMETH_OR_GIVEN (f, internal_frame_property_p, (f, prop), 0))
 	*tailp = *next_tailp;
 tailp = next_tailp;
 }
 DEFUN ("frame-property", Fframe_property, 2, 3, 0, /*
 Return FRAME's value for property PROPERTY.
 See `set-frame-properties' for the built-in property names.
 */
-(frame, property, defalt))
+(frame, property, default_))
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 property = get_property_alias (property);
 #define FROB(propprop, value) 	\
 do {				\
 if (EQ (property, propprop))	\
-return (value);		\
+return value;		\
 } while (0)
 FROB (Qname, f->name);
 FROB (Qheight, make_int (FRAME_HEIGHT (f)));
 FROB (Qwidth,  make_int (FRAME_WIDTH  (f)));
 #undef FROB
 if (SYMBOLP (property) && EQ (Fbuilt_in_variable_type (property),
 				Qconst_specifier))
-return Fspecifier_instance (Fsymbol_value (property), frame, defalt, Qnil);
+return Fspecifier_instance (Fsymbol_value (property), frame, default_, Qnil);
 if (SYMBOLP (property) && !NILP (Fget (property, Qconst_glyph_variable,
 					 Qnil)))
 {
 Lisp_Object glyph = Fsymbol_value (property);
 CHECK_GLYPH (glyph);
-return Fspecifier_instance (XGLYPH_IMAGE (glyph), frame, defalt, Qnil);
+return Fspecifier_instance (XGLYPH_IMAGE (glyph), frame, default_, Qnil);
 }
-if (VECTORP (property) && vector_length (XVECTOR (property)) == 2)
+if (VECTORP (property) && XVECTOR_LENGTH (property) == 2)
 {
-Lisp_Object face_prop = vector_data (XVECTOR (property))[1];
+Lisp_Object face_prop = XVECTOR_DATA (property)[1];
 CHECK_SYMBOL (face_prop);
 return call3 (Qface_property_instance,
-		    Fget_face (vector_data (XVECTOR (property))[0]),
+		    Fget_face (XVECTOR_DATA (property)[0]),
 		    face_prop, frame);
 }
 {
 Lisp_Object value;
 return value;
 value = external_plist_get (&f->plist, property, 1, ERROR_ME);
 if (!UNBOUNDP (value))
 return value;
-return defalt;
+return default_;
 }
 }
 DEFUN ("frame-properties", Fframe_properties, 0, 1, 0, /*
 Return a property list of the properties of FRAME.
 struct frame *f = decode_frame (frame);
 Lisp_Object result = Qnil;
 struct gcpro gcpro1;
 GCPRO1 (result);
 #define FROB(propprop, value)				\
 do {							\
 Lisp_Object temtem = (value);				\
 if (!NILP (temtem))					\
 /* backwards order; we reverse it below */		\
 Return the height in pixels of FRAME.
 */
 (frame))
 {
 struct frame *f = decode_frame (frame);
-return (make_int (f->pixheight));
+return make_int (f->pixheight);
 }
 DEFUN ("frame-pixel-width", Fframe_pixel_width, 0, 1, 0, /*
 Return the width in pixels of FRAME.
 */
 (frame))
 {
 struct frame *f = decode_frame (frame);
-return (make_int (f->pixwidth));
+return make_int (f->pixwidth);
 }
 DEFUN ("frame-name", Fframe_name, 0, 1, 0, /*
 Return the name of FRAME (defaulting to the selected frame).
 This is not the same as the `title' of the frame.
 */
 (frame))
 {
-return (decode_frame (frame)->name);
+return decode_frame (frame)->name;
 }
 DEFUN ("frame-modified-tick", Fframe_modified_tick, 0, 1, 0, /*
 Return FRAME's tick counter, incremented for each change to the frame.
 Each frame has a tick counter which is incremented each time the frame
 (frame, rows, pretend))
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 CHECK_INT (rows);
 internal_set_frame_size (f, FRAME_WIDTH (f), XINT (rows),
 			   !NILP (pretend));
 return frame;
 }
 DEFUN ("set-frame-width", Fset_frame_width, 2, 3, 0, /*
 {
 *pixel_width = (*char_width - 1) * cpw + egw + bdr + obw;
 *pixel_height = *char_height * cph + bdr + obh;
 }
 }
 /* This takes the size in pixels of the text area, and returns the number
 of characters that will fit there, taking into account the internal
 border width, and the pixel width of the line terminator glyphs (which
 always count as one "character" wide, even if they are not the same size
 as the default character size of the default font).  The frame scrollbar
 				/* - font_height for minibuffer */
 				new_pixheight - minibuf_height, 0);
 	  XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_top =
 	    new_pixheight - minibuf_height + FRAME_TOP_BORDER_END (f);
 	  set_window_pixheight (FRAME_MINIBUF_WINDOW (f), minibuf_height, 0);
 	}
 else
 	/* Frame has just one top-level window.  */
 	set_window_pixheight (FRAME_ROOT_WINDOW (f), new_pixheight, 0);

Mercurial > hg > xemacs-beta

comparison src/frame.c @ 173:8eaf7971accc r20-3b13