/* 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>
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 ();
}
}
+/* 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);
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
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. */
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.
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
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++;
if (INTEGERP (left))
*root_x = XINT (left);
else if (INTEGERP (right))
- *root_y = XINT (right) - width;
+ *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
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");