xemacs-beta: src/frame.c comparison

comparison src/frame.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	8fc7fe29b841

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 foolist = Fcopy_sequence (foolist);
 return foolist;
 }
-DEFUN ("make-frame", Fmake_frame, Smake_frame, 0, 2, "" /*
+DEFUN ("make-frame", Fmake_frame, 0, 2, "", /*
 Create a new frame, displaying the current buffer.
 Optional argument PROPS is a property list (a list of alternating
 keyword-value specifcations) of properties for the new frame.
 \(An alist is accepted for backward compatibility but should not
 be passed in.)
 See `set-frame-properties', `default-x-frame-plist', and
 `default-tty-frame-plist' for the specially-recognized properties.
-*/ )
+*/
-(props, device)
+(props, device))
-Lisp_Object props, device;
 {
 struct frame *f;
 struct device *d;
 Lisp_Object frame = Qnil, name = Qnil, minibuf;
 struct gcpro gcpro1, gcpro2, gcpro3;
 unhold_one_frame_size_changes (XFRAME (XCAR (frmcons)));
 }
-DEFUN ("framep", Fframep, Sframep, 1, 1, 0 /*
+DEFUN ("framep", Fframep, 1, 1, 0, /*
 Return non-nil if OBJECT is a frame.
 Also see `frame-live-p'.
 Note that FSF Emacs kludgily returns a value indicating what type of
 frame this is.  Use the cleaner function `frame-type' for that.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return FRAMEP (object) ? Qt : Qnil;
 }
-DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0 /*
+DEFUN ("frame-live-p", Fframe_live_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a frame which has not been deleted.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return FRAMEP (object) && FRAME_LIVE_P (XFRAME (object)) ? Qt : Qnil;
 }
 select_device_1 (FRAME_DEVICE (f));
 update_frame_window_mirror (f);
 }
-DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 1, 0 /*
+DEFUN ("select-frame", Fselect_frame, 1, 1, 0, /*
 Select the frame FRAME.
 Subsequent editing commands apply to its selected window.
 The selection of FRAME lasts until the next time the user does
 something to select a different frame, or until the next time this
 function is called.
 Note that this does not actually cause the window-system focus to
 be set to this frame, or the select-frame-hook or deselect-frame-hook
 to be run, until the next time that XEmacs is waiting for an event.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 CHECK_LIVE_FRAME (frame);
 /* select the frame's selected window.  This will call
 selected_frame_1(). */
 This function selects the selected window of the frame of EVENT.
 If EVENT is frame object, handle it as if it were a switch-frame event
 to that frame.
 */ )
-(frame, no_enter)
+(Lisp_Object frame, Lisp_Object no_enter)
-Lisp_Object frame, no_enter;
 {
 /* Preserve prefix arg that the command loop just cleared.  */
 XCONSOLE (Vselected_console)->prefix_arg = Vcurrent_prefix_arg;
 #if 0 /* unclean! */
 run_hook (Qmouse_leave_buffer_hook);
 return Qnil;
 }
 #endif
-DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 1, 0 /*
+DEFUN ("selected-frame", Fselected_frame, 0, 1, 0, /*
 Return the frame that is now selected on device DEVICE.
 If DEVICE is not specified, the selected device will be used.
 If no frames exist on the device, nil is returned.
-*/ )
+*/
-(device)
+(device))
-Lisp_Object device;
 {
 if (NILP (device) && NILP (Fselected_device (Qnil)))
 return Qnil; /* happens early in temacs */
 return DEVICE_SELECTED_FRAME (decode_device (device));
 }
 }
 return w;
 }
-DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
+DEFUN ("active-minibuffer-window", Factive_minibuffer_window, 0, 0, 0, /*
-Sactive_minibuffer_window, 0, 0, 0 /*
 Return the currently active minibuffer window, or nil if none.
-*/ )
+*/
-()
+())
 {
 return minibuf_level ? minibuf_window : Qnil;
 }
