xemacs-beta: src/frame.c comparison

comparison src/frame.c @ 2:ac2d302a0011 r19-15b2

Import from CVS: tag r19-15b2

author	cvs
date	Mon, 13 Aug 2007 08:46:35 +0200
parents	376386a54a3c
children	0293115a14e9

comparison

equal deleted inserted replaced

-:c0c6a60d29db
+:ac2d302a0011
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 /* Synched up with: FSF 19.30. */
-/* This file has been Mule-ized except for the frame-title stuff. */
+/* This file has been Mule-ized. */
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"             /* for Vbuffer_alist */
 Lisp_Object Vmouse_enter_frame_hook, Qmouse_enter_frame_hook;
 Lisp_Object Vmouse_leave_frame_hook, Qmouse_leave_frame_hook;
 Lisp_Object Vmap_frame_hook, Qmap_frame_hook;
 Lisp_Object Vunmap_frame_hook, Qunmap_frame_hook;
 Lisp_Object Vallow_deletion_of_last_visible_frame;
-#ifdef HAVE_CDE
+#if defined (HAVE_CDE) || defined (HAVE_OFFIX_DND)
 Lisp_Object Vdrag_and_drop_functions, Qdrag_and_drop_functions;
 #endif
 Lisp_Object Vmouse_motion_handler;
 Lisp_Object Vsynchronize_minibuffers;
 Lisp_Object Qsynchronize_minibuffers;
 Lisp_Object Qframep, Qframe_live_p;
 Lisp_Object Qframe_x_p, Qframe_tty_p;
 Lisp_Object Qdelete_frame;
-Lisp_Object Vframe_title_format;
+Lisp_Object Qframe_title_format, Vframe_title_format;
-Lisp_Object Vframe_icon_title_format;
+Lisp_Object Qframe_icon_title_format, Vframe_icon_title_format;
 Lisp_Object Vdefault_frame_name;
 Lisp_Object Vdefault_frame_plist;
 Lisp_Object Vframe_icon_glyph;
 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)
 Lisp_Object frame, frametype, console;
 {
 XSETFRAME (frame, decode_frame (frame));
 return (next_frame (frame, frametype, console));
 }
 	}
 }
 minibuffer_selected = EQ (minibuf_window, Fselected_window (Qnil));
-/* If we were focussed on this frame, then we're not any more.
+/* If we were focused on this frame, then we're not any more.
 Assume that we lost the focus; that way, the call to
 Fselect_frame() below won't end up making us explicitly
 focus on another frame, which is generally undesirable in
 a point-to-type world.  If our mouse ends up sitting over
 another frame, we will receive a FocusIn event and end up
 	 select the new one.  */
 if (minibuffer_selected)
 	Fselect_window (minibuf_window);
 }
-/* Before here, we haven't made any dangerous changed (just checked for
+/* 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.
 */
 /* 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, concons;
+Lisp_Object frmcons, devcons;
 set_console_last_nonminibuf_frame (con, Qnil);
 CONSOLE_FRAME_LOOP_NO_BREAK (frmcons, devcons, con)
 	{
 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)
 Lisp_Object frame, force;
 {
 /* This function can GC */
 struct frame *f;
 if (NILP (frame))
 w = XWINDOW (XCAR (val));
 x = XINT (XCAR (XCDR (val)));
 y = XINT (XCDR (XCDR (val)));
 f = XFRAME (w->frame);
