#include "faces.h"
#include "frame.h"
#include "glyphs.h"
-#include "gutter.h"
#include "menubar.h"
#include "redisplay.h"
#include "scrollbar.h"
#include "window.h"
+#include <errno.h>
+#include "sysdep.h"
+
Lisp_Object Vselect_frame_hook, Qselect_frame_hook;
Lisp_Object Vdeselect_frame_hook, Qdeselect_frame_hook;
Lisp_Object Vcreate_frame_hook, Qcreate_frame_hook;
Lisp_Object Qborder_width;
Lisp_Object Qframep, Qframe_live_p;
+Lisp_Object Qframe_x_p, Qframe_tty_p;
Lisp_Object Qdelete_frame;
Lisp_Object Qframe_title_format, Vframe_title_format;
Lisp_Object Qnomini, Qvisible_nomini, Qiconic_nomini, Qinvisible_nomini;
Lisp_Object Qvisible_iconic_nomini, Qinvisible_iconic_nomini;
-Lisp_Object Qset_specifier, Qset_face_property;
+Lisp_Object Qset_specifier, Qset_glyph_image, Qset_face_property;
Lisp_Object Qface_property_instance;
Lisp_Object Qframe_property_alias;
Lisp_Object Qframe_being_created;
static void store_minibuf_frame_prop (struct frame *f, Lisp_Object val);
-static struct display_line title_string_display_line;
-/* Used by generate_title_string. Global because they get used so much that
- the dynamic allocation time adds up. */
-static Emchar_dynarr *title_string_emchar_dynarr;
+
+EXFUN (Fset_frame_properties, 2);
\f
static Lisp_Object
-mark_frame (Lisp_Object obj)
+mark_frame (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
struct frame *f = XFRAME (obj);
-#define MARKED_SLOT(x) mark_object (f->x)
+#define MARKED_SLOT(x) ((markobj) (f->x));
#include "frameslots.h"
if (FRAME_LIVE_P (f)) /* device is nil for a dead frame */
- MAYBE_FRAMEMETH (f, mark_frame, (f));
+ MAYBE_FRAMEMETH (f, mark_frame, (f, markobj));
return Qnil;
}
}
DEFINE_LRECORD_IMPLEMENTATION ("frame", frame,
- mark_frame, print_frame, 0, 0, 0, 0,
+ mark_frame, print_frame, 0, 0, 0,
struct frame);
\f
static void
nuke_all_frame_slots (struct frame *f)
{
-#define MARKED_SLOT(x) f->x = Qnil
+#define MARKED_SLOT(x) f->x = Qnil;
#include "frameslots.h"
}
/* This function can GC */
Lisp_Object frame;
Lisp_Object root_window;
- struct frame *f = alloc_lcrecord_type (struct frame, &lrecord_frame);
+ struct frame *f = alloc_lcrecord_type (struct frame, lrecord_frame);
zero_lcrecord (f);
nuke_all_frame_slots (f);
XWINDOW (root_window)->frame = frame;
/* 10 is arbitrary,
- Just so that there is "something there."
+ just so that there is "something there."
Correct size will be set up later with change_frame_size. */
- f->width = 10;
+ f->width = 10;
f->height = 10;
XWINDOW (root_window)->pixel_width = 10;
XWINDOW (root_window)->pixel_height = 9;
+ /* The size of the minibuffer window is now set in x_create_frame
+ in xfns.c. */
+
f->root_window = root_window;
f->selected_window = root_window;
f->last_nonminibuf_window = root_window;
- /* cache of subwindows visible on frame */
- f->subwindow_instance_cache = make_weak_list (WEAK_LIST_SIMPLE);
-
- /* associated exposure ignore list */
- f->subwindow_exposures = 0;
- f->subwindow_exposures_tail = 0;
-
- FRAME_SET_PAGENUMBER (f, 1);
-
/* Choose a buffer for the frame's root window. */
XWINDOW (root_window)->buffer = Qt;
{
a space), try to find another one. */
if (string_char (XSTRING (Fbuffer_name (buf)), 0) == ' ')
buf = Fother_buffer (buf, Qnil, Qnil);
- Fset_window_buffer (root_window, buf, Qnil);
+ Fset_window_buffer (root_window, buf);
}
return f;
f->has_minibuffer = 1;
XWINDOW (mini_window)->buffer = Qt;
- Fset_window_buffer (mini_window, Vminibuffer_zero, Qt);
+ Fset_window_buffer (mini_window, Vminibuffer_zero);
}
/* Make a frame using a separate minibuffer window on another frame.
FRAME_CONSOLE (XFRAME (XWINDOW (mini_window)->frame))))
error ("frame and minibuffer must be on the same console");
- /* Do not create a default minibuffer frame on printer devices. */
- if (NILP (mini_window)
- && DEVICE_DISPLAY_P (XDEVICE (FRAME_DEVICE (f))))
+ if (NILP (mini_window))
{
struct console *con = XCONSOLE (FRAME_CONSOLE (f));
/* Use default-minibuffer-frame if possible. */
}
/* Install the chosen minibuffer window, with proper buffer. */
- if (!NILP (mini_window))
- {
- store_minibuf_frame_prop (f, mini_window);
- Fset_window_buffer (mini_window, Vminibuffer_zero, Qt);
- }
- else
- f->minibuffer_window = Qnil;
+ store_minibuf_frame_prop (f, mini_window);
+ Fset_window_buffer (mini_window, Vminibuffer_zero);
}
/* Make a frame containing only a minibuffer window. */
/* Put the proper buffer in that window. */
- Fset_window_buffer (mini_window, Vminibuffer_zero, Qt);
+ Fset_window_buffer (mini_window, Vminibuffer_zero);
}
static Lisp_Object
else
name = build_string ("emacs");
- if (!NILP (Fstring_match (make_string ((const Bufbyte *) "\\.", 2), name,
+ if (!NILP (Fstring_match (make_string ((CONST Bufbyte *) "\\.", 2), name,
Qnil, Qnil)))
signal_simple_error (". not allowed in frame names", name);
update_frame_window_mirror (f);
- if (initialized && !DEVICE_STREAM_P (d))
+ if (initialized)
{
if (!NILP (f->minibuffer_window))
reset_face_cachels (XWINDOW (f->minibuffer_window));
things. */
init_frame_toolbars (f);
#endif
+
reset_face_cachels (XWINDOW (FRAME_SELECTED_WINDOW (f)));
reset_glyph_cachels (XWINDOW (FRAME_SELECTED_WINDOW (f)));
-
change_frame_size (f, f->height, f->width, 0);
}
MAYBE_FRAMEMETH (f, after_init_frame, (f, first_frame_on_device,
first_frame_on_console));
- if (!DEVICE_STREAM_P (d))
- {
- /* Now initialise the gutters. This won't change the frame size,
- but is needed as input to the layout that change_frame_size
- will eventually do. Unfortunately gutter sizing code relies
- on the frame in question being visible so we can't do this
- earlier. */
- init_frame_gutters (f);
-
- change_frame_size (f, f->height, f->width, 0);
- }
-
if (first_frame_on_device)
{
if (first_frame_on_console)
void
invalidate_vertical_divider_cache_in_frame (struct frame *f)
{
- /* Invalidate cached value of needs_vertical_divider_p in
+ /* Invalidate cached value of needs_vertical_divider_p in
every and all windows */
map_windows (f, invalidate_vertical_divider_cache_in_window, 0);
}
f->selected_window = window;
if (!MINI_WINDOW_P (XWINDOW (window)) || FRAME_MINIBUF_ONLY_P (f))
{
- if (!EQ (f->last_nonminibuf_window, window))
- {
#ifdef HAVE_TOOLBARS
- MARK_TOOLBAR_CHANGED;
-#endif
- MARK_GUTTER_CHANGED;
- }
+ if (!EQ (f->last_nonminibuf_window, window))
+ MARK_TOOLBAR_CHANGED;
+#endif
f->last_nonminibuf_window = window;
}
}
DEFUN ("set-frame-selected-window", Fset_frame_selected_window, 2, 2, 0, /*
-Set the selected window of FRAME to WINDOW.
+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.
*/
}
static int
-frame_matches_frame_spec (Lisp_Object frame, Lisp_Object type)
+frame_matches_frametype (Lisp_Object frame, Lisp_Object type)
{
struct frame *f = XFRAME (frame);
}
int
-device_matches_device_spec (Lisp_Object device, Lisp_Object device_spec)
+device_matches_console_spec (Lisp_Object frame, Lisp_Object device,
+ Lisp_Object console)
{
- if (EQ (device_spec, Qwindow_system))
+ if (EQ (console, Qwindow_system))
return DEVICE_WIN_P (XDEVICE (device));
- if (DEVICEP (device_spec))
- return EQ (device, device_spec);
- if (CONSOLEP (device_spec))
- return EQ (DEVICE_CONSOLE (XDEVICE (device)), device_spec);
- if (valid_console_type_p (device_spec))
- return EQ (DEVICE_TYPE (XDEVICE (device)), device_spec);
+ 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 EQ (DEVICE_TYPE (XDEVICE (device)), console);
return 1;
}
/* Return the next frame in the frame list after FRAME.
- WHICH-FRAMES and WHICH-DEVICES control which frames and devices
+ FRAMETYPE and CONSOLE control which frames and devices
are considered; see `next-frame'. */
-Lisp_Object
-next_frame (Lisp_Object frame, Lisp_Object which_frames, Lisp_Object which_devices)
+static Lisp_Object
+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);
- DEVICE_LOOP_NO_BREAK (devcons, concons)
+ while (1)
{
- Lisp_Object device = XCAR (devcons);
- Lisp_Object frmcons;
+ Lisp_Object devcons, concons;
- if (!device_matches_device_spec (device, which_devices))
+ DEVICE_LOOP_NO_BREAK (devcons, concons)
{
- if (EQ (device, FRAME_DEVICE (XFRAME (frame))))
- passed = 1;
- continue;
- }
+ Lisp_Object device = XCAR (devcons);
+ Lisp_Object frmcons;
- DEVICE_FRAME_LOOP (frmcons, XDEVICE (device))
- {
- Lisp_Object f = XCAR (frmcons);
+ if (!device_matches_console_spec (frame, device, console))
+ continue;
- if (passed)
+ DEVICE_FRAME_LOOP (frmcons, XDEVICE (device))
{
- if (frame_matches_frame_spec (f, which_frames))
- return f;
- }
- else
- {
- if (EQ (frame, f))
- {
- passed = 1;
- }
- else
+ Lisp_Object f = XCAR (frmcons);
+ if (passed)
{
- if (NILP (first) && frame_matches_frame_spec (f, which_frames))
- first = f;
+ /* #### 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;
}
+
+ if (EQ (frame, f))
+ passed++;
}
}
+ /* We hit the end of the list, and need to start over again. */
+ if (started_over)
+ return Qnil;
+ started_over++;
}
+}
- if (NILP (first))
- /* 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 after FRAME; otherwise,
- we would have returned directly from the loop. Since FIRST is the last
- acceptable frame in the list, return it. */
- return first;
+Lisp_Object
+next_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
+{
+ return next_frame_internal (frame, frametype, console, 0);
}
/* Return the previous frame in the frame list before FRAME.
- WHICH-FRAMES and WHICH-DEVICES control which frames and devices
+ FRAMETYPE and CONSOLE control which frames and devices
are considered; see `next-frame'. */
Lisp_Object
-previous_frame (Lisp_Object frame, Lisp_Object which_frames, Lisp_Object which_devices)
+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_device_spec (device, which_devices))
- {
- if (EQ (device, FRAME_DEVICE (XFRAME (frame)))
- && !NILP (last))
- return last;
- continue;
- }
+ if (!device_matches_console_spec (frame, device, console))
+ continue;
DEVICE_FRAME_LOOP (frmcons, XDEVICE (device))
{
Lisp_Object f = XCAR (frmcons);
- if (EQ (frame, f))
- {
- if (!NILP (last))
- return last;
- }
- else
- {
- if (frame_matches_frame_spec (f, which_frames))
- last = f;
- }
+ 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;
+
}
}
- if (NILP (last))
+ /* We've scanned the entire list. */
+ 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.
-WHICH-FRAMES controls which frames are eligible to be returned; all
+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
returned.
-Possible values for WHICH-FRAMES are
+Possible values for FRAMETYPE are
'visible Consider only frames that are visible.
'iconic Consider only frames that are iconic.
frames.
any other value Consider all frames.
-If WHICH-FRAMES is omitted, 'nomini is used. A value for WHICH-FRAMES
-of 0 (a number) is treated like 'iconic, for backwards compatibility.
+If FRAMETYPE is omitted, 'nomini is used. A FRAMETYPE of 0 (a number)
+is treated like 'iconic, for backwards compatibility.
-If WHICH-FRAMES is a window, include only its own frame and any frame
-now using that window as the minibuffer.
+If FRAMETYPE is a window, include only its own frame and any frame now
+using that window as the minibuffer.
-The optional third argument WHICH-DEVICES further clarifies on which
-devices to search for frames as specified by WHICH-FRAMES.
-If nil or omitted, search all devices on FRAME's console.
-If a device, only search that device.
-If a console, search all devices on that console.
-If a device type, search all devices of that type.
-If `window-system', search all window-system devices.
-Any other non-nil value means search all devices.
+Optional third argument CONSOLE controls which consoles or devices the
+returned frame may be on. If CONSOLE is a console, return frames only
+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, which_frames, which_devices))
+ (frame, frametype, console))
{
XSETFRAME (frame, decode_frame (frame));
- return next_frame (frame, which_frames, which_devices);
+ 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.
-WHICH-FRAMES controls which frames are eligible to be returned; all
+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 WHICH-FRAMES and WHICH-DEVICES
+See `next-frame' for an explanation of the FRAMETYPE and CONSOLE
arguments.
*/
- (frame, which_frames, which_devices))
+ (frame, frametype, console))
{
XSETFRAME (frame, decode_frame (frame));
- return previous_frame (frame, which_frames, which_devices);
+ return prev_frame (frame, frametype, console);
}
/* Return any frame for which PREDICATE is non-zero, or return Qnil
(Exception: if F is a stream frame, it's OK to delete if
any other frames exist.) */
-int
-other_visible_frames (struct frame *f)
+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 (frame, Qt, Qt));
- return !EQ (frame, next_frame (frame, Qvisible_iconic_nomini, Qt));
+ 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)
+{
+ return other_visible_frames_internal (f, 0);
}
/* Delete frame F.
console = DEVICE_CONSOLE (d);
con = XCONSOLE (console);
- if (!called_from_delete_device &&
- !(MAYBE_INT_DEVMETH (d, device_implementation_flags, ())
- & XDEVIMPF_FRAMELESS_OK))
+ if (!called_from_delete_device)
{
/* If we're deleting the only non-minibuffer frame on the
device, delete the device. */
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
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 (!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))
- set_device_selected_frame (d, Qnil);
+ ;
else
set_device_selected_frame (d, next_f);
}
{
struct frame *sel_frame = selected_frame ();
Fset_window_buffer (sel_frame->minibuffer_window,
- XWINDOW (minibuf_window)->buffer, Qt);
+ XWINDOW (minibuf_window)->buffer);
minibuf_window = sel_frame->minibuffer_window;
/* If the dying minibuffer window was selected,
#ifdef HAVE_TOOLBARS
free_frame_toolbars (f);
#endif
- free_frame_gutters (f);
- /* Unfortunately deleting the frame will also delete the parent of
- all of the subwindow instances current on the frame. I think this
- can lead to bad things when trying to finalize the
- instances. Thus we loop over all instance caches calling the
- finalize method for each instance. */
- free_frame_subwindow_instances (f);
/* This must be done before the window and window_mirror structures
are freed. The scrollbar information is attached to them. */
delete_all_subwindows (XWINDOW (f->root_window));
f->root_window = Qnil;
- /* clear out the cached glyph information */
- f->subwindow_instance_cache = Qnil;
-
/* Remove the frame now from the list. This way, any events generated
on this frame by the maneuvers below will disperse themselves. */
DEFUN ("mouse-pixel-position", Fmouse_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
-of the window.
+The position is given in pixel units, where (0, 0) is the upper-left corner.
When the cursor is not over a window, the return value is a list (nil nil).
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 XEmacs hasn't been programmed to read its mouse position, it returns
+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))
struct window *w;
int pix_x, pix_y;
- CHECK_LIVE_WINDOW (window);
+ CHECK_WINDOW (window);
CHECK_INT (x);
CHECK_INT (y);
{
struct window *w;
- CHECK_LIVE_WINDOW (window);
+ CHECK_WINDOW (window);
CHECK_INT (x);
CHECK_INT (y);
if (EQ (f->minibuffer_window, minibuf_window))
{
Fset_window_buffer (sel_frame->minibuffer_window,
- XWINDOW (minibuf_window)->buffer, Qt);
+ XWINDOW (minibuf_window)->buffer);
minibuf_window = sel_frame->minibuffer_window;
}
if (EQ (f->minibuffer_window, minibuf_window))
{
Fset_window_buffer (sel_frame->minibuffer_window,
- XWINDOW (minibuf_window)->buffer, Qt);
+ XWINDOW (minibuf_window)->buffer);
minibuf_window = sel_frame->minibuffer_window;
}
A frame that is not visible is not updated, and, if it works through a
window system, may not show at all.
N.B. Under X "visible" means Mapped. It the window is mapped but not
-actually visible on screen then `frame-visible-p' returns 'hidden.
+actually visible on screen then frame_visible returns 'hidden.
*/
(frame))
{
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.
-Note that under virtual window managers not all these frames are
-necessarily really updated.
+Note that under virtual window managers not all these frame are necessarily
+really updated.
*/
(device))
{
return Qnil;
}
-\f
-DEFUN ("disable-frame", Fdisable_frame, 1, 1, 0, /*
-Disable frame FRAME, so that it cannot have the focus or receive user input.
-This is normally used during modal dialog boxes.
-WARNING: Be very careful not to wedge XEmacs!
-Use an `unwind-protect' that re-enables the frame to avoid this.
-*/
- (frame))
-{
- struct frame *f = decode_frame (frame);
-
- f->disabled = 1;
- MAYBE_FRAMEMETH (f, disable_frame, (f));
- return Qnil;
-}
-
-DEFUN ("enable-frame", Fenable_frame, 1, 1, 0, /*
-Enable frame FRAME, so that it can have the focus and receive user input.
-Frames are normally enabled, unless explicitly disabled using `disable-frame'.
-*/
- (frame))
-{
- struct frame *f = decode_frame (frame);
- f->disabled = 0;
- MAYBE_FRAMEMETH (f, enable_frame, (f));
- return Qnil;
-}
-
/* Ben thinks there is no need for `redirect-frame-focus' or `frame-focus',
crockish FSFmacs functions. See summary on focus in event-stream.c. */
-\f
-DEFUN ("print-job-page-number", Fprint_job_page_number, 1, 1, 0, /*
-Return current page number for the print job FRAME.
-*/
- (frame))
-{
- CHECK_PRINTER_FRAME (frame);
- return make_int (FRAME_PAGENUMBER (XFRAME (frame)));
-}
-
-DEFUN ("print-job-eject-page", Fprint_job_eject_page, 1, 1, 0, /*
-Eject page in the print job FRAME.
-*/
- (frame))
-{
- struct frame *f;
-
- CHECK_PRINTER_FRAME (frame);
- f = XFRAME (frame);
- FRAMEMETH (f, eject_page, (f));
- FRAME_SET_PAGENUMBER (f, 1 + FRAME_PAGENUMBER (f));
- f->clear = 1;
-
- return Qnil;
-}
\f
/***************************************************************************/
Lisp_Object *face_prop_out)
{
Lisp_Object list = Vbuilt_in_face_specifiers;
- Lisp_String *s;
+ struct Lisp_String *s;
if (!SYMBOLP (sym))
return 0;
while (!NILP (list))
{
Lisp_Object prop = Fcar (list);
- Lisp_String *prop_name;
+ struct Lisp_String *prop_name;
if (!SYMBOLP (prop))
continue;
minibuffer Gives the minibuffer behavior for this frame. Either
t (frame has its own minibuffer), `only' (frame is
- a minibuffer-only frame), `none' (frame has no minibuffer)
- or a window (frame uses that window, which is on another
- frame, as the minibuffer).
+ a minibuffer-only frame), or a window (frame uses that
+ window, which is on another frame, as the minibuffer).
unsplittable If non-nil, frame cannot be split by `display-buffer'.
left-toolbar-visible-p, right-toolbar-visible-p, toolbar-buttons-captioned-p,
top-toolbar-border-width, bottom-toolbar-border-width,
left-toolbar-border-width, right-toolbar-border-width,
- modeline-shadow-thickness, has-modeline-p,
- default-gutter, top-gutter, bottom-gutter, left-gutter, right-gutter,
- default-gutter-height, default-gutter-width, top-gutter-height,
- bottom-gutter-height, left-gutter-width, right-gutter-width,
- default-gutter-visible-p, top-gutter-visible-p, bottom-gutter-visible-p,
- left-gutter-visible-p, right-gutter-visible-p, top-gutter-border-width,
- bottom-gutter-border-width, left-gutter-border-width, right-gutter-border-width,
+ modeline-shadow-thickness, has-modeline-p
[Giving the name of any built-in specifier variable is
equivalent to calling `set-specifier' on the specifier,
with a locale of FRAME. Giving the name to `frame-property'
DEFUN ("frame-property", Fframe_property, 2, 3, 0, /*
Return FRAME's value for property PROPERTY.
-Return DEFAULT if there is no such property.
See `set-frame-properties' for the built-in property names.
*/
(frame, property, default_))
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, lines, pretend))
+ (frame, rows, pretend))
{
struct frame *f = decode_frame (frame);
int height, width;
XSETFRAME (frame, f);
- CHECK_INT (lines);
+ CHECK_INT (rows);
if (window_system_pixelated_geometry (frame))
{
- char_to_real_pixel_size (f, 0, XINT (lines), 0, &height);
+ char_to_real_pixel_size (f, 0, XINT (rows), 0, &height);
width = FRAME_PIXWIDTH (f);
}
else
{
- height = XINT (lines);
+ height = XINT (rows);
width = FRAME_WIDTH (f);
}
}
DEFUN ("set-frame-size", Fset_frame_size, 3, 4, 0, /*
-Set the size of FRAME to COLS by ROWS, measured in characters.
+Set the 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.
*/
window = FRAME_SELECTED_WINDOW (f);
- egw = max (glyph_width (Vcontinuation_glyph, window),
- glyph_width (Vtruncation_glyph, window));
+ egw = max (glyph_width (Vcontinuation_glyph, Vdefault_face, 0, window),
+ glyph_width (Vtruncation_glyph, Vdefault_face, 0, window));
egw = max (egw, cpw);
bdr = 2 * f->internal_border_width;
obw = FRAME_SCROLLBAR_WIDTH (f) + FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH (f) +
/* when frame_conversion_internal() calculated the number of rows/cols
in the frame, the theoretical toolbar sizes were subtracted out.
- The calculations below adjust for real toolbar height/width in
+ The caluclations below adjust for real toolbar height/width in
frame, which may be different from frame spec, taking the above
fact into account */
new_pixheight +=
+ 2 * FRAME_THEORETICAL_TOP_TOOLBAR_BORDER_WIDTH (f)
- FRAME_REAL_TOP_TOOLBAR_HEIGHT (f)
- 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f);
-
+
new_pixheight +=
+ FRAME_THEORETICAL_BOTTOM_TOOLBAR_HEIGHT (f)
+ 2 * FRAME_THEORETICAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f)
+ 2 * FRAME_THEORETICAL_LEFT_TOOLBAR_BORDER_WIDTH (f)
- FRAME_REAL_LEFT_TOOLBAR_WIDTH (f)
- 2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f);
-
+
new_pixwidth +=
+ FRAME_THEORETICAL_RIGHT_TOOLBAR_WIDTH (f)
+ 2 * FRAME_THEORETICAL_RIGHT_TOOLBAR_BORDER_WIDTH (f)
- FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f)
- 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f);
-
+
/* Adjust the width for the end glyph which may be a different width
than the default character width. */
{
int adjustment, trunc_width, cont_width;
- trunc_width = glyph_width (Vtruncation_glyph,
+ trunc_width = glyph_width (Vtruncation_glyph, Vdefault_face, 0,
FRAME_SELECTED_WINDOW (f));
- cont_width = glyph_width (Vcontinuation_glyph,
+ cont_width = glyph_width (Vcontinuation_glyph, Vdefault_face, 0,
FRAME_SELECTED_WINDOW (f));
adjustment = max (trunc_width, cont_width);
adjustment = max (adjustment, font_width);
if (new_pixheight)
{
- /* Adjust for gutters here so that we always get set
- properly. */
- new_pixheight -=
- (FRAME_TOP_GUTTER_BOUNDS (f)
- + FRAME_BOTTOM_GUTTER_BOUNDS (f));
-
- XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top
- = FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f);
+ XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top = FRAME_TOP_BORDER_END (f);
if (FRAME_HAS_MINIBUF_P (f)
&& ! FRAME_MINIBUF_ONLY_P (f))
new_pixheight - minibuf_height, 0);
XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_top =
- FRAME_TOP_BORDER_END (f) +
- FRAME_TOP_GUTTER_BOUNDS (f) +
- FRAME_BOTTOM_GUTTER_BOUNDS (f) +
- new_pixheight - minibuf_height;
+ new_pixheight - minibuf_height + FRAME_TOP_BORDER_END (f);
set_window_pixheight (FRAME_MINIBUF_WINDOW (f), minibuf_height, 0);
}
if (new_pixwidth)
{
- /* Adjust for gutters here so that we always get set
- properly. */
- new_pixwidth -=
- (FRAME_LEFT_GUTTER_BOUNDS (f)
- + FRAME_RIGHT_GUTTER_BOUNDS (f));
-
- XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left =
- FRAME_LEFT_BORDER_END (f) + FRAME_LEFT_GUTTER_BOUNDS (f);
+ XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left = FRAME_LEFT_BORDER_END (f);
set_window_pixwidth (FRAME_ROOT_WINDOW (f), new_pixwidth, 0);
if (FRAME_HAS_MINIBUF_P (f))
{
XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_left =
- FRAME_LEFT_BORDER_END (f) + FRAME_LEFT_GUTTER_BOUNDS (f);
+ FRAME_LEFT_BORDER_END (f);
set_window_pixwidth (FRAME_MINIBUF_WINDOW (f), new_pixwidth, 0);
}
FRAME_CHARWIDTH (f) = FRAME_WIDTH (f);
FRAME_CHARHEIGHT (f) = FRAME_HEIGHT (f);
}
-
+
MARK_FRAME_TOOLBARS_CHANGED (f);
- MARK_FRAME_GUTTERS_CHANGED (f);
MARK_FRAME_CHANGED (f);
f->echo_area_garbaged = 1;
}
So deal. */
check_frame_size (f, &newheight, &newwidth);
- /* Unconditionally mark that the frame has changed size. This is
- because many things need to know after the
- fact. f->size_change_pending will get reset below. The most that
- can happen is that we will cycle through redisplay once more
- --andy. */
- MARK_FRAME_SIZE_CHANGED (f);
-
if (delay || in_display || gc_in_progress)
{
+ MARK_FRAME_SIZE_CHANGED (f);
f->new_width = newwidth;
f->new_height = newheight;
return;
}
\f
-/* The caller is responsible for freeing the returned string. */
-static Bufbyte *
-generate_title_string (struct window *w, Lisp_Object format_str,
- face_index findex, int type)
-{
- struct display_line *dl;
- struct display_block *db;
- int elt = 0;
-
- dl = &title_string_display_line;
- db = get_display_block_from_line (dl, TEXT);
- Dynarr_reset (db->runes);
-
- generate_formatted_string_db (format_str, Qnil, w, dl, db, findex, 0,
- -1, type);
-
- Dynarr_reset (title_string_emchar_dynarr);
- while (elt < Dynarr_length (db->runes))
- {
- if (Dynarr_atp (db->runes, elt)->type == RUNE_CHAR)
- Dynarr_add (title_string_emchar_dynarr,
- Dynarr_atp (db->runes, elt)->object.chr.ch);
- elt++;
- }
-
- return
- convert_emchar_string_into_malloced_string
- (Dynarr_atp (title_string_emchar_dynarr, 0),
- Dynarr_length (title_string_emchar_dynarr), 0);
-}
-
void
update_frame_title (struct frame *f)
{
if (HAS_FRAMEMETH_P (f, set_title_from_bufbyte))
{
- title = generate_title_string (w, title_format,
- DEFAULT_INDEX, CURRENT_DISP);
+ title = generate_formatted_string (w, title_format, Qnil,
+ DEFAULT_INDEX, CURRENT_DISP);
FRAMEMETH (f, set_title_from_bufbyte, (f, title));
}
if (title)
xfree (title);
- title = generate_title_string (w, icon_format,
- DEFAULT_INDEX, CURRENT_DISP);
+ title = generate_formatted_string (w, icon_format, Qnil,
+ DEFAULT_INDEX, CURRENT_DISP);
}
FRAMEMETH (f, set_icon_name_from_bufbyte, (f, title));
}
}
\f
-/***************************************************************************/
-/* */
-/* initialization */
-/* */
-/***************************************************************************/
-
-void
-init_frame (void)
-{
-#ifndef PDUMP
- if (!initialized)
-#endif
- {
- title_string_emchar_dynarr = Dynarr_new (Emchar);
- xzero (title_string_display_line);
- }
-}
-
void
syms_of_frame (void)
{
- INIT_LRECORD_IMPLEMENTATION (frame);
-
defsymbol (&Qdelete_frame_hook, "delete-frame-hook");
defsymbol (&Qselect_frame_hook, "select-frame-hook");
defsymbol (&Qdeselect_frame_hook, "deselect-frame-hook");
defsymbol (&Qframep, "framep");
defsymbol (&Qframe_live_p, "frame-live-p");
+ defsymbol (&Qframe_x_p, "frame-x-p");
+ defsymbol (&Qframe_tty_p, "frame-tty-p");
defsymbol (&Qdelete_frame, "delete-frame");
defsymbol (&Qsynchronize_minibuffers, "synchronize-minibuffers");
defsymbol (&Qbuffer_predicate, "buffer-predicate");
defsymbol (&Qborder_width, "border-width");
/* Qwidth, Qheight, Qleft, Qtop in general.c */
defsymbol (&Qset_specifier, "set-specifier");
+ 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 (Fvisible_frame_list);
DEFSUBR (Fraise_frame);
DEFSUBR (Flower_frame);
- DEFSUBR (Fdisable_frame);
- DEFSUBR (Fenable_frame);
DEFSUBR (Fframe_property);
DEFSUBR (Fframe_properties);
DEFSUBR (Fset_frame_properties);
DEFSUBR (Fset_frame_size);
DEFSUBR (Fset_frame_position);
DEFSUBR (Fset_frame_pointer);
- DEFSUBR (Fprint_job_page_number);
- DEFSUBR (Fprint_job_eject_page);
}
void
Vsynchronize_minibuffers = Qnil;
DEFVAR_LISP ("frame-title-format", &Vframe_title_format /*
-Controls the title of the window-system window of the selected frame.
+Controls the title of the X window corresponding to the selected frame.
This is the same format as `modeline-format' with the exception that
%- is ignored.
*/ );
-/* #### I would change this unilaterally but for the wrath of the Kyles
-of the world. */
-#ifdef WIN32_NATIVE
- Vframe_title_format = build_string ("%b - XEmacs");
-#else
- Vframe_title_format = build_string ("%S: %b");
-#endif
+ Vframe_title_format = Fpurecopy (build_string ("%S: %b"));
DEFVAR_LISP ("frame-icon-title-format", &Vframe_icon_title_format /*
Controls the title of the icon corresponding to the selected frame.
See also the variable `frame-title-format'.
*/ );
- Vframe_icon_title_format = build_string ("%b");
+ Vframe_icon_title_format = Fpurecopy (build_string ("%b"));
DEFVAR_LISP ("default-frame-name", &Vdefault_frame_name /*
The default name to assign to newly-created frames.
-This can be overridden by arguments to `make-frame'. This must be a string.
-This is used primarily for picking up X resources, and is *not* the title
-of the frame. (See `frame-title-format'.)
+This can be overridden by arguments to `make-frame'.
+This must be a string.
*/ );
#ifndef INFODOCK
- Vdefault_frame_name = build_string ("emacs");
+ Vdefault_frame_name = Fpurecopy (build_string ("emacs"));
#else
- Vdefault_frame_name = build_string ("InfoDock");
+ Vdefault_frame_name = Fpurecopy (build_string ("InfoDock"));
#endif
DEFVAR_LISP ("default-frame-plist", &Vdefault_frame_plist /*