-DEFUN ("last-nonminibuf-frame", Flast_nonminibuf_frame,
+DEFUN ("last-nonminibuf-frame", Flast_nonminibuf_frame, 0, 1, 0, /*
-Slast_nonminibuf_frame, 0, 1, 0 /*
 Return the most-recently-selected non-minibuffer-only frame on CONSOLE.
 This will always be the same as (selected-frame device) unless the
 selected frame is a minibuffer-only frame.
 CONSOLE defaults to the selected console if omitted.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 Lisp_Object result;
 XSETCONSOLE (console, decode_console (console));
 /* Just in case the machinations in delete_frame_internal() resulted
 if (!NILP (result) && !FRAME_MINIBUF_ONLY_P (XFRAME (result)))
 return result;
 return CONSOLE_LAST_NONMINIBUF_FRAME (XCONSOLE (console));
 }
-DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0 /*
+DEFUN ("frame-root-window", Fframe_root_window, 0, 1, 0, /*
 Return the root-window of FRAME.
 If omitted, FRAME defaults to the currently selected frame.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 return (FRAME_ROOT_WINDOW (decode_frame (frame)));
 }
-DEFUN ("frame-selected-window", Fframe_selected_window,
+DEFUN ("frame-selected-window", Fframe_selected_window, 0, 1, 0, /*
-Sframe_selected_window, 0, 1, 0 /*
 Return the selected window of frame object FRAME.
 If omitted, FRAME defaults to the currently selected frame.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 return (FRAME_SELECTED_WINDOW (decode_frame (frame)));
 }
 void
 f->selected_window = window;
 if (!MINI_WINDOW_P (XWINDOW (window)) || FRAME_MINIBUF_ONLY_P (f))
 f->last_nonminibuf_window = window;
 }
-DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
+DEFUN ("set-frame-selected-window", Fset_frame_selected_window, 2, 2, 0, /*
-Sset_frame_selected_window, 2, 2, 0 /*
 Set the selected window of frame object FRAME to WINDOW.
 If FRAME is nil, the selected frame is used.
 If FRAME is the selected frame, this makes WINDOW the selected window.
-*/ )
+*/
-(frame, window)
+(frame, window))
-Lisp_Object frame, window;
 {
 XSETFRAME (frame, decode_frame (frame));
 CHECK_LIVE_WINDOW (window);
 if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
 set_frame_selected_window (XFRAME (frame), window);
 return window;
 }
-DEFUN ("frame-device", Fframe_device, Sframe_device,
+DEFUN ("frame-device", Fframe_device, 0, 1, 0, /*
-0, 1, 0 /*
 Return the device that FRAME is on.
 If omitted, FRAME defaults to the currently selected frame.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 return (FRAME_DEVICE (decode_frame (frame)));
 }
 int
 we would have returned directly from the loop.  Since PREV is the last
 acceptable frame in the list, return it.  */
 return prev;
 }
-DEFUN ("next-frame", Fnext_frame, Snext_frame,
+DEFUN ("next-frame", Fnext_frame, 0, 3, 0, /*
-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
 others will be skipped.  Note that if there is only one eligible
 frame, then `next-frame' called repeatedly will always return
 the same frame, and if there is no eligible frame, then FRAME is
 on that console.  If CONSOLE is a device, return frames only on that
 device.  If CONSOLE is a console type, return frames only on consoles
 of that type.  If CONSOLE is 'window-system, return any frames on any
 window-system consoles.  If CONSOLE is nil or omitted, return frames only
 on the FRAME's console.  Otherwise, all frames are considered.
-*/ )
+*/
-(frame, frametype, console)
+(frame, frametype, console))
-Lisp_Object frame, frametype, console;
 {
 XSETFRAME (frame, decode_frame (frame));
 return (next_frame (frame, frametype, console));
 }
-DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame,
+DEFUN ("previous-frame", Fprevious_frame, 0, 3, 0, /*
-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
 others will be skipped.  Note that if there is only one eligible
 frame, then `previous-frame' called repeatedly will always return
 the same frame, and if there is no eligible frame, then FRAME is
 returned.
 See `next-frame' for an explanation of the FRAMETYPE and CONSOLE
 arguments.
-*/ )
+*/
-(frame, frametype, console)
+(frame, frametype, console))
-Lisp_Object frame, frametype, console;
 {
 XSETFRAME (frame, decode_frame (frame));
 return (prev_frame (frame, frametype, console));
 }
 	      signal_simple_error
 		("Attempt to delete a surrogate minibuffer frame", frame);
 	    }
 	}
 }
