/* 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 bw, 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, &bw, &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)
- *outer_border = bw;
+ /* 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 (!had_errors && dpyinfo->root_window == f->output_data.x->parent_desc)
+ 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 (tmp_data) XFree (tmp_data);
+#endif
+ }
+
+ 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.
}
}
+/* 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;
- block_input ();
-
- /* It's not okay to crash if the user selects a screwy cursor. */
- x_catch_errors (dpy);
-
- 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));
+ 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;
}
- else
- cursor = XCreateFontCursor (dpy, XC_xterm);
- x_check_errors (dpy, "bad text pointer cursor: %s");
- if (!NILP (Vx_nontext_pointer_shape))
- {
- 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");
+ block_input ();
- 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");
+ /* It's not okay to crash if the user selects a screwy cursor. */
+ x_catch_errors_with_handler (dpy, x_set_mouse_color_handler, &cursor_data);
- if (!NILP (Vx_mode_pointer_shape))
+ for (i = 0; i < mouse_cursor_max; i++)
{
- CHECK_NUMBER (Vx_mode_pointer_shape);
- mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_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
- mode_cursor = XCreateFontCursor (dpy, XC_xterm);
- x_check_errors (dpy, "bad modeline pointer cursor: %s");
- if (!NILP (Vx_sensitive_text_pointer_shape))
+ /* Now sync up and process all received errors from cursor
+ creation. */
+ if (x_had_errors_p (dpy))
{
- CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
- hand_cursor
- = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
- }
- else
- hand_cursor = XCreateFontCursor (dpy, XC_hand2);
+ 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_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 ();
- 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));
+ /* 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]);
+
+ /* 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
- vertical_drag_cursor
- = XCreateFontCursor (dpy, XC_sb_v_double_arrow);
- /* Check and report errors with the above calls. */
- x_check_errors (dpy, "can't set cursor shape: %s");
x_uncatch_errors_after_check ();
{
- 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);
+ XColor colors[2]; /* 0=foreground, 1=background */
+
+ colors[0].pixel = x->mouse_pixel;
+ colors[1].pixel = mask_color;
+ x_query_colors (f, colors, 2);
+
+ 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 ();
#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);
/* 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,
- ((NILP (fullscreen = get_frame_param (f, Qfullscreen))
- || EQ (fullscreen, Qfullwidth)) ? 1
+ ((!f->tool_bar_resized
+ && (NILP (fullscreen =
+ get_frame_param (f, Qfullscreen))
+ || EQ (fullscreen, Qfullwidth))) ? 1
: (old_height == 0 || height == 0) ? 2
: 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);
struct x_display_info *dpyinfo = NULL;
Lisp_Object parent;
struct kboard *kb;
+ int x_width = 0, x_height = 0;
parms = Fcopy_alist (parms);
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. */
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");
"foreground", "Foreground", RES_TYPE_STRING);
x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
"background", "Background", RES_TYPE_STRING);
-#if 0 /* This code currently doesn't work for tooltip frames; the
- cursor being set doesn't seem to get used. The call generates
- a bit of traffic, so skip it for now. */
x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
"pointerColor", "Foreground", RES_TYPE_STRING);
-#endif
x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
"cursorColor", "Foreground", RES_TYPE_STRING);
x_default_parameter (f, parms, Qborder_color, build_string ("black"),
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
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
#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");