-if (x >= 0 && y >= 0 &&
+if (x >= 0 && y >= 0)
-pixel_to_glyph_translation (f, x, y, &x, &y, &obj_x, &obj_y, &w,
+{
-				  &bufpos, &closest, &modeline_closest,
+if (pixel_to_glyph_translation (f, x, y, &x, &y, &obj_x, &obj_y, &w,
-				  &obj1, &obj2)
+				      &bufpos, &closest, &modeline_closest,
-!= OVER_NOTHING)
+				      &obj1, &obj2)
-{
+	  != OVER_NOTHING)
-XCAR (XCDR (val)) = make_int (x);
+	{
-XCDR (XCDR (val)) = make_int (y);
+	  XCAR (XCDR (val)) = make_int (x);
+	  XCDR (XCDR (val)) = make_int (y);
+	}
 }
 else
 {
 XCAR (XCDR (val)) = Qnil;
 XCDR (XCDR (val)) = Qnil;
 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)
 Lisp_Object device;
 {
 struct device *d = decode_device (device);
 Lisp_Object frame;
 Lisp_Object window;
 Lisp_Object x, y;
 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)
 Lisp_Object device;
 {
 struct device *d = decode_device (device);
 Lisp_Object frame;
 int intx, inty;
 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)
 Lisp_Object window, x, y;
 {
 struct window *w;
 int pix_x, pix_y;
 CHECK_WINDOW (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)
 Lisp_Object window, x, y;
 {
 struct window *w;
 CHECK_WINDOW (window);
 CHECK_INT (x);
 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)
 Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 MAYBE_FRAMEMETH (f, make_frame_visible, (f));
 return frame;
 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)
 Lisp_Object frame;
 {
 struct frame *f, *sel_frame;
 struct device *d;
 f = decode_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)
 Lisp_Object frame;
 {
 return Fmake_frame_visible (frame);
 }
 /* FSF returns 'icon for iconized frames.  What a crock! */
 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)
 Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 return (FRAMEMETH_OR_GIVEN (f, frame_totally_visible_p, (f), f->visible)
 			      ? Qt : Qnil);
 }
 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)
 Lisp_Object device;
 {
 Lisp_Object devcons, concons;
 struct frame *f;
 Lisp_Object value;
 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)
 Lisp_Object frame;
 {
 struct frame *f = decode_frame (frame);
 /* Do like the documentation says. */
 Fmake_frame_visible (frame);
 Frame properties can be retrieved using `frame-property' or `frame-properties'.
 The following symbols etc. have predefined meanings:
-name		Name of the frame, used for resourcing.  Unchangeable
+name		Name of the frame, used with X resources.
-		after creation.
+		Unchangeable after creation.
 height		Height of the frame, in lines.
 width		Width of the frame, in characters.
 [default foreground], [default background], [default font],
 [modeline foreground], [modeline background], [modeline font],
 etc.
 		[Giving a vector of a face and a property is equivalent
 		to calling `set-face-property' on the face and property,
-		with a local of FRAME.  Giving the vector to
+		with a locale of FRAME.  Giving the vector to
 		`frame-property' calls `face-property-instance' on the
 		face and property.]
 Finally, if a frame property symbol has the property `frame-property-alias'
 on it, then the value will be used in place of that symbol when looking
 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)
 Lisp_Object frame, plist;
 {
 struct frame *f = decode_frame (frame);
 Lisp_Object tail;
 Lisp_Object *tailp;
 struct gcpro gcpro1, gcpro2;
 Lisp_Object prop = Fcar (tail);
 Lisp_Object val = Fcar (Fcdr (tail));
 prop = get_property_alias (prop);
-if (EQ (prop, Qminibuffer))
-	store_minibuf_frame_prop (f, val);
 #if 0
 /* mly wants this, but it's not reasonable to change the name of a
 	 frame after it has been created, because the old name was used
 	 for resource lookup. */
 if (EQ (prop, Qname))
 XSETFRAME (frame, f);
 property = get_property_alias (property);
-#define FROB(propprop, value) 						\
+#define FROB(propprop, value) 	\
-do {									\
+do {				\
-if (EQ (property, propprop))						\
+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)));
+FROB (Qwidth,  make_int (FRAME_WIDTH  (f)));
 /* NOTE: FSF returns Qnil instead of Qt for FRAME_HAS_MINIBUF_P.
 This is over-the-top bogosity, because it's inconsistent with
 the semantics of `minibuffer' when passed to `make-frame'.
 Returning Qt makes things consistent. */
-FROB (Qminibuffer, (! FRAME_HAS_MINIBUF_P (f) ? Qt
+FROB (Qminibuffer, (FRAME_HAS_MINIBUF_P  (f) ? Qt    :
-		      : FRAME_MINIBUF_ONLY_P (f) ? Qonly
+		      FRAME_MINIBUF_ONLY_P (f) ? Qonly :
-		      : FRAME_MINIBUF_WINDOW (f)));
+		      FRAME_MINIBUF_WINDOW (f)));
 FROB (Qunsplittable, FRAME_NO_SPLIT_P (f) ? Qt : Qnil);
 FROB (Qbuffer_predicate, f->buffer_predicate);
 #undef FROB
 Lisp_Object result = Qnil;
 struct gcpro gcpro1;
 GCPRO1 (result);
-#define FROB(propprop, value)					\
+#define FROB(propprop, value)				\
-do {								\
+do {							\
-Lisp_Object temtem = (value);					\
+Lisp_Object temtem = (value);				\
-if (!NILP (temtem))						\
+if (!NILP (temtem))					\
-/* backwards order; we reverse it below */			\
+/* backwards order; we reverse it below */		\
-result = Fcons (temtem, Fcons (propprop, result));		\
+result = Fcons (temtem, Fcons (propprop, result));	\
 } while (0)
 FROB (Qname, f->name);
 FROB (Qheight, make_int (FRAME_HEIGHT (f)));
-FROB (Qwidth, make_int (FRAME_WIDTH (f)));
+FROB (Qwidth,  make_int (FRAME_WIDTH  (f)));
 /* NOTE: FSF returns Qnil instead of Qt for FRAME_HAS_MINIBUF_P.
 This is over-the-top bogosity, because it's inconsistent with
 the semantics of `minibuffer' when passed to `make-frame'.
 Returning Qt makes things consistent. */
-FROB (Qminibuffer, (! FRAME_HAS_MINIBUF_P (f) ? Qt
+FROB (Qminibuffer, (FRAME_HAS_MINIBUF_P  (f) ? Qt    :
-		      : FRAME_MINIBUF_ONLY_P (f) ? Qonly
+FRAME_MINIBUF_ONLY_P (f) ? Qonly :
-		      : FRAME_MINIBUF_WINDOW (f)));
+		      FRAME_MINIBUF_WINDOW (f)));
 FROB (Qunsplittable, FRAME_NO_SPLIT_P (f) ? Qt : Qnil);
 FROB (Qbuffer_predicate, f->buffer_predicate);
 #undef FROB
 DEFUN ("frame-pixel-height", Fframe_pixel_height, Sframe_pixel_height, 0, 1, 0 /*
 Return the height in pixels of 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 /*
 Return the width in pixels of 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 /*
 Return the name of FRAME (defaulting to the selected frame).
 This is not the same as the `title' of the frame.
 */ )
 (frame)
 Lisp_Object frame;
 {
 return (decode_frame (frame)->name);
 }
 DEFUN ("frame-modified-tick", Fframe_modified_tick, Sframe_modified_tick,
 `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)
 Lisp_Object frame;
 {
 return make_int (decode_frame (frame)->modiff);
 }
 static void
 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)
 Lisp_Object frame, rows, pretend;
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 CHECK_INT (rows);
 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)
 Lisp_Object frame, cols, pretend;
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 CHECK_INT (cols);
 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)
 Lisp_Object frame, cols, rows, pretend;
 {
 struct frame *f = decode_frame (frame);
 XSETFRAME (frame, f);
 CHECK_INT (cols);
 CHECK_INT (rows);
 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)
 Lisp_Object frame, xoffset, yoffset;
 {
 struct frame *f = decode_frame (frame);
 CHECK_INT (xoffset);
 CHECK_INT (yoffset);
 update_frame_title (struct frame *f)
 {
 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 Lisp_Object title_format;
 Lisp_Object icon_format;
-char *frame_title_string = 0;
+Bufbyte *title;
 /* We don't change the title for the minibuffer unless the frame
 only has a minibuffer. */
 if (MINI_WINDOW_P (w) && !FRAME_MINIBUF_ONLY_P (f))
 return;
 /* And we don't want dead buffers to blow up on us. */
-else if (!BUFFER_LIVE_P (XBUFFER (w->buffer)))
+if (!BUFFER_LIVE_P (XBUFFER (w->buffer)))
 return;
-title_format = Vframe_title_format;
+title = NULL;
-icon_format = Vframe_icon_title_format;
+title_format = symbol_value_in_buffer (Qframe_title_format,      w->buffer);
+icon_format  = symbol_value_in_buffer (Qframe_icon_title_format, w->buffer);
-if (HAS_FRAMEMETH_P (f, set_title_from_char))
-{
+if (HAS_FRAMEMETH_P (f, set_title_from_bufbyte))
-frame_title_string =
+{
-	generate_formatted_string (w, title_format, Qnil, DEFAULT_INDEX,
+title = generate_formatted_string (w, title_format, Qnil,
-				   CURRENT_DISP);
+DEFAULT_INDEX, CURRENT_DISP);
-FRAMEMETH (f, set_title_from_char, (f, frame_title_string));
+FRAMEMETH (f, set_title_from_bufbyte, (f, title));
 }
-if (HAS_FRAMEMETH_P (f, set_icon_name_from_char))
+if (HAS_FRAMEMETH_P (f, set_icon_name_from_bufbyte))
 {
-if (!EQ (icon_format, title_format) ||
+if (!EQ (icon_format, title_format) || !title)
-	  !HAS_FRAMEMETH_P (f, set_title_from_char))
 	{
-	  if (frame_title_string)
+	  if (title)
-	    xfree (frame_title_string);
+	    xfree (title);
-	  frame_title_string =
+	  title = generate_formatted_string (w, icon_format, Qnil,
-	    generate_formatted_string (w, icon_format, Qnil, DEFAULT_INDEX,
+DEFAULT_INDEX, CURRENT_DISP);
-				       CURRENT_DISP);
 	}
+FRAMEMETH (f, set_icon_name_from_bufbyte, (f, title));
-FRAMEMETH (f, set_icon_name_from_char, (f, frame_title_string));
+}
-}
+if (title)
-if (frame_title_string)
+xfree (title);
-xfree (frame_title_string);
 }
 DEFUN ("set-frame-pointer", Fset_frame_pointer, Sset_frame_pointer,
 2, 2, 0 /*
 defsymbol (&Qcreate_frame_hook, "create-frame-hook");
 defsymbol (&Qmouse_enter_frame_hook, "mouse-enter-frame-hook");
 defsymbol (&Qmouse_leave_frame_hook, "mouse-leave-frame-hook");
 defsymbol (&Qmap_frame_hook, "map-frame-hook");
 defsymbol (&Qunmap_frame_hook, "unmap-frame-hook");
-#ifdef HAVE_CDE
+#if defined (HAVE_CDE) || defined (HAVE_OFFIX_DND)
 defsymbol (&Qdrag_and_drop_functions, "drag-and-drop-functions");
 #endif
 defsymbol (&Qframep, "framep");
 defsymbol (&Qframe_live_p, "frame-live-p");
 defsymbol (&Qdelete_frame, "delete-frame");
 defsymbol (&Qsynchronize_minibuffers, "synchronize-minibuffers");
 defsymbol (&Qbuffer_predicate, "buffer-predicate");
 defsymbol (&Qframe_being_created, "frame-being-created");
 defsymbol (&Qmake_initial_minibuffer_frame, "make-initial-minibuffer-frame");
+defsymbol (&Qframe_title_format, "frame-title-format");
+defsymbol (&Qframe_icon_title_format, "frame-icon-title-format");
 defsymbol (&Qvisible, "visible");
 defsymbol (&Qiconic, "iconic");
 defsymbol (&Qinvisible, "invisible");
 defsymbol (&Qvisible_iconic, "visible-iconic");
 Vdeselect_frame_hook = Qnil;
 DEFVAR_LISP ("delete-frame-hook", &Vdelete_frame_hook /*
 Function or functions to call when a frame is deleted.
 One argument, the to-be-deleted frame.
+When this hook is called, the selected frame is different from
+the to-be-deleted frame, and the hook should not change that.
 */ );
 Vdelete_frame_hook = Qnil;
 DEFVAR_LISP ("create-frame-hook", &Vcreate_frame_hook /*
 Function or functions to call when a frame is created.
 	       &Vallow_deletion_of_last_visible_frame /*
 *Non-nil means to assume the force option to delete-frame.
 */ );
 Vallow_deletion_of_last_visible_frame = Qnil;
-#ifdef HAVE_CDE
+#if defined (HAVE_CDE) || defined (HAVE_OFFIX_DND)
 DEFVAR_LISP ("drag-and-drop-functions", &Vdrag_and_drop_functions /*
 Function or functions to run when an object is dropped on a frame.
-Each function is called with two args, a frame and a pathname.
+Each function is called with either two or three args.  If called with
+two args, the args are a frame and a pathname.  If with three, the
+args are a frame, a pathname (which is may be either a string or nil)
+and the textual representation of the dragged object.
 */ );
 Vdrag_and_drop_functions = Qnil;
 #endif
 DEFVAR_LISP ("mouse-motion-handler", &Vmouse_motion_handler /*

Mercurial > hg > xemacs-beta

comparison src/frame.c @ 2:ac2d302a0011 r19-15b2