+/* Test for popup frames hanging around. */
+/* Deletion of a parent frame with popups is deadly. */
+{
+Lisp_Object frmcons, devcons, concons;
+FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
+{
+	Lisp_Object this = XCAR (frmcons);
+	if (! EQ (this, frame)
+	    && EQ (frame, DEVMETH_OR_GIVEN(XDEVICE(XCAR(devcons)),
+					   get_frame_parent,
+					   (XFRAME(this)),
+					   Qnil)))
+	  {
+	    /* We've found another frame whose minibuffer is on
+	       this frame. */
+	    signal_simple_error
+	      ("Attempt to delete a frame with live popups", frame);
+	  }
+}
+}
 /* Before here, we haven't made any dangerous changes (just checked for
 error conditions).  Now run the delete-frame-hook.  Remember that
 user code there could do any number of dangerous things, including
 signalling an error. */
 signal an error. */
 if (XINT (Flength (DEVICE_FRAME_LIST (d))) == 1)
 {
 va_run_hook_with_args (Qdelete_device_hook, 1, device);
 if (!FRAME_LIVE_P (f)) /* Make sure the delete-device-hook didn't */
-	{		     /* go ahead and delete anything. */
+	{		     /*	go ahead and delete anything. */
 	  UNGCPRO;
 	  return;
 	}
 if (XINT (Flength (CONSOLE_DEVICE_LIST (con))) == 1)
 /* If this is a popup frame, select its parent if possible.
 	 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_internal (frame, Qvisible, device,
 				    called_from_delete_device);
 if (NILP (next) || EQ (next, frame))
 	next = next_frame_internal (frame, Qvisible, console,
 io_error_delete_frame (Lisp_Object frame)
 {
 delete_frame_internal (XFRAME (frame), 1, 0, 1);
 }
-DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame,
+DEFUN ("delete-frame", Fdelete_frame, 0, 2, "", /*
-0, 2, "" /*
 Delete FRAME, permanently eliminating it from use.
 If omitted, FRAME defaults to the selected frame.
 A frame may not be deleted if its minibuffer is used by other frames.
 Normally, you cannot delete the last non-minibuffer-only frame (you must
 use `save-buffers-kill-emacs' or `kill-emacs').  However, if optional
 second argument FORCE is non-nil, you can delete the last frame. (This
 will automatically call `save-buffers-kill-emacs'.)
-*/ )
+*/
-(frame, force)
+(frame, force))
-Lisp_Object frame, force;
 {
 /* This function can GC */
 struct frame *f;
 if (NILP (frame))
 }
 /* Return mouse position in character cell units.  */
-DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 1, 0 /*
+DEFUN ("mouse-position", Fmouse_position, 0, 1, 0, /*
 Return a list (WINDOW X . Y) giving the current mouse window and position.
 The position is given in character cells, where (0, 0) is the
 upper-left corner of the window.
 DEVICE specifies the device on which to read the mouse position, and
 defaults to the selected device.  If the device is a mouseless terminal
 or Emacs hasn't been programmed to read its mouse position, it returns
 the device's selected window for WINDOW and nil for X and Y.
-*/ )
+*/
-(device)
+(device))
-Lisp_Object device;
 {
 Lisp_Object val = Fmouse_pixel_position (device);
 int x, y, obj_x, obj_y;
 struct window *w;
 struct frame *f;
 }
 return 0;
 }
-DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
+DEFUN ("mouse-pixel-position", Fmouse_pixel_position, 0, 1, 0, /*
-Smouse_pixel_position, 0, 1, 0 /*
 Return a list (WINDOW X . Y) giving the current mouse window and position.
 The position is given in pixel units, where (0, 0) is the
 upper-left corner.
 DEVICE specifies the device on which to read the mouse position, and
 defaults to the selected device.  If the device is a mouseless terminal
 or Emacs hasn't been programmed to read its mouse position, it returns
 the device's selected window for WINDOW and nil for X and Y.
-*/ )
+*/
-(device)
+(device))
-Lisp_Object device;
 {
 struct device *d = decode_device (device);
 Lisp_Object frame;
 Lisp_Object window;
 Lisp_Object x, y;
 }
 return Fcons (window, Fcons (x, y));
 }
-DEFUN ("mouse-position-as-motion-event", Fmouse_position_as_motion_event,
+DEFUN ("mouse-position-as-motion-event", Fmouse_position_as_motion_event, 0, 1, 0, /*
-Smouse_position_as_motion_event, 0, 1, 0 /*
 Return the current mouse position as a motion event.
 This allows you to call the standard event functions such as
 `event-over-toolbar-p' to determine where the mouse is.
 DEVICE specifies the device on which to read the mouse position, and
 defaults to the selected device.  If the mouse position can't be determined
 (e.g. DEVICE is a TTY device), nil is returned instead of an event.
-*/ )
+*/
-(device)
+(device))
-Lisp_Object device;
 {
 struct device *d = decode_device (device);
 Lisp_Object frame;
 int intx, inty;
 }
 else
 return Qnil;
 }
-DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0 /*
+DEFUN ("set-mouse-position", Fset_mouse_position, 3, 3, 0, /*
 Move the mouse pointer to the center of character cell (X,Y) in WINDOW.
 Note, this is a no-op for an X frame that is not visible.
 If you have just created a frame, you must wait for it to become visible
 before calling this function on it, like this.
 (while (not (frame-visible-p frame)) (sleep-for .5))
 Note also: Warping the mouse is contrary to the ICCCM, so be very sure
 that the behavior won't end up being obnoxious!
-*/ )
+*/
-(window, x, y)
+(window, x, y))
-Lisp_Object window, x, y;
 {
 struct window *w;
 int pix_x, pix_y;
 CHECK_WINDOW (window);
 MAYBE_FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, pix_x, pix_y));
 return Qnil;
 }
-DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
+DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position, 3, 3, 0, /*
-Sset_mouse_pixel_position, 3, 3, 0 /*
 Move the mouse pointer to pixel position (X,Y) in WINDOW.
 Note, this is a no-op for an X frame that is not visible.
 If you have just created a frame, you must wait for it to become visible
 before calling this function on it, like this.
 (while (not (frame-visible-p frame)) (sleep-for .5))
-*/ )
+*/
-(window, x, y)
+(window, x, y))
-Lisp_Object window, x, y;
 {
 struct window *w;
 CHECK_WINDOW (window);
 CHECK_INT (x);
 FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, XINT (x), XINT (y)));
 return Qnil;
 }
-DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
+DEFUN ("make-frame-visible", Fmake_frame_visible, 0, 1, 0, /*
-0, 1, 0 /*
 Make the frame FRAME visible (assuming it is an X-window).
 If omitted, FRAME defaults to the currently selected frame.
 Also raises the frame so that nothing obscures it.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 MAYBE_FRAMEMETH (f, make_frame_visible, (f));
 return frame;
 }
-DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
+DEFUN ("make-frame-invisible", Fmake_frame_invisible, 0, 2, 0, /*
-0, 2, 0 /*
 Unconditionally removes frame from the display (assuming it is an X-window).
 If omitted, FRAME defaults to the currently selected frame.
 If what you want to do is iconify the frame (if the window manager uses
 icons) then you should call `iconify-frame' instead.
 Normally you may not make FRAME invisible if all other frames are invisible
 and uniconified, but if the second optional argument FORCE is non-nil,
 you may do so.
-*/ )
+*/
-(frame, force)
+(frame, force))
-Lisp_Object frame, force;
 {
 struct frame *f, *sel_frame;
 struct device *d;
 f = decode_frame (frame);
 MAYBE_FRAMEMETH (f, make_frame_invisible, (f));
 return Qnil;
 }
-DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
+DEFUN ("iconify-frame", Ficonify_frame, 0, 1, "", /*
-0, 1, "" /*
 Make the frame FRAME into an icon, if the window manager supports icons.
 If omitted, FRAME defaults to the currently selected frame.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f, *sel_frame;
 struct device *d;
 f = decode_frame (frame);
 MAYBE_FRAMEMETH (f, iconify_frame, (f));
 return Qnil;
 }
-DEFUN ("deiconify-frame", Fdeiconify_frame, Sdeiconify_frame,
+DEFUN ("deiconify-frame", Fdeiconify_frame, 0, 1, 0, /*
-0, 1, 0 /*
 Open (de-iconify) the iconified frame FRAME.
 Under X, this is currently the same as `make-frame-visible'.
 If omitted, FRAME defaults to the currently selected frame.
 Also raises the frame so that nothing obscures it.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 return Fmake_frame_visible (frame);
 }
 /* FSF returns 'icon for iconized frames.  What a crock! */
-DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
+DEFUN ("frame-visible-p", Fframe_visible_p, 0, 1, 0, /*
-1, 1, 0 /*
 Return t if FRAME is now \"visible\" (actually in use for display).
 A frame that is not visible is not updated, and, if it works through a
 window system, may not show at all.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 return (FRAMEMETH_OR_GIVEN (f, frame_visible_p, (f), f->visible)
 			      ? Qt : Qnil);
 }
-DEFUN ("frame-totally-visible-p", Fframe_totally_visible_p,
+DEFUN ("frame-totally-visible-p", Fframe_totally_visible_p, 0, 1, 0, /*
-Sframe_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)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 return (FRAMEMETH_OR_GIVEN (f, frame_totally_visible_p, (f), f->visible)
 			      ? Qt : Qnil);
 }
-DEFUN ("frame-iconified-p", Fframe_iconified_p, Sframe_iconified_p,
+DEFUN ("frame-iconified-p", Fframe_iconified_p, 0, 1, 0, /*
-1, 1, 0 /*
 Return t if FRAME is iconified.
 Not all window managers use icons; some merely unmap the window, so this
 function is not the inverse of `frame-visible-p'.  It is possible for a
 frame to not be visible and not be iconified either.  However, if the
 frame is iconified, it will not be visible.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 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);
 }
-DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
+DEFUN ("visible-frame-list", Fvisible_frame_list, 0, 1, 0, /*
-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.
-*/ )
+*/
-(device)
+(device))
-Lisp_Object device;
 {
 Lisp_Object devcons, concons;
 struct frame *f;
 Lisp_Object value;
 return value;
 }
-DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "" /*
+DEFUN ("raise-frame", Fraise_frame, 0, 1, "", /*
 Bring FRAME to the front, so it occludes any frames it overlaps.
 If omitted, FRAME defaults to the currently selected frame.
 If FRAME is invisible, make it visible.
 If Emacs is displaying on an ordinary terminal or some other device which
 doesn't support multiple overlapping frames, this function does nothing.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 /* Do like the documentation says. */
 Fmake_frame_visible (frame);
 MAYBE_FRAMEMETH (f, raise_frame, (f));
 return Qnil;
 }
-DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "" /*
+DEFUN ("lower-frame", Flower_frame, 0, 1, "", /*
 Send FRAME to the back, so it is occluded by any frames that overlap it.
 If omitted, FRAME defaults to the currently selected frame.
 If Emacs is displaying on an ordinary terminal or some other device which
 doesn't support multiple overlapping frames, this function does nothing.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 MAYBE_FRAMEMETH (f, lower_frame, (f));
 return Qnil;
 other properties which this claims to handle, but doesn't?
 But of course.  This stuff needs more work, but it's a lot closer
 to sanity now than before with the horrible frame-params stuff. */
-DEFUN ("set-frame-properties", Fset_frame_properties, Sset_frame_properties,
+DEFUN ("set-frame-properties", Fset_frame_properties, 2, 2, 0, /*
-2, 2, 0 /*
 Change some properties of a frame.
 PLIST is a property list.
 You can also change frame properties individually using `set-frame-property',
 but it may be more efficient to change many properties at once.
 frame property name to another.
 See the variables `default-x-frame-plist' and `default-tty-frame-plist'
 for a description of the properties recognized for particular types of
 frames.
-*/ )
+*/
-(frame, plist)
+(frame, plist))
-Lisp_Object frame, plist;
 {
 struct frame *f = decode_frame (frame);
 Lisp_Object tail;
 Lisp_Object *tailp;
 struct gcpro gcpro1, gcpro2;
 Fcanonicalize_lax_plist (f->plist, Qnil);
 UNGCPRO;
 return Qnil;
 }
-DEFUN ("frame-property", Fframe_property, Sframe_property, 2, 3, 0 /*
+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, defalt))
-Lisp_Object frame, property, defalt;
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 return value;
 return defalt;
 }
 }
-DEFUN ("frame-properties", Fframe_properties, Sframe_properties, 1, 1, 0 /*
+DEFUN ("frame-properties", Fframe_properties, 0, 1, 0, /*
 Return a property list of the properties of FRAME.
 Do not modify this list; use `set-frame-property' instead.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 Lisp_Object result = Qnil;
 struct gcpro gcpro1;
 RETURN_UNGCPRO (result);
 }
 }
-DEFUN ("frame-pixel-height", Fframe_pixel_height, Sframe_pixel_height, 0, 1, 0 /*
+DEFUN ("frame-pixel-height", Fframe_pixel_height, 0, 1, 0, /*
 Return the height in pixels of FRAME.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 return (make_int (f->pixheight));
 }
-DEFUN ("frame-pixel-width", Fframe_pixel_width, Sframe_pixel_width, 0, 1, 0 /*
+DEFUN ("frame-pixel-width", Fframe_pixel_width, 0, 1, 0, /*
 Return the width in pixels of FRAME.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 return (make_int (f->pixwidth));
 }
-DEFUN ("frame-name", Fframe_name, Sframe_name, 0, 1, 0 /*
+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)
+(frame))
-Lisp_Object frame;
 {
 return (decode_frame (frame)->name);
 }
-DEFUN ("frame-modified-tick", Fframe_modified_tick, Sframe_modified_tick,
+DEFUN ("frame-modified-tick", Fframe_modified_tick, 0, 1, 0, /*
-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
 is resized, a window is resized, added, or deleted, a face is changed,
 `set-window-buffer' or `select-window' is called on a window in the
 frame, the window-start of a window in the frame has changed, or
 anything else interesting has happened.  It wraps around occasionally.
 No argument or nil as argument means use selected frame as FRAME.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 return make_int (decode_frame (frame)->modiff);
 }
 static void
 change_frame_size (f, rows, cols, 0);
 else
 FRAMEMETH (f, set_frame_size, (f, cols, rows));
 }
-DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0 /*
+DEFUN ("set-frame-height", Fset_frame_height, 2, 3, 0, /*
 Specify that the frame FRAME has LINES lines.
 Optional third arg non-nil means that redisplay should use LINES lines
 but that the idea of the actual height of the frame should not be changed.
-*/ )
+*/
-(frame, rows, pretend)
+(frame, rows, pretend))
-Lisp_Object 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, Sset_frame_width, 2, 3, 0 /*
+DEFUN ("set-frame-width", Fset_frame_width, 2, 3, 0, /*
 Specify that the frame FRAME has COLS columns.
 Optional third arg non-nil means that redisplay should use COLS columns
 but that the idea of the actual width of the frame should not be changed.
-*/ )
+*/
-(frame, cols, pretend)
+(frame, cols, pretend))
-Lisp_Object frame, cols, pretend;
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 CHECK_INT (cols);
 internal_set_frame_size (f, XINT (cols), FRAME_HEIGHT (f),
 			    !NILP (pretend));
 return frame;
 }
