Lisp_Object Qframe_being_created;
static void store_minibuf_frame_prop (struct frame *f, Lisp_Object val);
+static void frame_conversion_internal (struct frame *f, int pixel_to_char,
+ int *pixel_width, int *pixel_height,
+ int *char_width, int *char_height,
+ int real_face);
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;
+static Charc_dynarr *title_string_charc_dynarr;
\f
static Lisp_Object
/* use this instead of XFRAME (DEVICE_SELECTED_FRAME (d)) to catch
the possibility of there being no frames on the device (just created).
There is no point doing this inside of redisplay because errors
- cause an abort(), indicating a flaw in the logic, and error_check_frame()
+ cause an ABORT(), indicating a flaw in the logic, and error_check_frame()
will catch this just as well. */
struct frame *
}
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.
*/
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. */
that is prohibited at the top; you can't delete surrogate
minibuffer frames. */
if (NILP (frame_with_minibuf))
- abort ();
+ ABORT ();
con->default_minibuffer_frame = frame_with_minibuf;
}
break;
default:
- abort (); /* method is incorrectly written */
+ ABORT (); /* method is incorrectly written */
}
return 0;
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))
{
return frame;
}
+DEFUN ("set-frame-pixel-height", Fset_frame_pixel_height, 2, 3, 0, /*
+Specify that the frame FRAME is HEIGHT pixels tall.
+Optional third arg non-nil means that redisplay should be HEIGHT pixels tall
+but that the idea of the actual height of the frame should not be changed.
+*/
+ (frame, height, pretend))
+{
+ struct frame *f = decode_frame (frame);
+ int pheight, width;
+ XSETFRAME (frame, f);
+ CHECK_INT (height);
+
+ if (!window_system_pixelated_geometry (frame))
+ {
+ int h = XINT (height);
+ width = FRAME_WIDTH (f);
+ /* Simply using pixel_to_real_char_size here is not good
+ enough since we end up with a total frame size of HEIGHT
+ rather than a displayable height of HEIGHT. */
+ frame_conversion_internal (f, 2, 0, &h, 0, &pheight, 0);
+ }
+ else
+ {
+ width = FRAME_PIXWIDTH (f);
+ pheight = XINT (height);
+ }
+
+ internal_set_frame_size (f, width, pheight, !NILP (pretend));
+ return frame;
+}
+
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
return frame;
}
+DEFUN ("set-frame-pixel-width", Fset_frame_pixel_width, 2, 3, 0, /*
+Specify that the frame FRAME is WIDTH pixels wide.
+Optional third arg non-nil means that redisplay should be WIDTH wide
+but that the idea of the actual height of the frame should not be changed.
+*/
+ (frame, width, pretend))
+{
+ struct frame *f = decode_frame (frame);
+ int height, pwidth;
+ XSETFRAME (frame, f);
+ CHECK_INT (width);
+
+ if (!window_system_pixelated_geometry (frame))
+ {
+ int w = XINT (width);
+ height = FRAME_HEIGHT (f);
+ /* Simply using pixel_to_real_char_size here is not good
+ enough since we end up with a total frame size of WIDTH
+ rather than a displayable height of WIDTH. */
+ frame_conversion_internal (f, 2, &w, 0, &pwidth, 0, 0);
+ }
+ else
+ {
+ height = FRAME_PIXHEIGHT (f);
+ pwidth = XINT (width);
+ }
+
+ internal_set_frame_size (f, pwidth, height, !NILP (pretend));
+ return frame;
+}
+
DEFUN ("set-frame-size", Fset_frame_size, 3, 4, 0, /*
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
return frame;
}
+DEFUN ("set-frame-pixel-size", Fset_frame_pixel_size, 3, 4, 0, /*
+Set the size of FRAME to WIDTH by HEIGHT, measured in pixels.
+Optional fourth arg non-nil means that redisplay should use WIDTH by HEIGHT
+but that the idea of the actual size of the frame should not be changed.
+*/
+ (frame, width, height, pretend))
+{
+ struct frame *f = decode_frame (frame);
+ int pheight, pwidth;
+ XSETFRAME (frame, f);
+ CHECK_INT (width);
+ CHECK_INT (height);
+
+ if (!window_system_pixelated_geometry (frame))
+ {
+ int w = XINT (width);
+ int h = XINT (height);
+ /* Simply using pixel_to_real_char_size here is not good enough
+ since we end up with a total frame size of WIDTH x HEIGHT
+ rather than a displayable height of WIDTH x HEIGHT. */
+ frame_conversion_internal (f, 2, &w, &h, &pwidth, &pheight, 0);
+ }
+ else
+ {
+ pheight = XINT (height);
+ pwidth = XINT (width);
+ }
+
+ internal_set_frame_size (f, pwidth, pheight, !NILP (pretend));
+ return frame;
+}
+
DEFUN ("set-frame-position", Fset_frame_position, 3, 3, 0, /*
Set position of FRAME in pixels to XOFFSET by YOFFSET.
This is actually the position of the upper left corner of the frame.
2 * FRAME_THEORETICAL_TOP_TOOLBAR_BORDER_WIDTH (f) +
2 * FRAME_THEORETICAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f);
- if (pixel_to_char)
+ /* Convert to chars so that the displayable area is pixel_width x
+ pixel_height.
+
+ #### Consider rounding up to 0.5 characters to avoid adding too
+ much space. */
+ if (pixel_to_char > 1)
+ {
+ if (char_width)
+ *char_width = ROUND_UP (*pixel_width, cpw) / cpw;
+ if (char_height)
+ *char_height = ROUND_UP (*pixel_height, cph) / cph;
+ }
+ /* Convert to chars so that the total frame size is pixel_width x
+ pixel_height. */
+ else if (pixel_to_char)
{
if (char_width)
*char_width = 1 + ((*pixel_width - egw) - bdr - obw) / cpw;
`left' coordinates to be recomputed even though no frame size
change occurs. --kyle */
if (in_display)
- abort ();
+ ABORT ();
XSETFRAME (frame, f);
generate_formatted_string_db (format_str, Qnil, w, dl, db, findex, 0,
-1, type);
- Dynarr_reset (title_string_emchar_dynarr);
+ Dynarr_reset (title_string_charc_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);
+ Dynarr_add (title_string_charc_dynarr,
+ Dynarr_atp (db->runes, elt)->object.cglyph);
elt++;
}
return
- convert_emchar_string_into_malloced_string
- (Dynarr_atp (title_string_emchar_dynarr, 0),
- Dynarr_length (title_string_emchar_dynarr), 0);
+ convert_charc_string_into_malloced_string
+ (Dynarr_atp (title_string_charc_dynarr, 0),
+ Dynarr_length (title_string_charc_dynarr), 0);
}
void
if (!initialized)
#endif
{
- title_string_emchar_dynarr = Dynarr_new (Emchar);
+ title_string_charc_dynarr = Dynarr_new (Charc);
xzero (title_string_display_line);
}
}
DEFSUBR (Fset_frame_height);
DEFSUBR (Fset_frame_width);
DEFSUBR (Fset_frame_size);
+ DEFSUBR (Fset_frame_pixel_height);
+ DEFSUBR (Fset_frame_pixel_width);
+ DEFSUBR (Fset_frame_pixel_size);
DEFSUBR (Fset_frame_position);
DEFSUBR (Fset_frame_pointer);
DEFSUBR (Fprint_job_page_number);
projects / chise / xemacs-chise.git.1 / blobdiff