/* Functions for the X window system.
-Copyright (C) 1989, 1992-2015 Free Software Foundation, Inc.
+Copyright (C) 1989, 1992-2016 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "lisp.h"
#include "xterm.h"
-#include "menu.h"
#include "frame.h"
#include "window.h"
-#include "character.h"
#include "buffer.h"
-#include "intervals.h"
#include "dispextern.h"
#include "keyboard.h"
#include "blockinput.h"
-#include <epaths.h>
#include "charset.h"
#include "coding.h"
-#include "fontset.h"
-#include "systime.h"
#include "termhooks.h"
-#include "atimer.h"
-#include "termchar.h"
#include "font.h"
#include <sys/types.h>
#define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
-#ifdef GLYPH_DEBUG
static ptrdiff_t image_cache_refcount;
+#ifdef GLYPH_DEBUG
static int dpyinfo_refcount;
#endif
int *yptr,
int *outer_border)
{
- int win_x, win_y, outer_x IF_LINT (= 0), outer_y IF_LINT (= 0);
+ int win_x = 0, win_y = 0, outer_x = 0, outer_y = 0;
int real_x = 0, real_y = 0;
bool had_errors = false;
Window win = f->output_data.x->parent_desc;
+ struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+ long max_len = 400;
+ Atom target_type = XA_CARDINAL;
+ unsigned int ow = 0, oh = 0;
+ unsigned int fw = 0, fh = 0;
+ unsigned int bw = 0;
+ /* We resort to XCB if possible because there are several X calls
+ here which require responses from the server but do not have data
+ dependencies between them. Using XCB lets us pipeline requests,
+ whereas with Xlib we must wait for each answer before sending the
+ next request.
+
+ For a non-local display, the round-trip time could be a few tens
+ of milliseconds, depending on the network distance. It doesn't
+ take a lot of those to add up to a noticeable hesitation in
+ responding to user actions. */
+#ifdef USE_XCB
+ xcb_connection_t *xcb_conn = dpyinfo->xcb_connection;
+ xcb_get_property_cookie_t prop_cookie;
+ xcb_get_geometry_cookie_t outer_geom_cookie;
+ bool sent_requests = false;
+#else
Atom actual_type;
unsigned long actual_size, bytes_remaining;
int rc, actual_format;
- struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
- long max_len = 400;
Display *dpy = FRAME_X_DISPLAY (f);
unsigned char *tmp_data = NULL;
- Atom target_type = XA_CARDINAL;
- unsigned int ow IF_LINT (= 0), oh IF_LINT (= 0);
-
- block_input ();
-
- x_catch_errors (dpy);
+#endif
if (x_pixels_diff) *x_pixels_diff = 0;
if (y_pixels_diff) *y_pixels_diff = 0;
if (win == dpyinfo->root_window)
win = FRAME_OUTER_WINDOW (f);
+ block_input ();
+
+#ifndef USE_XCB
+ /* If we're using XCB, all errors are checked for on each call. */
+ x_catch_errors (dpy);
+#endif
+
/* This loop traverses up the containment tree until we hit the root
window. Window managers may intersect many windows between our window
and the root window. The window we find just before the root window
for (;;)
{
Window wm_window, rootw;
+
+#ifdef USE_XCB
+ xcb_query_tree_cookie_t query_tree_cookie;
+ xcb_query_tree_reply_t *query_tree;
+
+ query_tree_cookie = xcb_query_tree (xcb_conn, win);
+ query_tree = xcb_query_tree_reply (xcb_conn, query_tree_cookie, NULL);
+ if (query_tree == NULL)
+ had_errors = true;
+ else
+ {
+ wm_window = query_tree->parent;
+ rootw = query_tree->root;
+ free (query_tree);
+ }
+#else
Window *tmp_children;
unsigned int tmp_nchildren;
int success;
- success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
+ success = XQueryTree (dpy, win, &rootw,
&wm_window, &tmp_children, &tmp_nchildren);
- had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
+ had_errors = x_had_errors_p (dpy);
/* Don't free tmp_children if XQueryTree failed. */
if (! success)
break;
XFree (tmp_children);
+#endif
if (wm_window == rootw || had_errors)
break;
if (! had_errors)
{
- unsigned int ign;
+#ifdef USE_XCB
+ xcb_get_geometry_cookie_t geom_cookie;
+ xcb_translate_coordinates_cookie_t trans_cookie;
+ xcb_translate_coordinates_cookie_t outer_trans_cookie;
+
+ xcb_translate_coordinates_reply_t *trans;
+ xcb_get_geometry_reply_t *geom;
+#else
Window child, rootw;
+ unsigned int ign;
+#endif
- /* Get the real coordinates for the WM window upper left corner */
- XGetGeometry (FRAME_X_DISPLAY (f), win,
- &rootw, &real_x, &real_y, &ow, &oh, &ign, &ign);
+#ifdef USE_XCB
+ /* Fire off the requests that don't have data dependencies.
+
+ Once we've done this, we must collect the results for each
+ one before returning, even if other errors are detected,
+ making the other responses moot. */
+ geom_cookie = xcb_get_geometry (xcb_conn, win);
+
+ trans_cookie =
+ xcb_translate_coordinates (xcb_conn,
+ /* From-window, to-window. */
+ FRAME_DISPLAY_INFO (f)->root_window,
+ FRAME_X_WINDOW (f),
+
+ /* From-position. */
+ 0, 0);
+ if (FRAME_X_WINDOW (f) != FRAME_OUTER_WINDOW (f))
+ outer_trans_cookie =
+ xcb_translate_coordinates (xcb_conn,
+ /* From-window, to-window. */
+ FRAME_DISPLAY_INFO (f)->root_window,
+ FRAME_OUTER_WINDOW (f),
+
+ /* From-position. */
+ 0, 0);
+ if (right_offset_x || bottom_offset_y)
+ outer_geom_cookie = xcb_get_geometry (xcb_conn,
+ FRAME_OUTER_WINDOW (f));
+
+ if (dpyinfo->root_window == f->output_data.x->parent_desc)
+ /* Try _NET_FRAME_EXTENTS if our parent is the root window. */
+ prop_cookie = xcb_get_property (xcb_conn, 0, win,
+ dpyinfo->Xatom_net_frame_extents,
+ target_type, 0, max_len);
+
+ sent_requests = true;
+#endif
- if (outer_border)
- {
- XWindowAttributes atts;
- XGetWindowAttributes (FRAME_X_DISPLAY (f), win, &atts);
- *outer_border = atts.border_width;
- }
+ /* Get the real coordinates for the WM window upper left corner */
+#ifdef USE_XCB
+ geom = xcb_get_geometry_reply (xcb_conn, geom_cookie, NULL);
+ if (geom)
+ {
+ real_x = geom->x;
+ real_y = geom->y;
+ ow = geom->width;
+ oh = geom->height;
+ bw = geom->border_width;
+ free (geom);
+ }
+ else
+ had_errors = true;
+#else
+ XGetGeometry (dpy, win,
+ &rootw, &real_x, &real_y, &ow, &oh, &bw, &ign);
+#endif
/* Translate real coordinates to coordinates relative to our
window. For our window, the upper left corner is 0, 0.
| title |
| ----------------- v y
| | our window
- */
- XTranslateCoordinates (FRAME_X_DISPLAY (f),
+
+ Since we don't care about the child window corresponding to
+ the actual coordinates, we can send zero to get the offsets
+ and compute the resulting coordinates below. This reduces
+ the data dependencies between calls and lets us pipeline the
+ requests better in the XCB case. */
+#ifdef USE_XCB
+ trans = xcb_translate_coordinates_reply (xcb_conn, trans_cookie, NULL);
+ if (trans)
+ {
+ win_x = trans->dst_x;
+ win_y = trans->dst_y;
+ free (trans);
+ }
+ else
+ had_errors = true;
+#else
+ XTranslateCoordinates (dpy,
/* From-window, to-window. */
FRAME_DISPLAY_INFO (f)->root_window,
FRAME_X_WINDOW (f),
/* From-position, to-position. */
- real_x, real_y, &win_x, &win_y,
+ 0, 0, &win_x, &win_y,
/* Child of win. */
&child);
+#endif
+
+ win_x += real_x;
+ win_y += real_y;
if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
{
}
else
{
- XTranslateCoordinates (FRAME_X_DISPLAY (f),
+#ifdef USE_XCB
+ xcb_translate_coordinates_reply_t *outer_trans;
+
+ outer_trans = xcb_translate_coordinates_reply (xcb_conn,
+ outer_trans_cookie,
+ NULL);
+ if (outer_trans)
+ {
+ outer_x = outer_trans->dst_x;
+ outer_y = outer_trans->dst_y;
+ free (outer_trans);
+ }
+ else
+ had_errors = true;
+#else
+ XTranslateCoordinates (dpy,
/* From-window, to-window. */
FRAME_DISPLAY_INFO (f)->root_window,
FRAME_OUTER_WINDOW (f),
/* From-position, to-position. */
- real_x, real_y, &outer_x, &outer_y,
+ 0, 0, &outer_x, &outer_y,
/* Child of win. */
&child);
+#endif
+
+ outer_x += real_x;
+ outer_y += real_y;
}
- had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
+#ifndef USE_XCB
+ had_errors = x_had_errors_p (dpy);
+#endif
}
-
if (dpyinfo->root_window == f->output_data.x->parent_desc)
{
/* Try _NET_FRAME_EXTENTS if our parent is the root window. */
+#ifdef USE_XCB
+ /* Make sure we didn't get an X error early and skip sending the
+ request. */
+ if (sent_requests)
+ {
+ xcb_get_property_reply_t *prop;
+
+ prop = xcb_get_property_reply (xcb_conn, prop_cookie, NULL);
+ if (prop)
+ {
+ if (prop->type == target_type
+ && prop->format == 32
+ && (xcb_get_property_value_length (prop)
+ == 4 * sizeof (int32_t)))
+ {
+ int32_t *fe = xcb_get_property_value (prop);
+
+ outer_x = -fe[0];
+ outer_y = -fe[2];
+ real_x -= fe[0];
+ real_y -= fe[2];
+ }
+ free (prop);
+ }
+ /* Xlib version doesn't set had_errors here. Intentional or bug? */
+ }
+#else
rc = XGetWindowProperty (dpy, win, dpyinfo->Xatom_net_frame_extents,
0, max_len, False, target_type,
&actual_type, &actual_format, &actual_size,
if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
&& actual_size == 4 && actual_format == 32)
{
- unsigned int ign;
- Window rootw;
long *fe = (long *)tmp_data;
- XGetGeometry (FRAME_X_DISPLAY (f), win,
- &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
outer_x = -fe[0];
outer_y = -fe[2];
real_x -= fe[0];
real_y -= fe[2];
}
+
+ if (tmp_data) XFree (tmp_data);
+#endif
}
- if (tmp_data) XFree (tmp_data);
+ if (right_offset_x || bottom_offset_y)
+ {
+#ifdef USE_XCB
+ /* Make sure we didn't get an X error early and skip sending the
+ request. */
+ if (sent_requests)
+ {
+ xcb_get_geometry_reply_t *outer_geom;
+
+ outer_geom = xcb_get_geometry_reply (xcb_conn, outer_geom_cookie,
+ NULL);
+ if (outer_geom)
+ {
+ fw = outer_geom->width;
+ fh = outer_geom->height;
+ free (outer_geom);
+ }
+ else
+ had_errors = true;
+ }
+#else
+ int xy_ign;
+ unsigned int ign;
+ Window rootw;
+
+ XGetGeometry (dpy, FRAME_OUTER_WINDOW (f),
+ &rootw, &xy_ign, &xy_ign, &fw, &fh, &ign, &ign);
+#endif
+ }
+#ifndef USE_XCB
x_uncatch_errors ();
+#endif
unblock_input ();
if (xptr) *xptr = real_x;
if (yptr) *yptr = real_y;
- if (right_offset_x || bottom_offset_y)
- {
- int xy_ign;
- unsigned int ign, fw, fh;
- Window rootw;
+ if (outer_border) *outer_border = bw;
- XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
- &rootw, &xy_ign, &xy_ign, &fw, &fh, &ign, &ign);
- if (right_offset_x) *right_offset_x = ow - fw + outer_x;
- if (bottom_offset_y) *bottom_offset_y = oh - fh + outer_y;
- }
+ if (right_offset_x) *right_offset_x = ow - fw + outer_x;
+ if (bottom_offset_y) *bottom_offset_y = oh - fh + outer_y;
}
/* Store the screen positions of frame F into XPTR and YPTR.
XColor *color, bool alloc_p)
{
bool success_p = false;
- Display *dpy = FRAME_X_DISPLAY (f);
Colormap cmap = FRAME_X_COLORMAP (f);
block_input ();
success_p = xg_check_special_colors (f, color_name, color);
#endif
if (!success_p)
- success_p = XParseColor (dpy, cmap, color_name, color) != 0;
+ success_p = x_parse_color (f, color_name, color) != 0;
if (success_p && alloc_p)
success_p = x_alloc_nearest_color (f, cmap, color);
unblock_input ();
{
GdkPixbuf *pixbuf;
GError *err = NULL;
- char *filename = SSDATA (found);
+ char *filename = SSDATA (ENCODE_FILE (found));
block_input ();
pixbuf = gdk_pixbuf_new_from_file (filename, &err);
}
}
+/* This array must stay in sync with the mouse_cursor_types array below! */
+enum mouse_cursor {
+ mouse_cursor_text,
+ mouse_cursor_nontext,
+ mouse_cursor_hourglass,
+ mouse_cursor_mode,
+ mouse_cursor_hand,
+ mouse_cursor_horizontal_drag,
+ mouse_cursor_vertical_drag,
+ mouse_cursor_max
+};
+
+struct mouse_cursor_types {
+ /* Printable name for error messages (optional). */
+ const char *name;
+
+ /* Lisp variable controlling the cursor shape. */
+ /* FIXME: A couple of these variables are defined in the C code but
+ are not actually accessible from Lisp. They should probably be
+ made accessible or removed. */
+ Lisp_Object *shape_var_ptr;
+
+ /* The default shape. */
+ int default_shape;
+};
+
+/* This array must stay in sync with enum mouse_cursor above! */
+static const struct mouse_cursor_types mouse_cursor_types[] = {
+ { "text", &Vx_pointer_shape, XC_xterm },
+ { "nontext", &Vx_nontext_pointer_shape, XC_left_ptr },
+ { "hourglass", &Vx_hourglass_pointer_shape, XC_watch },
+ { "modeline", &Vx_mode_pointer_shape, XC_xterm },
+ { NULL, &Vx_sensitive_text_pointer_shape, XC_hand2 },
+ { NULL, &Vx_window_horizontal_drag_shape, XC_sb_h_double_arrow },
+ { NULL, &Vx_window_vertical_drag_shape, XC_sb_v_double_arrow },
+};
+
+struct mouse_cursor_data {
+ /* Last index for which XCreateFontCursor has been called, and thus
+ the last index for which x_request_serial[] is valid. */
+ int last_cursor_create_request;
+
+ /* Last index for which an X error event was received in response to
+ attempting to create the cursor. */
+ int error_cursor;
+
+ /* Cursor numbers chosen. */
+ unsigned int cursor_num[mouse_cursor_max];
+
+ /* Allocated Cursor values, or zero for failed attempts. */
+ Cursor cursor[mouse_cursor_max];
+
+ /* X serial numbers for the first request sent by XCreateFontCursor.
+ Note that there may be more than one request sent. */
+ unsigned long x_request_serial[mouse_cursor_max];
+
+ /* If an error has been received, a pointer to where the current
+ error-message text is stored. */
+ char *error_string;
+};
+
+static void
+x_set_mouse_color_handler (Display *dpy, XErrorEvent *event,
+ char *error_string, void *data)
+{
+ struct mouse_cursor_data *cursor_data = data;
+ int i;
+
+ cursor_data->error_cursor = -1;
+ cursor_data->error_string = error_string;
+ for (i = 0; i < cursor_data->last_cursor_create_request; i++)
+ {
+ if (event->serial >= cursor_data->x_request_serial[i])
+ cursor_data->error_cursor = i;
+ }
+ if (cursor_data->error_cursor >= 0)
+ /* If we failed to allocate it, don't try to free it. */
+ cursor_data->cursor[cursor_data->error_cursor] = 0;
+}
+
static void
x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
struct x_output *x = f->output_data.x;
Display *dpy = FRAME_X_DISPLAY (f);
- Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
- Cursor hourglass_cursor, horizontal_drag_cursor, vertical_drag_cursor;
+ struct mouse_cursor_data cursor_data = { -1, -1 };
unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
+ int i;
/* Don't let pointers be invisible. */
if (mask_color == pixel)
unload_color (f, x->mouse_pixel);
x->mouse_pixel = pixel;
+ for (i = 0; i < mouse_cursor_max; i++)
+ {
+ Lisp_Object shape_var = *mouse_cursor_types[i].shape_var_ptr;
+ if (!NILP (shape_var))
+ {
+ CHECK_TYPE_RANGED_INTEGER (unsigned, shape_var);
+ cursor_data.cursor_num[i] = XINT (shape_var);
+ }
+ else
+ cursor_data.cursor_num[i] = mouse_cursor_types[i].default_shape;
+ }
+
block_input ();
/* It's not okay to crash if the user selects a screwy cursor. */
- x_catch_errors (dpy);
+ x_catch_errors_with_handler (dpy, x_set_mouse_color_handler, &cursor_data);
- if (!NILP (Vx_pointer_shape))
+ for (i = 0; i < mouse_cursor_max; i++)
{
- CHECK_NUMBER (Vx_pointer_shape);
- cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
+ cursor_data.x_request_serial[i] = XNextRequest (dpy);
+ cursor_data.last_cursor_create_request = i;
+ cursor_data.cursor[i] = XCreateFontCursor (dpy,
+ cursor_data.cursor_num[i]);
}
- else
- cursor = XCreateFontCursor (dpy, XC_xterm);
- x_check_errors (dpy, "bad text pointer cursor: %s");
- if (!NILP (Vx_nontext_pointer_shape))
+ /* Now sync up and process all received errors from cursor
+ creation. */
+ if (x_had_errors_p (dpy))
{
- CHECK_NUMBER (Vx_nontext_pointer_shape);
- nontext_cursor
- = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
- }
- else
- nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
- x_check_errors (dpy, "bad nontext pointer cursor: %s");
+ const char *bad_cursor_name = NULL;
+ /* Bounded by X_ERROR_MESSAGE_SIZE in xterm.c. */
+ size_t message_length = strlen (cursor_data.error_string);
+ char *xmessage = alloca (1 + message_length);
+ memcpy (xmessage, cursor_data.error_string, message_length);
- if (!NILP (Vx_hourglass_pointer_shape))
- {
- CHECK_NUMBER (Vx_hourglass_pointer_shape);
- hourglass_cursor
- = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
- }
- else
- hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
- x_check_errors (dpy, "bad hourglass pointer cursor: %s");
+ x_uncatch_errors ();
- if (!NILP (Vx_mode_pointer_shape))
- {
- CHECK_NUMBER (Vx_mode_pointer_shape);
- mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
- }
- else
- mode_cursor = XCreateFontCursor (dpy, XC_xterm);
- x_check_errors (dpy, "bad modeline pointer cursor: %s");
+ /* Free any successfully created cursors. */
+ for (i = 0; i < mouse_cursor_max; i++)
+ if (cursor_data.cursor[i] != 0)
+ XFreeCursor (dpy, cursor_data.cursor[i]);
- if (!NILP (Vx_sensitive_text_pointer_shape))
- {
- CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
- hand_cursor
- = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
+ /* This should only be able to fail if the server's serial
+ number tracking is broken. */
+ if (cursor_data.error_cursor >= 0)
+ bad_cursor_name = mouse_cursor_types[cursor_data.error_cursor].name;
+ if (bad_cursor_name)
+ error ("bad %s pointer cursor: %s", bad_cursor_name, xmessage);
+ else
+ error ("can't set cursor shape: %s", xmessage);
}
- else
- hand_cursor = XCreateFontCursor (dpy, XC_hand2);
- if (!NILP (Vx_window_horizontal_drag_shape))
- {
- CHECK_TYPE_RANGED_INTEGER (unsigned, Vx_window_horizontal_drag_shape);
- horizontal_drag_cursor
- = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
- }
- else
- horizontal_drag_cursor
- = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
+ x_uncatch_errors_after_check ();
- if (!NILP (Vx_window_vertical_drag_shape))
- {
- CHECK_NUMBER (Vx_window_vertical_drag_shape);
- vertical_drag_cursor
- = XCreateFontCursor (dpy, XINT (Vx_window_vertical_drag_shape));
- }
- else
- vertical_drag_cursor
- = XCreateFontCursor (dpy, XC_sb_v_double_arrow);
+ {
+ XColor colors[2]; /* 0=foreground, 1=background */
- /* Check and report errors with the above calls. */
- x_check_errors (dpy, "can't set cursor shape: %s");
- x_uncatch_errors ();
+ colors[0].pixel = x->mouse_pixel;
+ colors[1].pixel = mask_color;
+ x_query_colors (f, colors, 2);
- {
- XColor fore_color, back_color;
-
- fore_color.pixel = x->mouse_pixel;
- x_query_color (f, &fore_color);
- back_color.pixel = mask_color;
- x_query_color (f, &back_color);
-
- XRecolorCursor (dpy, cursor, &fore_color, &back_color);
- XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
- XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
- XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
- XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
- XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
- XRecolorCursor (dpy, vertical_drag_cursor, &fore_color, &back_color);
+ for (i = 0; i < mouse_cursor_max; i++)
+ XRecolorCursor (dpy, cursor_data.cursor[i], &colors[0], &colors[1]);
}
if (FRAME_X_WINDOW (f) != 0)
- XDefineCursor (dpy, FRAME_X_WINDOW (f),
- f->output_data.x->current_cursor = cursor);
-
- if (cursor != x->text_cursor
- && x->text_cursor != 0)
- XFreeCursor (dpy, x->text_cursor);
- x->text_cursor = cursor;
-
- if (nontext_cursor != x->nontext_cursor
- && x->nontext_cursor != 0)
- XFreeCursor (dpy, x->nontext_cursor);
- x->nontext_cursor = nontext_cursor;
-
- if (hourglass_cursor != x->hourglass_cursor
- && x->hourglass_cursor != 0)
- XFreeCursor (dpy, x->hourglass_cursor);
- x->hourglass_cursor = hourglass_cursor;
-
- if (mode_cursor != x->modeline_cursor
- && x->modeline_cursor != 0)
- XFreeCursor (dpy, f->output_data.x->modeline_cursor);
- x->modeline_cursor = mode_cursor;
-
- if (hand_cursor != x->hand_cursor
- && x->hand_cursor != 0)
- XFreeCursor (dpy, x->hand_cursor);
- x->hand_cursor = hand_cursor;
-
- if (horizontal_drag_cursor != x->horizontal_drag_cursor
- && x->horizontal_drag_cursor != 0)
- XFreeCursor (dpy, x->horizontal_drag_cursor);
- x->horizontal_drag_cursor = horizontal_drag_cursor;
-
- if (vertical_drag_cursor != x->vertical_drag_cursor
- && x->vertical_drag_cursor != 0)
- XFreeCursor (dpy, x->vertical_drag_cursor);
- x->vertical_drag_cursor = vertical_drag_cursor;
+ {
+ f->output_data.x->current_cursor = cursor_data.cursor[mouse_cursor_text];
+ XDefineCursor (dpy, FRAME_X_WINDOW (f),
+ f->output_data.x->current_cursor);
+ }
+
+#define INSTALL_CURSOR(FIELD, SHORT_INDEX) \
+ eassert (x->FIELD != cursor_data.cursor[mouse_cursor_ ## SHORT_INDEX]); \
+ if (x->FIELD != 0) \
+ XFreeCursor (dpy, x->FIELD); \
+ x->FIELD = cursor_data.cursor[mouse_cursor_ ## SHORT_INDEX];
+
+ INSTALL_CURSOR (text_cursor, text);
+ INSTALL_CURSOR (nontext_cursor, nontext);
+ INSTALL_CURSOR (hourglass_cursor, hourglass);
+ INSTALL_CURSOR (modeline_cursor, mode);
+ INSTALL_CURSOR (hand_cursor, hand);
+ INSTALL_CURSOR (horizontal_drag_cursor, horizontal_drag);
+ INSTALL_CURSOR (vertical_drag_cursor, vertical_drag);
+
+#undef INSTALL_CURSOR
XFlush (dpy);
unblock_input ();
nlines = 0;
/* Make sure we redisplay all windows in this frame. */
- windows_or_buffers_changed = 59;
+ fset_redisplay (f);
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
FRAME_MENU_BAR_LINES (f) = 0;
#else /* not USE_X_TOOLKIT && not USE_GTK */
FRAME_MENU_BAR_LINES (f) = nlines;
FRAME_MENU_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
- adjust_frame_size (f, -1, -1, 2, true, Qmenu_bar_lines);
+ adjust_frame_size (f, -1, -1, 2, true, Qx_set_menu_bar_lines);
if (FRAME_X_WINDOW (f))
x_clear_under_internal_border (f);
y = FRAME_TOP_MARGIN_HEIGHT (f);
block_input ();
- x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
- 0, y, width, height);
+ x_clear_area (f, 0, y, width, height);
unblock_input ();
}
height = nlines * FRAME_LINE_HEIGHT (f) - y;
block_input ();
- x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
- 0, y, width, height);
+ x_clear_area (f, 0, y, width, height);
unblock_input ();
}
Lisp_Object fullscreen;
/* Make sure we redisplay all windows in this frame. */
- windows_or_buffers_changed = 60;
-
+ fset_redisplay (f);
/* Recalculate tool bar and frame text sizes. */
FRAME_TOOL_BAR_HEIGHT (f) = height;
/* Recalculate toolbar height. */
f->n_tool_bar_rows = 0;
+ if (old_height == 0
+ && (!f->after_make_frame
+ || NILP (frame_inhibit_implied_resize)
+ || (CONSP (frame_inhibit_implied_resize)
+ && NILP (Fmemq (Qtool_bar_lines, frame_inhibit_implied_resize)))))
+ f->tool_bar_redisplayed = f->tool_bar_resized = false;
adjust_frame_size (f, -1, -1,
- ((!f->tool_bar_redisplayed_once
+ ((!f->tool_bar_resized
&& (NILP (fullscreen =
get_frame_param (f, Qfullscreen))
|| EQ (fullscreen, Qfullwidth))) ? 1
: 4),
false, Qtool_bar_lines);
+ f->tool_bar_resized = f->tool_bar_redisplayed;
+
/* adjust_frame_size might not have done anything, garbage frame
here. */
adjust_frame_glyphs (f);
/* Encode Lisp string STRING as a text in a format appropriate for
XICCC (X Inter Client Communication Conventions).
- This can call Lisp code, so callers must GCPRO.
-
If STRING contains only ASCII characters, do no conversion and
return the string data of STRING. Otherwise, encode the text by
CODING_SYSTEM, and return a newly allocated memory area which
Lisp_Object coding_system;
Lisp_Object encoded_name;
Lisp_Object encoded_icon_name;
- struct gcpro gcpro1;
/* As ENCODE_UTF_8 may cause GC and relocation of string data,
we use it before x_encode_text that may return string data. */
- GCPRO1 (name);
encoded_name = ENCODE_UTF_8 (name);
- UNGCPRO;
coding_system = Qcompound_text;
/* Note: Encoding strategy
struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
#endif
+ /* If the frame's image cache refcount is still the same as our
+ private shadow variable, it means we are unwinding a frame
+ for which we didn't yet call init_frame_faces, where the
+ refcount is incremented. Therefore, we increment it here, so
+ that free_frame_faces, called in x_free_frame_resources
+ below, will not mistakenly decrement the counter that was not
+ incremented yet to account for this new frame. */
+ if (FRAME_IMAGE_CACHE (f) != NULL
+ && FRAME_IMAGE_CACHE (f)->refcount == image_cache_refcount)
+ FRAME_IMAGE_CACHE (f)->refcount++;
+
x_free_frame_resources (f);
free_glyphs (f);
bool minibuffer_only = false;
long window_prompting = 0;
ptrdiff_t count = SPECPDL_INDEX ();
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
Lisp_Object display;
struct x_display_info *dpyinfo = NULL;
Lisp_Object parent;
struct kboard *kb;
+ int x_width = 0, x_height = 0;
parms = Fcopy_alist (parms);
if (! NILP (parent))
CHECK_NUMBER (parent);
- /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
- /* No need to protect DISPLAY because that's not used after passing
- it to make_frame_without_minibuffer. */
frame = Qnil;
- GCPRO4 (parms, parent, name, frame);
tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
RES_TYPE_SYMBOL);
if (EQ (tem, Qnone) || NILP (tem))
to get the color reference counts right, so initialize them! */
{
Lisp_Object black;
- struct gcpro gcpro1;
/* Function x_decode_color can signal an error. Make
sure to initialize color slots so that we won't try
f->output_data.x->mouse_pixel = -1;
black = build_string ("black");
- GCPRO1 (black);
FRAME_FOREGROUND_PIXEL (f)
= x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
FRAME_BACKGROUND_PIXEL (f)
= x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
f->output_data.x->mouse_pixel
= x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
- UNGCPRO;
}
/* Specify the parent under which to make this X window. */
register_font_driver (&xfont_driver, f);
#endif /* not USE_CAIRO */
+ image_cache_refcount =
+ FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
+#ifdef GLYPH_DEBUG
+ dpyinfo_refcount = dpyinfo->reference_count;
+#endif /* GLYPH_DEBUG */
+
x_default_parameter (f, parms, Qfont_backend, Qnil,
"fontBackend", "FontBackend", RES_TYPE_STRING);
"scrollBarBackground",
"ScrollBarBackground", false);
-#ifdef GLYPH_DEBUG
- image_cache_refcount =
- FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
- dpyinfo_refcount = dpyinfo->reference_count;
-#endif /* GLYPH_DEBUG */
-
/* Init faces before x_default_parameter is called for the
scroll-bar-width parameter because otherwise we end up in
init_iterator with a null face cache, which should not happen. */
FRAME_TOOL_BAR_POSITION (f), 0, 0, RES_TYPE_SYMBOL);
/* Compute the size of the X window. */
- window_prompting = x_figure_window_size (f, parms, true);
+ window_prompting = x_figure_window_size (f, parms, true, &x_width, &x_height);
tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
f->no_split = minibuffer_only || EQ (tem, Qt);
x_default_parameter (f, parms, Qalpha, Qnil,
"alpha", "Alpha", RES_TYPE_NUMBER);
- /* Consider frame official, now. */
- f->can_x_set_window_size = true;
-
- adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 0, true,
- Qx_create_frame_2);
-
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
/* Create the menu bar. */
if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
}
#endif /* USE_X_TOOLKIT || USE_GTK */
+ /* Consider frame official, now. */
+ f->can_x_set_window_size = true;
+
+ if (x_width > 0)
+ SET_FRAME_WIDTH (f, x_width);
+ if (x_height > 0)
+ SET_FRAME_HEIGHT (f, x_height);
+
/* Tell the server what size and position, etc, we want, and how
badly we want them. This should be done after we have the menu
bar so that its size can be taken into account. */
x_wm_set_size_hint (f, window_prompting, false);
unblock_input ();
+ adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
+ 0, true, Qx_create_frame_2);
+
/* Process fullscreen parameter here in the hope that normalizing a
fullheight/fullwidth frame will produce the size set by the last
adjust_frame_size call. */
if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
- UNGCPRO;
-
/* Make sure windows on this frame appear in calls to next-window
and similar functions. */
Vwindow_list = Qnil;
\f
DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
- doc: /* Internal function called by `color-defined-p', which see
-.\(Note that the Nextstep version of this function ignores FRAME.) */)
+ doc: /* Internal function called by `color-defined-p', which see.
+(Note that the Nextstep version of this function ignores FRAME.) */)
(Lisp_Object color, Lisp_Object frame)
{
XColor foo;
DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
doc: /* Return the "vendor ID" string of the GUI software on TERMINAL.
-\(Labeling every distributor as a "vendor" embodies the false assumption
+(Labeling every distributor as a "vendor" embodies the false assumption
that operating systems cannot be developed and distributed noncommercially.)
The optional argument TERMINAL specifies which display to ask about.
return attributes_list;
}
-DEFUN ("x-frame-geometry", Fx_frame_geometry, Sx_frame_geometry, 0, 1, 0,
- doc: /* Return geometric attributes of frame FRAME.
+/* Return geometric attributes of FRAME. According to the value of
+ ATTRIBUTES return the outer edges of FRAME (Qouter_edges), the native
+ edges of FRAME (Qnative_edges), or the inner edges of frame
+ (Qinner_edges). Any other value means to return the geometry as
+ returned by Fx_frame_geometry. */
+static Lisp_Object
+frame_geometry (Lisp_Object frame, Lisp_Object attribute)
+{
+ struct frame *f = decode_live_frame (frame);
+ /** XWindowAttributes atts; **/
+ Window rootw;
+ unsigned int ign, native_width, native_height;
+ int xy_ign, xptr, yptr;
+ int left_off, right_off, top_off, bottom_off;
+ int outer_left, outer_top, outer_right, outer_bottom;
+ int native_left, native_top, native_right, native_bottom;
+ int inner_left, inner_top, inner_right, inner_bottom;
+ int internal_border_width;
+ bool menu_bar_external = false, tool_bar_external = false;
+ int menu_bar_height = 0, menu_bar_width = 0;
+ int tool_bar_height = 0, tool_bar_width = 0;
+
+ if (FRAME_INITIAL_P (f) || !FRAME_X_P (f))
+ return Qnil;
+
+ block_input ();
+ XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+ &rootw, &xy_ign, &xy_ign, &native_width, &native_height,
+ &ign, &ign);
+ /** XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &atts); **/
+ x_real_pos_and_offsets (f, &left_off, &right_off, &top_off, &bottom_off,
+ NULL, NULL, &xptr, &yptr, NULL);
+ unblock_input ();
+
+ /** native_width = atts.width; **/
+ /** native_height = atts.height; **/
+
+ outer_left = xptr;
+ outer_top = yptr;
+ outer_right = outer_left + left_off + native_width + right_off;
+ outer_bottom = outer_top + top_off + native_height + bottom_off;
+
+ native_left = outer_left + left_off;
+ native_top = outer_top + top_off;
+ native_right = native_left + native_width;
+ native_bottom = native_top + native_height;
+
+ internal_border_width = FRAME_INTERNAL_BORDER_WIDTH (f);
+ inner_left = native_left + internal_border_width;
+ inner_top = native_top + internal_border_width;
+ inner_right = native_right - internal_border_width;
+ inner_bottom = native_bottom - internal_border_width;
+
+#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
+ menu_bar_external = true;
+ menu_bar_height = FRAME_MENUBAR_HEIGHT (f);
+ native_top += menu_bar_height;
+ inner_top += menu_bar_height;
+#else
+ menu_bar_height = FRAME_MENU_BAR_HEIGHT (f);
+ inner_top += menu_bar_height;
+#endif
+ menu_bar_width = menu_bar_height ? native_width : 0;
+
+#if defined (USE_GTK)
+ tool_bar_external = true;
+ if (EQ (FRAME_TOOL_BAR_POSITION (f), Qleft))
+ {
+ tool_bar_width = FRAME_TOOLBAR_WIDTH (f);
+ native_left += tool_bar_width;
+ inner_left += tool_bar_width;
+ tool_bar_height
+ = tool_bar_width ? native_height - menu_bar_height : 0;
+ }
+ else if (EQ (FRAME_TOOL_BAR_POSITION (f), Qtop))
+ {
+ tool_bar_height = FRAME_TOOLBAR_HEIGHT (f);
+ native_top += tool_bar_height;
+ inner_top += tool_bar_height;
+ tool_bar_width = tool_bar_height ? native_width : 0;
+ }
+ else if (EQ (FRAME_TOOL_BAR_POSITION (f), Qright))
+ {
+ tool_bar_width = FRAME_TOOLBAR_WIDTH (f);
+ native_right -= tool_bar_width;
+ inner_right -= tool_bar_width;
+ tool_bar_height
+ = tool_bar_width ? native_height - menu_bar_height : 0;
+ }
+ else
+ {
+ tool_bar_height = FRAME_TOOLBAR_HEIGHT (f);
+ native_bottom -= tool_bar_height;
+ inner_bottom -= tool_bar_height;
+ tool_bar_width = tool_bar_height ? native_width : 0;
+ }
+#else
+ tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f);
+ tool_bar_width = tool_bar_height ? native_width : 0;
+ inner_top += tool_bar_height;
+#endif
-FRAME must be a live frame and defaults to the selected one.
+ /* Construct list. */
+ if (EQ (attribute, Qouter_edges))
+ return list4 (make_number (outer_left), make_number (outer_top),
+ make_number (outer_right), make_number (outer_bottom));
+ else if (EQ (attribute, Qnative_edges))
+ return list4 (make_number (native_left), make_number (native_top),
+ make_number (native_right), make_number (native_bottom));
+ else if (EQ (attribute, Qinner_edges))
+ return list4 (make_number (inner_left), make_number (inner_top),
+ make_number (inner_right), make_number (inner_bottom));
+ else
+ return
+ listn (CONSTYPE_HEAP, 10,
+ Fcons (Qouter_position,
+ Fcons (make_number (outer_left),
+ make_number (outer_top))),
+ Fcons (Qouter_size,
+ Fcons (make_number (outer_right - outer_left),
+ make_number (outer_bottom - outer_top))),
+ /* Approximate. */
+ Fcons (Qexternal_border_size,
+ Fcons (make_number (right_off),
+ make_number (bottom_off))),
+ /* Approximate. */
+ Fcons (Qtitle_bar_size,
+ Fcons (make_number (0),
+ make_number (top_off - bottom_off))),
+ Fcons (Qmenu_bar_external, menu_bar_external ? Qt : Qnil),
+ Fcons (Qmenu_bar_size,
+ Fcons (make_number (menu_bar_width),
+ make_number (menu_bar_height))),
+ Fcons (Qtool_bar_external, tool_bar_external ? Qt : Qnil),
+ Fcons (Qtool_bar_position, FRAME_TOOL_BAR_POSITION (f)),
+ Fcons (Qtool_bar_size,
+ Fcons (make_number (tool_bar_width),
+ make_number (tool_bar_height))),
+ Fcons (Qinternal_border_width,
+ make_number (internal_border_width)));
+}
-The return value is an association list containing the following
-elements (all size values are in pixels).
+DEFUN ("x-frame-geometry", Fx_frame_geometry, Sx_frame_geometry, 0, 1, 0,
+ doc: /* Return geometric attributes of FRAME.
+FRAME must be a live frame and defaults to the selected one. The return
+value is an association list of the attributes listed below. All height
+and width values are in pixels.
-- `frame-outer-size' is a cons of the outer width and height of FRAME.
- The outer size include the title bar and the external borders as well
- as any menu and/or tool bar of frame.
+`outer-position' is a cons of the outer left and top edges of FRAME
+ relative to the origin - the position (0, 0) - of FRAME's display.
-- `border' is a cons of the horizontal and vertical width of FRAME's
- external borders.
+`outer-size' is a cons of the outer width and height of FRAME. The
+ outer size includes the title bar and the external borders as well as
+ any menu and/or tool bar of frame.
-- `title-bar-height' is the height of the title bar of FRAME.
+`external-border-size' is a cons of the horizontal and vertical width of
+ FRAME's external borders as supplied by the window manager.
-- `menu-bar-external' if `t' means the menu bar is external (not
+`title-bar-size' is a cons of the width and height of the title bar of
+ FRAME as supplied by the window manager. If both of them are zero,
+ FRAME has no title bar. If only the width is zero, Emacs was not
+ able to retrieve the width information.
+
+`menu-bar-external', if non-nil, means the menu bar is external (never
included in the inner edges of FRAME).
-- `menu-bar-size' is a cons of the width and height of the menu bar of
+`menu-bar-size' is a cons of the width and height of the menu bar of
FRAME.
-- `tool-bar-external' if `t' means the tool bar is external (not
+`tool-bar-external', if non-nil, means the tool bar is external (never
included in the inner edges of FRAME).
-- `tool-bar-side' tells tells on which side the tool bar on FRAME is and
- can be one of `left', `top', `right' or `bottom'.
+`tool-bar-position' tells on which side the tool bar on FRAME is and can
+ be one of `left', `top', `right' or `bottom'. If this is nil, FRAME
+ has no tool bar.
-- `tool-bar-size' is a cons of the width and height of the tool bar of
+`tool-bar-size' is a cons of the width and height of the tool bar of
FRAME.
-- `frame-inner-size' is a cons of the inner width and height of FRAME.
- This excludes FRAME's title bar and external border as well as any
- external menu and/or tool bar. */)
+`internal-border-width' is the width of the internal border of
+ FRAME. */)
(Lisp_Object frame)
{
- struct frame *f = decode_live_frame (frame);
- int inner_width = FRAME_PIXEL_WIDTH (f);
- int inner_height = FRAME_PIXEL_HEIGHT (f);
- int outer_width, outer_height, border, title;
- Lisp_Object fullscreen = Fframe_parameter (frame, Qfullscreen);
- int menu_bar_height, menu_bar_width, tool_bar_height, tool_bar_width;
-
- int left_off, right_off, top_off, bottom_off, outer_border;
- XWindowAttributes atts;
-
- block_input ();
+ return frame_geometry (frame, Qnil);
+}
- XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &atts);
+DEFUN ("x-frame-edges", Fx_frame_edges, Sx_frame_edges, 0, 2, 0,
+ doc: /* Return edge coordinates of FRAME.
+FRAME must be a live frame and defaults to the selected one. The return
+value is a list of the form (LEFT, TOP, RIGHT, BOTTOM). All values are
+in pixels relative to the origin - the position (0, 0) - of FRAME's
+display.
+
+If optional argument TYPE is the symbol `outer-edges', return the outer
+edges of FRAME. The outer edges comprise the decorations of the window
+manager (like the title bar or external borders) as well as any external
+menu or tool bar of FRAME. If optional argument TYPE is the symbol
+`native-edges' or nil, return the native edges of FRAME. The native
+edges exclude the decorations of the window manager and any external
+menu or tool bar of FRAME. If TYPE is the symbol `inner-edges', return
+the inner edges of FRAME. These edges exclude title bar, any borders,
+menu bar or tool bar of FRAME. */)
+ (Lisp_Object frame, Lisp_Object type)
+{
+ return frame_geometry (frame, ((EQ (type, Qouter_edges)
+ || EQ (type, Qinner_edges))
+ ? type
+ : Qnative_edges));
+}
- x_real_pos_and_offsets (f, &left_off, &right_off, &top_off, &bottom_off,
- NULL, NULL, NULL, NULL, &outer_border);
+DEFUN ("x-mouse-absolute-pixel-position", Fx_mouse_absolute_pixel_position,
+ Sx_mouse_absolute_pixel_position, 0, 0, 0,
+ doc: /* Return absolute position of mouse cursor in pixels.
+The position is returned as a cons cell (X . Y) of the coordinates of
+the mouse cursor position in pixels relative to a position (0, 0) of the
+selected frame's display. */)
+ (void)
+{
+ struct frame *f = SELECTED_FRAME ();
+ Window root, dummy_window;
+ int x, y, dummy;
+ if (FRAME_INITIAL_P (f) || !FRAME_X_P (f))
+ return Qnil;
+ block_input ();
+ XQueryPointer (FRAME_X_DISPLAY (f),
+ DefaultRootWindow (FRAME_X_DISPLAY (f)),
+ &root, &dummy_window, &x, &y, &dummy, &dummy,
+ (unsigned int *) &dummy);
unblock_input ();
- border = atts.border_width;
- title = top_off;
-
- outer_width = atts.width + 2 * border + right_off + left_off
- + 2 * outer_border;
- outer_height = atts.height + 2 * border + top_off + bottom_off
- + 2 * outer_border;
+ return Fcons (make_number (x), make_number (y));
+}
-#if defined (USE_GTK)
+DEFUN ("x-set-mouse-absolute-pixel-position", Fx_set_mouse_absolute_pixel_position,
+ Sx_set_mouse_absolute_pixel_position, 2, 2, 0,
+ doc: /* Move mouse pointer to absolute pixel position (X, Y).
+The coordinates X and Y are interpreted in pixels relative to a position
+(0, 0) of the selected frame's display. */)
+ (Lisp_Object x, Lisp_Object y)
{
- bool tool_bar_left_right = (EQ (FRAME_TOOL_BAR_POSITION (f), Qleft)
- || EQ (FRAME_TOOL_BAR_POSITION (f), Qright));
-
- tool_bar_width = (tool_bar_left_right
- ? FRAME_TOOLBAR_WIDTH (f)
- : FRAME_PIXEL_WIDTH (f));
- tool_bar_height = (tool_bar_left_right
- ? FRAME_PIXEL_HEIGHT (f)
- : FRAME_TOOLBAR_HEIGHT (f));
- }
-#else
- tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f);
- tool_bar_width = tool_bar_height > 0 ? FRAME_PIXEL_WIDTH (f) : 0;
-#endif
+ struct frame *f = SELECTED_FRAME ();
-#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
- menu_bar_height = FRAME_MENUBAR_HEIGHT (f);
-#else
- menu_bar_height = FRAME_MENU_BAR_HEIGHT (f);
-#endif
+ if (FRAME_INITIAL_P (f) || !FRAME_X_P (f))
+ return Qnil;
- menu_bar_width = menu_bar_height > 0 ? FRAME_PIXEL_WIDTH (f) : 0;
-
- if (!FRAME_EXTERNAL_MENU_BAR (f))
- inner_height -= menu_bar_height;
- if (!FRAME_EXTERNAL_TOOL_BAR (f))
- inner_height -= tool_bar_height;
-
- return
- listn (CONSTYPE_HEAP, 10,
- Fcons (Qframe_position,
- Fcons (make_number (f->left_pos), make_number (f->top_pos))),
- Fcons (Qframe_outer_size,
- Fcons (make_number (outer_width), make_number (outer_height))),
- Fcons (Qexternal_border_size,
- ((EQ (fullscreen, Qfullboth) || EQ (fullscreen, Qfullscreen))
- ? Fcons (make_number (0), make_number (0))
- : Fcons (make_number (border), make_number (border)))),
- Fcons (Qtitle_height,
- ((EQ (fullscreen, Qfullboth) || EQ (fullscreen, Qfullscreen))
- ? make_number (0)
- : make_number (title))),
- Fcons (Qmenu_bar_external, FRAME_EXTERNAL_MENU_BAR (f) ? Qt : Qnil),
- Fcons (Qmenu_bar_size,
- Fcons (make_number (menu_bar_width),
- make_number (menu_bar_height))),
- Fcons (Qtool_bar_external, FRAME_EXTERNAL_TOOL_BAR (f) ? Qt : Qnil),
- Fcons (Qtool_bar_position, FRAME_TOOL_BAR_POSITION (f)),
- Fcons (Qtool_bar_size,
- Fcons (make_number (tool_bar_width),
- make_number (tool_bar_height))),
- Fcons (Qframe_inner_size,
- Fcons (make_number (inner_width),
- make_number (inner_height))));
+ CHECK_TYPE_RANGED_INTEGER (int, x);
+ CHECK_TYPE_RANGED_INTEGER (int, y);
+
+ block_input ();
+ XWarpPointer (FRAME_X_DISPLAY (f), None, DefaultRootWindow (FRAME_X_DISPLAY (f)),
+ 0, 0, 0, 0, XINT (x), XINT (y));
+ unblock_input ();
+
+ return Qnil;
}
/************************************************************************
if (class == -1
|| !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
dpyinfo->n_planes, class, &vinfo))
- fatal ("Invalid visual specification `%s'", SDATA (value));
+ fatal ("Invalid visual specification '%s'",
+ SSDATA (ENCODE_SYSTEM (value)));
dpyinfo->visual = vinfo.visual;
}
Optional second arg XRM-STRING is a string of resources in xrdb format.
If the optional third arg MUST-SUCCEED is non-nil,
terminate Emacs if we can't open the connection.
-\(In the Nextstep version, the last two arguments are currently ignored.) */)
+(In the Nextstep version, the last two arguments are currently ignored.) */)
(Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
{
char *xrm_option;
int actual_format;
unsigned long actual_size, bytes_remaining;
int rc;
- struct gcpro gcpro1;
-
- GCPRO1 (prop_value);
rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
prop_atom, 0, 0, False, target_type,
if (tmp_data) XFree (tmp_data);
}
- UNGCPRO;
return prop_value;
}
Lisp_Object prop_value = Qnil;
Atom target_type = XA_STRING;
Window target_window = FRAME_X_WINDOW (f);
- struct gcpro gcpro1;
bool found;
- GCPRO1 (prop_value);
CHECK_STRING (prop);
if (! NILP (source))
unblock_input ();
- UNGCPRO;
return prop_value;
}
Lisp_Object name;
int width, height;
ptrdiff_t count = SPECPDL_INDEX ();
- struct gcpro gcpro1, gcpro2, gcpro3;
bool face_change_before = face_change;
Lisp_Object buffer;
struct buffer *old_buffer;
+ int x_width = 0, x_height = 0;
if (!dpyinfo->terminal->name)
error ("Terminal is not live, can't create new frames on it");
error ("Invalid frame name--not a string or nil");
frame = Qnil;
- GCPRO3 (parms, name, frame);
f = make_frame (true);
XSETFRAME (frame, f);
to get the color reference counts right, so initialize them! */
{
Lisp_Object black;
- struct gcpro gcpro1;
/* Function x_decode_color can signal an error. Make
sure to initialize color slots so that we won't try
f->output_data.x->mouse_pixel = -1;
black = build_string ("black");
- GCPRO1 (black);
FRAME_FOREGROUND_PIXEL (f)
= x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
FRAME_BACKGROUND_PIXEL (f)
= x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
f->output_data.x->mouse_pixel
= x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
- UNGCPRO;
}
/* Set the name; the functions to which we pass f expect the name to
#endif /* HAVE_FREETYPE */
#endif /* not USE_CAIRO */
+ image_cache_refcount =
+ FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
+#ifdef GLYPH_DEBUG
+ dpyinfo_refcount = dpyinfo->reference_count;
+#endif /* GLYPH_DEBUG */
+
x_default_parameter (f, parms, Qfont_backend, Qnil,
"fontBackend", "FontBackend", RES_TYPE_STRING);
x_default_parameter (f, parms, Qborder_color, build_string ("black"),
"borderColor", "BorderColor", RES_TYPE_STRING);
-#ifdef GLYPH_DEBUG
- image_cache_refcount =
- FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
- dpyinfo_refcount = dpyinfo->reference_count;
-#endif /* GLYPH_DEBUG */
-
/* Init faces before x_default_parameter is called for the
scroll-bar-width parameter because otherwise we end up in
init_iterator with a null face cache, which should not happen. */
f->output_data.x->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
- x_figure_window_size (f, parms, false);
+ x_figure_window_size (f, parms, false, &x_width, &x_height);
{
XSetWindowAttributes attrs;
Atom type = FRAME_DISPLAY_INFO (f)->Xatom_net_window_type_tooltip;
block_input ();
- mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
+ mask = CWBackPixel | CWOverrideRedirect | CWEventMask | CWCursor;
if (DoesSaveUnders (dpyinfo->screen))
mask |= CWSaveUnder;
attrs.override_redirect = True;
attrs.save_under = True;
attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
+ attrs.cursor =
+ f->output_data.x->current_cursor
+ = f->output_data.x->text_cursor;
/* Arrange for getting MapNotify and UnmapNotify events. */
attrs.event_mask = StructureNotifyMask;
tip_window
"autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
x_default_parameter (f, parms, Qcursor_type, Qbox,
"cursorType", "CursorType", RES_TYPE_SYMBOL);
+ x_default_parameter (f, parms, Qalpha, Qnil,
+ "alpha", "Alpha", RES_TYPE_NUMBER);
/* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
Change will not be effected unless different from the current
f->no_split = true;
- UNGCPRO;
-
/* Now that the frame will be official, it counts as a reference to
its display and terminal. */
FRAME_DISPLAY_INFO (f)->reference_count++;
static void
compute_tip_xy (struct frame *f, Lisp_Object parms, Lisp_Object dx, Lisp_Object dy, int width, int height, int *root_x, int *root_y)
{
- Lisp_Object left, top;
+ Lisp_Object left, top, right, bottom;
int win_x, win_y;
Window root, child;
unsigned pmask;
/* User-specified position? */
left = Fcdr (Fassq (Qleft, parms));
top = Fcdr (Fassq (Qtop, parms));
+ right = Fcdr (Fassq (Qright, parms));
+ bottom = Fcdr (Fassq (Qbottom, parms));
/* Move the tooltip window where the mouse pointer is. Resize and
show it. */
- if (!INTEGERP (left) || !INTEGERP (top))
+ if ((!INTEGERP (left) && !INTEGERP (right))
+ || (!INTEGERP (top) && !INTEGERP (bottom)))
{
block_input ();
XQueryPointer (FRAME_X_DISPLAY (f), FRAME_DISPLAY_INFO (f)->root_window,
if (INTEGERP (top))
*root_y = XINT (top);
+ else if (INTEGERP (bottom))
+ *root_y = XINT (bottom) - height;
else if (*root_y + XINT (dy) <= 0)
*root_y = 0; /* Can happen for negative dy */
else if (*root_y + XINT (dy) + height
if (INTEGERP (left))
*root_x = XINT (left);
+ else if (INTEGERP (right))
+ *root_x = XINT (right) - width;
else if (*root_x + XINT (dx) <= 0)
*root_x = 0; /* Can happen for negative dx */
else if (*root_x + XINT (dx) + width
Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
means use the default timeout of 5 seconds.
-If the list of frame parameters PARMS contains a `left' parameters,
-the tooltip is displayed at that x-position. Otherwise it is
-displayed at the mouse position, with offset DX added (default is 5 if
-DX isn't specified). Likewise for the y-position; if a `top' frame
-parameter is specified, it determines the y-position of the tooltip
-window, otherwise it is displayed at the mouse position, with offset
-DY added (default is -10).
+If the list of frame parameters PARMS contains a `left' parameter,
+display the tooltip at that x-position. If the list of frame parameters
+PARMS contains no `left' but a `right' parameter, display the tooltip
+right-adjusted at that x-position. Otherwise display it at the
+x-position of the mouse, with offset DX added (default is 5 if DX isn't
+specified).
+
+Likewise for the y-position: If a `top' frame parameter is specified, it
+determines the position of the upper edge of the tooltip window. If a
+`bottom' parameter but no `top' frame parameter is specified, it
+determines the position of the lower edge of the tooltip window.
+Otherwise display the tooltip window at the y-position of the mouse,
+with offset DY added (default is -10).
A tooltip's maximum size is specified by `x-max-tooltip-size'.
Text larger than the specified size is clipped. */)
struct text_pos pos;
int i, width, height;
bool seen_reversed_p;
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_redisplay, Qt);
- GCPRO4 (string, parms, frame, timeout);
-
CHECK_STRING (string);
if (SCHARS (string) == 0)
string = make_unibyte_string (" ", 1);
tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
intern ("x-hide-tip"));
- UNGCPRO;
return unbind_to (count, Qnil);
}
{
ptrdiff_t count;
Lisp_Object deleted, frame, timer;
- struct gcpro gcpro1, gcpro2;
/* Return quickly if nothing to do. */
if (NILP (tip_timer) && NILP (tip_frame))
frame = tip_frame;
timer = tip_timer;
- GCPRO2 (frame, timer);
tip_frame = tip_timer = deleted = Qnil;
count = SPECPDL_INDEX ();
#endif /* USE_LUCID */
}
- UNGCPRO;
return unbind_to (count, deleted);
}
int ac = 0;
XmString dir_xmstring, pattern_xmstring;
ptrdiff_t count = SPECPDL_INDEX ();
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
check_window_system (f);
- GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
-
if (popup_activated ())
error ("Trying to use a menu from within a menu-entry");
file = Qnil;
unblock_input ();
- UNGCPRO;
/* Make "Cancel" equivalent to C-g. */
if (NILP (file))
Lisp_Object file = Qnil;
Lisp_Object decoded_file;
ptrdiff_t count = SPECPDL_INDEX ();
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
char *cdef_file;
check_window_system (f);
- GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
-
if (popup_activated ())
error ("Trying to use a menu from within a menu-entry");
}
unblock_input ();
- UNGCPRO;
/* Make "Cancel" equivalent to C-g. */
if (NILP (file))
Lisp_Object font;
Lisp_Object font_param;
char *default_name = NULL;
- struct gcpro gcpro1, gcpro2;
ptrdiff_t count = SPECPDL_INDEX ();
if (popup_activated ())
block_input ();
- GCPRO2 (font_param, font);
-
XSETFONT (font, FRAME_FONT (f));
font_param = Ffont_get (font, QCname);
if (STRINGP (font_param))
#ifdef USE_CAIRO
DEFUN ("x-export-frames", Fx_export_frames, Sx_export_frames, 0, 2, 0,
- doc: /* XXX Experimental. Return image data of FRAMES in TYPE format.
+ doc: /* Return image data of FRAMES in TYPE format.
FRAMES should be nil (the selected frame), a frame, or a list of
-frames (each of which corresponds to one page). Optional arg TYPE
-should be either `pdf' (default), `png', `ps', or `svg'. Supported
-types are determined by the compile-time configuration of cairo. */)
+frames (each of which corresponds to one page). Each frame should be
+visible. Optional arg TYPE should be either `pdf' (default), `png',
+`postscript', or `svg'. Supported types are determined by the
+compile-time configuration of cairo. */)
(Lisp_Object frames, Lisp_Object type)
{
- Lisp_Object result, rest, tmp;
+ Lisp_Object rest, tmp;
cairo_surface_type_t surface_type;
- if (NILP (frames))
- frames = selected_frame;
if (!CONSP (frames))
frames = list1 (frames);
tmp = Qnil;
for (rest = frames; CONSP (rest); rest = XCDR (rest))
{
- struct frame *f = XFRAME (XCAR (rest));
-
- if (! FRAME_LIVE_P (f) || ! FRAME_X_P (f) || ! FRAME_LIVE_P (f))
- error ("Invalid frame");
-
+ struct frame *f = decode_window_system_frame (XCAR (rest));
Lisp_Object frame;
XSETFRAME (frame, f);
+ if (!FRAME_VISIBLE_P (f))
+ error ("Frames to be exported must be visible.");
tmp = Fcons (frame, tmp);
}
frames = Fnreverse (tmp);
#ifdef CAIRO_HAS_PDF_SURFACE
- if (NILP (type) || EQ (type, intern ("pdf"))) /* XXX: Qpdf */
+ if (NILP (type) || EQ (type, Qpdf))
surface_type = CAIRO_SURFACE_TYPE_PDF;
else
#endif
#ifdef CAIRO_HAS_PNG_FUNCTIONS
- if (EQ (type, intern ("png")))
+ if (EQ (type, Qpng))
{
if (!NILP (XCDR (frames)))
error ("PNG export cannot handle multiple frames.");
else
#endif
#ifdef CAIRO_HAS_PS_SURFACE
- if (EQ (type, intern ("ps")))
+ if (EQ (type, Qpostscript))
surface_type = CAIRO_SURFACE_TYPE_PS;
else
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
- if (EQ (type, intern ("svg")))
+ if (EQ (type, Qsvg))
{
/* For now, we stick to SVG 1.1. */
if (!NILP (XCDR (frames)))
#endif
error ("Unsupported export type");
- result = x_cr_export_frames (frames, surface_type);
-
- return result;
+ return x_cr_export_frames (frames, surface_type);
}
#ifdef USE_GTK
on, in points.
The paper width can be obtained as the sum of width, left-margin, and
-right-margin values. Likewise, the paper height is the sum of height,
-top-margin, and bottom-margin values. */)
+right-margin values if the page orientation is `portrait' or
+`reverse-portrait'. Otherwise, it is the sum of width, top-margin,
+and bottom-margin values. Likewise, the paper height is the sum of
+height, top-margin, and bottom-margin values if the page orientation
+is `portrait' or `reverse-portrait'. Otherwise, it is the sum of
+height, left-margin, and right-margin values. */)
(void)
{
Lisp_Object result;
(Lisp_Object frames)
{
Lisp_Object rest, tmp;
+ int count;
- if (NILP (frames))
- frames = selected_frame;
if (!CONSP (frames))
frames = list1 (frames);
tmp = Qnil;
for (rest = frames; CONSP (rest); rest = XCDR (rest))
{
- struct frame *f = XFRAME (XCAR (rest));
- if (! FRAME_LIVE_P (f) || ! FRAME_X_P (f) || ! FRAME_LIVE_P (f))
- error ("Invalid frame");
+ struct frame *f = decode_window_system_frame (XCAR (rest));
Lisp_Object frame;
XSETFRAME (frame, f);
- if (!EQ (Fframe_visible_p (frame), Qt))
+ if (!FRAME_VISIBLE_P (f))
error ("Frames to be printed must be visible.");
tmp = Fcons (frame, tmp);
}
frames = Fnreverse (tmp);
/* Make sure the current matrices are up-to-date. */
- Fredisplay (Qt);
+ count = SPECPDL_INDEX ();
+ specbind (Qredisplay_dont_pause, Qt);
+ redisplay_preserve_echo_area (32);
+ unbind_to (count, Qnil);
block_input ();
xg_print_frames_dialog (frames);
DEFSYM (Qmono, "mono");
#ifdef USE_CAIRO
+ DEFSYM (Qpdf, "pdf");
+
DEFSYM (Qorientation, "orientation");
DEFSYM (Qtop_margin, "top-margin");
DEFSYM (Qbottom_margin, "bottom-margin");
defsubr (&Sx_display_save_under);
defsubr (&Sx_display_monitor_attributes_list);
defsubr (&Sx_frame_geometry);
+ defsubr (&Sx_frame_edges);
+ defsubr (&Sx_mouse_absolute_pixel_position);
+ defsubr (&Sx_set_mouse_absolute_pixel_position);
defsubr (&Sx_wm_set_size_hint);
defsubr (&Sx_create_frame);
defsubr (&Sx_open_connection);