-DEFUN ("set-frame-size", Fset_frame_size,
+DEFUN ("set-frame-size", Fset_frame_size, 3, 4, 0, /*
-Sset_frame_size, 3, 4, 0 /*
 Sets size of FRAME to COLS by ROWS.
 Optional fourth arg non-nil means that redisplay should use COLS by ROWS
 but that the idea of the actual size of the frame should not be changed.
-*/ )
+*/
-(frame, cols, rows, pretend)
+(frame, cols, rows, pretend))
-Lisp_Object frame, cols, rows, pretend;
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 CHECK_INT (cols);
 CHECK_INT (rows);
 internal_set_frame_size (f, XINT (cols), XINT (rows), !NILP (pretend));
 return frame;
 }
-DEFUN ("set-frame-position", Fset_frame_position,
+DEFUN ("set-frame-position", Fset_frame_position, 3, 3, 0, /*
-Sset_frame_position, 3, 3, 0 /*
 Sets position of FRAME in pixels to XOFFSET by YOFFSET.
 This is actually the position of the upper left corner of the frame.
 Negative values for XOFFSET or YOFFSET are interpreted relative to
 the rightmost or bottommost possible position (that stays within the screen).
-*/ )
+*/
-(frame, xoffset, yoffset)
+(frame, xoffset, yoffset))
-Lisp_Object frame, xoffset, yoffset;
 {
 struct frame *f = decode_frame (frame);
 CHECK_INT (xoffset);
 CHECK_INT (yoffset);
 if (title)
 xfree (title);
 }
