}
DEFUN ("set-frame-selected-window", Fset_frame_selected_window, 2, 2, 0, /*
-Set the selected window of frame object FRAME to WINDOW.
+Set the selected window of 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_frametype (Lisp_Object frame, Lisp_Object type)
+frame_matches_frame_spec (Lisp_Object frame, Lisp_Object type)
{
struct frame *f = XFRAME (frame);
}
int
-device_matches_console_spec (Lisp_Object device, Lisp_Object console)
+device_matches_device_spec (Lisp_Object device, Lisp_Object device_spec)
{
- if (EQ (console, Qwindow_system))
+ if (EQ (device_spec, Qwindow_system))
return DEVICE_WIN_P (XDEVICE (device));
- 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);
+ 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);
return 1;
}
/* Return the next frame in the frame list after FRAME.
- FRAMETYPE and CONSOLE control which frames and devices
+ WHICH-FRAMES and WHICH-DEVICES control which frames and devices
are considered; see `next-frame'. */
Lisp_Object
-next_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
+next_frame (Lisp_Object frame, Lisp_Object which_frames, Lisp_Object which_devices)
{
Lisp_Object first = Qnil;
Lisp_Object devcons, concons;
Lisp_Object device = XCAR (devcons);
Lisp_Object frmcons;
- if (!device_matches_console_spec (device, console))
+ if (!device_matches_device_spec (device, which_devices))
{
if (EQ (device, FRAME_DEVICE (XFRAME (frame))))
passed = 1;
if (passed)
{
- if (frame_matches_frametype (f, frametype))
+ if (frame_matches_frame_spec (f, which_frames))
return f;
}
else
}
else
{
- if (NILP (first) && frame_matches_frametype (f, frametype))
+ if (NILP (first) && frame_matches_frame_spec (f, which_frames))
first = f;
}
}
}
/* Return the previous frame in the frame list before FRAME.
- FRAMETYPE and CONSOLE control which frames and devices
+ WHICH-FRAMES and WHICH-DEVICES control which frames and devices
are considered; see `next-frame'. */
Lisp_Object
-previous_frame (Lisp_Object frame, Lisp_Object frametype, Lisp_Object console)
+previous_frame (Lisp_Object frame, Lisp_Object which_frames, Lisp_Object which_devices)
{
Lisp_Object devcons, concons;
Lisp_Object last = Qnil;
Lisp_Object device = XCAR (devcons);
Lisp_Object frmcons;
- if (!device_matches_console_spec (device, console))
+ if (!device_matches_device_spec (device, which_devices))
{
if (EQ (device, FRAME_DEVICE (XFRAME (frame)))
&& !NILP (last))
}
else
{
- if (frame_matches_frametype (f, frametype))
+ if (frame_matches_frame_spec (f, which_frames))
last = f;
}
}
DEFUN ("next-frame", Fnext_frame, 0, 3, 0, /*
Return the next frame of the right type in the frame list after FRAME.
-FRAMETYPE controls which frames are eligible to be returned; all
+WHICH-FRAMES 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 FRAMETYPE are
+Possible values for WHICH-FRAMES are
'visible Consider only frames that are visible.
'iconic Consider only frames that are iconic.
frames.
any other value Consider all frames.
-If FRAMETYPE is omitted, 'nomini is used. A FRAMETYPE of 0 (a number)
-is treated like 'iconic, for backwards compatibility.
+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 a window, include only its own frame and any frame now
-using that window as the minibuffer.
+If WHICH-FRAMES is a window, include only its own frame and any frame
+now using that window as the minibuffer.
-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.
+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.
*/
- (frame, frametype, console))
+ (frame, which_frames, which_devices))
{
XSETFRAME (frame, decode_frame (frame));
- return next_frame (frame, frametype, console);
+ return next_frame (frame, which_frames, which_devices);
}
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
+WHICH-FRAMES 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
+See `next-frame' for an explanation of the WHICH-FRAMES and WHICH-DEVICES
arguments.
*/
- (frame, frametype, console))
+ (frame, which_frames, which_devices))
{
XSETFRAME (frame, decode_frame (frame));
- return previous_frame (frame, frametype, console);
+ return previous_frame (frame, which_frames, which_devices);
}
/* Return any frame for which PREDICATE is non-zero, or return Qnil
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
+ && !DEVICE_IMPL_FLAG (d, XDEVIMPF_FRAMELESS_OK))
{
/* If we're deleting the only non-minibuffer frame on the
device, delete the device. */
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 returns 'hidden.
+actually visible on screen then `frame-visible-p' 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 frame are necessarily
-really updated.
+Note that under virtual window managers not all these frames are
+necessarily really updated.
*/
(device))
{
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, rows, pretend))
+ (frame, lines, pretend))
{
struct frame *f = decode_frame (frame);
int height, width;
XSETFRAME (frame, f);
- CHECK_INT (rows);
+ CHECK_INT (lines);
if (window_system_pixelated_geometry (frame))
{
- char_to_real_pixel_size (f, 0, XINT (rows), 0, &height);
+ char_to_real_pixel_size (f, 0, XINT (lines), 0, &height);
width = FRAME_PIXWIDTH (f);
}
else
{
- height = XINT (rows);
+ height = XINT (lines);
width = FRAME_WIDTH (f);
}
}
DEFUN ("set-frame-size", Fset_frame_size, 3, 4, 0, /*
-Set the size of FRAME to COLS by ROWS.
+Set the size of FRAME to COLS by ROWS, measured in characters.
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.
*/
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;
projects / chise / xemacs-chise.git.1 / blobdiff