-DEFUN ("set-frame-pointer", Fset_frame_pointer, Sset_frame_pointer,
+DEFUN ("set-frame-pointer", Fset_frame_pointer, 2, 2, 0, /*
-2, 2, 0 /*
 Set the mouse pointer of FRAME to the given pointer image instance.
 You should not call this function directly.  Instead, set one of
 the variables `text-pointer-glyph', `nontext-pointer-glyph',
 `modeline-pointer-glyph', `selection-pointer-glyph',
 `busy-pointer-glyph', or `toolbar-pointer-glyph'.
-*/ )
+*/
-(frame, image_instance)
+(frame, image_instance))
-Lisp_Object frame, image_instance;
 {
 struct frame *f = decode_frame (frame);
 CHECK_POINTER_IMAGE_INSTANCE (image_instance);
 if (!EQ (f->pointer, image_instance))
 {
 defsymbol (&Qset_glyph_image, "set-glyph-image");
 defsymbol (&Qset_face_property, "set-face-property");
 defsymbol (&Qface_property_instance, "face-property-instance");
 defsymbol (&Qframe_property_alias, "frame-property-alias");
-defsubr (&Smake_frame);
+DEFSUBR (Fmake_frame);
-defsubr (&Sframep);
+DEFSUBR (Fframep);
-defsubr (&Sframe_live_p);
+DEFSUBR (Fframe_live_p);
 #if 0 /* FSFmacs */
-defsubr (&Signore_event);
+DEFSUBR (Fignore_event);
 #endif
-defsubr (&Sselect_frame);
+DEFSUBR (Fselect_frame);
-defsubr (&Sselected_frame);
+DEFSUBR (Fselected_frame);
-defsubr (&Sactive_minibuffer_window);
+DEFSUBR (Factive_minibuffer_window);
-defsubr (&Slast_nonminibuf_frame);
+DEFSUBR (Flast_nonminibuf_frame);
-defsubr (&Sframe_root_window);
+DEFSUBR (Fframe_root_window);
-defsubr (&Sframe_selected_window);
+DEFSUBR (Fframe_selected_window);
-defsubr (&Sset_frame_selected_window);
+DEFSUBR (Fset_frame_selected_window);
-defsubr (&Sframe_device);
+DEFSUBR (Fframe_device);
-defsubr (&Snext_frame);
+DEFSUBR (Fnext_frame);
-defsubr (&Sprevious_frame);
+DEFSUBR (Fprevious_frame);
-defsubr (&Sdelete_frame);
+DEFSUBR (Fdelete_frame);
-defsubr (&Smouse_position);
+DEFSUBR (Fmouse_position);
-defsubr (&Smouse_pixel_position);
+DEFSUBR (Fmouse_pixel_position);
-defsubr (&Smouse_position_as_motion_event);
+DEFSUBR (Fmouse_position_as_motion_event);
-defsubr (&Sset_mouse_position);
+DEFSUBR (Fset_mouse_position);
-defsubr (&Sset_mouse_pixel_position);
+DEFSUBR (Fset_mouse_pixel_position);
-defsubr (&Smake_frame_visible);
+DEFSUBR (Fmake_frame_visible);
-defsubr (&Smake_frame_invisible);
+DEFSUBR (Fmake_frame_invisible);
-defsubr (&Siconify_frame);
+DEFSUBR (Ficonify_frame);
-defsubr (&Sdeiconify_frame);
+DEFSUBR (Fdeiconify_frame);
-defsubr (&Sframe_visible_p);
+DEFSUBR (Fframe_visible_p);
-defsubr (&Sframe_totally_visible_p);
+DEFSUBR (Fframe_totally_visible_p);
-defsubr (&Sframe_iconified_p);
+DEFSUBR (Fframe_iconified_p);
-defsubr (&Svisible_frame_list);
+DEFSUBR (Fvisible_frame_list);
-defsubr (&Sraise_frame);
+DEFSUBR (Fraise_frame);
-defsubr (&Slower_frame);
+DEFSUBR (Flower_frame);
-defsubr (&Sframe_property);
+DEFSUBR (Fframe_property);
-defsubr (&Sframe_properties);
+DEFSUBR (Fframe_properties);
-defsubr (&Sset_frame_properties);
+DEFSUBR (Fset_frame_properties);
-defsubr (&Sframe_pixel_height);
+DEFSUBR (Fframe_pixel_height);
-defsubr (&Sframe_pixel_width);
+DEFSUBR (Fframe_pixel_width);
-defsubr (&Sframe_name);
+DEFSUBR (Fframe_name);
-defsubr (&Sframe_modified_tick);
+DEFSUBR (Fframe_modified_tick);
-defsubr (&Sset_frame_height);
+DEFSUBR (Fset_frame_height);
-defsubr (&Sset_frame_width);
+DEFSUBR (Fset_frame_width);
-defsubr (&Sset_frame_size);
+DEFSUBR (Fset_frame_size);
-defsubr (&Sset_frame_position);
+DEFSUBR (Fset_frame_position);
-defsubr (&Sset_frame_pointer);
+DEFSUBR (Fset_frame_pointer);
 }
 void
 vars_of_frame (void)
 {
 /* */
 Vframe_being_created = Qnil;
 staticpro (&Vframe_being_created);
+#ifdef HAVE_CDE
+Vfeatures = Fcons (intern ("cde"), Vfeatures);
+#endif
 #if 0 /* FSFmacs stupidity */
 xxDEFVAR_LISP ("emacs-iconified", &Vemacs_iconified /*
 Non-nil if all of emacs is iconified and frame updates are not needed.
 */ );

Mercurial > hg > xemacs-beta

comparison src/frame.c @ 20:859a2309aef8 r19-15b93