/* 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.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
#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>
#include "../lwlib/xlwmenu.h"
#endif
-#if !defined (NO_EDITRES)
-#define HACK_EDITRES
-extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
-#endif /* not defined NO_EDITRES */
-
/* Unique id counter for widgets created by the Lucid Widget Library. */
extern LWLIB_ID widget_id_tick;
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)
+ if (had_errors || wm_window == rootw)
break;
win = wm_window;
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 ();
}
}
+/* 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 ();
#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);
}
#endif /* not USE_X_TOOLKIT && not USE_GTK */
adjust_frame_glyphs (f);
- run_window_configuration_change_hook (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);
if (border != FRAME_INTERNAL_BORDER_WIDTH (f))
{
- FRAME_INTERNAL_BORDER_WIDTH (f) = border;
+ f->internal_border_width = border;
#ifdef USE_X_TOOLKIT
if (FRAME_X_OUTPUT (f)->edit_widget)
hack_wm_protocols (f, shell_widget);
-#ifdef HACK_EDITRES
+#ifdef X_TOOLKIT_EDITRES
XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
#endif
{
/* Remember the explicit font parameter, so we can re-apply it after
we've applied the `default' face settings. */
- AUTO_FRAME_ARG (arg, Qfont_param, font_param);
+ AUTO_FRAME_ARG (arg, Qfont_parameter, font_param);
x_set_frame_parameters (f, arg);
}
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. */
\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.) */)
+\(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.
struct frame *f = XFRAME (frame);
if (FRAME_X_P (f) && FRAME_DISPLAY_INFO (f) == dpyinfo
- && !EQ (frame, tip_frame))
+ && !FRAME_TOOLTIP_P (f))
{
int i = x_get_monitor_for_frame (f, monitors, n_monitors);
ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
RROutput pxid = None;
struct MonitorInfo *monitors;
-#ifdef HAVE_XRRGETSCREENRESOURCESCURRENT
- resources = XRRGetScreenResourcesCurrent (dpy, dpyinfo->root_window);
+#define RANDR13_LIBRARY \
+ (RANDR_MAJOR > 1 || (RANDR_MAJOR == 1 && RANDR_MINOR >= 3))
+
+#if RANDR13_LIBRARY
+ /* Check if the display supports 1.3 too. */
+ bool randr13_avail = (dpyinfo->xrandr_major_version > 1
+ || (dpyinfo->xrandr_major_version == 1
+ && dpyinfo->xrandr_minor_version >= 3));
+
+ if (randr13_avail)
+ resources = XRRGetScreenResourcesCurrent (dpy, dpyinfo->root_window);
+ else
+ resources = XRRGetScreenResources (dpy, dpyinfo->root_window);
#else
resources = XRRGetScreenResources (dpy, dpyinfo->root_window);
#endif
n_monitors = resources->noutput;
monitors = xzalloc (n_monitors * sizeof *monitors);
-#ifdef HAVE_XRRGETOUTPUTPRIMARY
- pxid = XRRGetOutputPrimary (dpy, dpyinfo->root_window);
+#if RANDR13_LIBRARY
+ if (randr13_avail)
+ pxid = XRRGetOutputPrimary (dpy, dpyinfo->root_window);
#endif
for (i = 0; i < n_monitors; ++i)
{
XRROutputInfo *info = XRRGetOutputInfo (dpy, resources,
resources->outputs[i]);
- Connection conn = info ? info->connection : RR_Disconnected;
- RRCrtc id = info ? info->crtc : None;
+ if (!info)
+ continue;
if (strcmp (info->name, "default") == 0)
{
return Qnil;
}
- if (conn != RR_Disconnected && id != None)
+ if (info->connection != RR_Disconnected && info->crtc != None)
{
- XRRCrtcInfo *crtc = XRRGetCrtcInfo (dpy, resources, id);
+ XRRCrtcInfo *crtc = XRRGetCrtcInfo (dpy, resources, info->crtc);
struct MonitorInfo *mi = &monitors[i];
XRectangle workarea_r;
xrr_ok = XRRQueryExtension (dpy, &xrr_event_base, &xrr_error_base);
if (xrr_ok)
{
- int xrr_major, xrr_minor;
- XRRQueryVersion (dpy, &xrr_major, &xrr_minor);
- xrr_ok = (xrr_major == 1 && xrr_minor >= 2) || xrr_major > 1;
+ XRRQueryVersion (dpy, &dpyinfo->xrandr_major_version,
+ &dpyinfo->xrandr_minor_version);
+ xrr_ok = ((dpyinfo->xrandr_major_version == 1
+ && dpyinfo->xrandr_minor_version >= 2)
+ || dpyinfo->xrandr_major_version > 1);
}
if (xrr_ok)
struct frame *f = XFRAME (frame);
if (FRAME_X_P (f) && FRAME_DISPLAY_INFO (f) == dpyinfo
- && !EQ (frame, tip_frame))
+ && !FRAME_TOOLTIP_P (f))
{
GdkWindow *gwin = gtk_widget_get_window (FRAME_GTK_WIDGET (f));
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. */)
+\(0, 0) of the selected frame's display. */)
(Lisp_Object x, Lisp_Object y)
{
struct frame *f = SELECTED_FRAME ();
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;
Tool tips
***********************************************************************/
-static Lisp_Object x_create_tip_frame (struct x_display_info *,
- Lisp_Object, Lisp_Object);
-static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
- Lisp_Object, int, int, int *, int *);
-
-/* The frame of a currently visible tooltip. */
-
-Lisp_Object tip_frame;
-
-/* If non-nil, a timer started that hides the last tooltip when it
- fires. */
-
-static Lisp_Object tip_timer;
-Window tip_window;
-
-/* If non-nil, a vector of 3 elements containing the last args
- with which x-show-tip was called. See there. */
-
-static Lisp_Object last_show_tip_args;
-
-
-static void
-unwind_create_tip_frame (Lisp_Object frame)
-{
- Lisp_Object deleted;
-
- deleted = unwind_create_frame (frame);
- if (EQ (deleted, Qt))
- {
- tip_window = None;
- tip_frame = Qnil;
- }
-}
-
-
/* Create a frame for a tooltip on the display described by DPYINFO.
PARMS is a list of frame parameters. TEXT is the string to
display in the tip frame. Value is the frame.
when this happens. */
static Lisp_Object
-x_create_tip_frame (struct x_display_info *dpyinfo,
- Lisp_Object parms,
- Lisp_Object text)
+x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
{
struct frame *f;
Lisp_Object frame;
int width, height;
ptrdiff_t count = SPECPDL_INDEX ();
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;
- f = make_frame (true);
+ f = make_frame (false);
+ f->wants_modeline = false;
XSETFRAME (frame, f);
-
- AUTO_STRING (tip, " *tip*");
- buffer = Fget_buffer_create (tip);
- /* Use set_window_buffer instead of Fset_window_buffer (see
- discussion of bug#11984, bug#12025, bug#12026). */
- set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, false, false);
- old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (buffer));
- bset_truncate_lines (current_buffer, Qnil);
- specbind (Qinhibit_read_only, Qt);
- specbind (Qinhibit_modification_hooks, Qt);
- Ferase_buffer ();
- Finsert (1, &text);
- set_buffer_internal_1 (old_buffer);
-
- record_unwind_protect (unwind_create_tip_frame, frame);
+ record_unwind_protect (do_unwind_create_frame, frame);
f->terminal = dpyinfo->terminal;
f->output_data.x->white_relief.pixel = -1;
f->output_data.x->black_relief.pixel = -1;
+ f->tooltip = true;
fset_icon_name (f, Qnil);
FRAME_DISPLAY_INFO (f) = dpyinfo;
f->output_data.x->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
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
- = FRAME_X_WINDOW (f)
+ FRAME_X_WINDOW (f)
= XCreateWindow (FRAME_X_DISPLAY (f),
FRAME_DISPLAY_INFO (f)->root_window,
/* x, y, width, height */
f->border_width,
CopyFromParent, InputOutput, CopyFromParent,
mask, &attrs);
- XChangeProperty (FRAME_X_DISPLAY (f), tip_window,
+ XChangeProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
FRAME_DISPLAY_INFO (f)->Xatom_net_window_type,
XA_ATOM, 32, PropModeReplace,
(unsigned char *)&type, 1);
"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
SET_FRAME_LINES (f, 0);
change_frame_size (f, width, height, true, false, false, false);
- /* Add `tooltip' frame parameter's default value. */
- if (NILP (Fframe_parameter (frame, Qtooltip)))
- {
- AUTO_FRAME_ARG (arg, Qtooltip, Qt);
- Fmodify_frame_parameters (frame, arg);
- }
-
/* FIXME - can this be done in a similar way to normal frames?
http://lists.gnu.org/archive/html/emacs-devel/2007-10/msg00641.html */
{
Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
- /* Set tip_frame here, so that */
- tip_frame = frame;
call2 (Qface_set_after_frame_default, frame, Qnil);
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
f->no_split = true;
+ /* Now this is an official tooltip frame on this display. */
+ dpyinfo->x_tooltip_frame = f;
+
/* Now that the frame will be official, it counts as a reference to
its display and terminal. */
FRAME_DISPLAY_INFO (f)->reference_count++;
the display in *ROOT_X, and *ROOT_Y. */
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)
+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, right, bottom;
int win_x, win_y;
Window root, child;
unsigned pmask;
+ int min_x, min_y, max_x, max_y = -1;
/* User-specified position? */
left = Fcdr (Fassq (Qleft, parms));
if ((!INTEGERP (left) && !INTEGERP (right))
|| (!INTEGERP (top) && !INTEGERP (bottom)))
{
+ Lisp_Object frame, attributes, monitor, geometry;
+
block_input ();
XQueryPointer (FRAME_X_DISPLAY (f), FRAME_DISPLAY_INFO (f)->root_window,
&root, &child, root_x, root_y, &win_x, &win_y, &pmask);
unblock_input ();
+
+ XSETFRAME(frame, f);
+ attributes = Fx_display_monitor_attributes_list (frame);
+
+ /* Try to determine the monitor where the mouse pointer is and
+ its geometry. See bug#22549. */
+ while (CONSP (attributes))
+ {
+ monitor = XCAR (attributes);
+ geometry = Fassq (Qgeometry, monitor);
+ if (CONSP (geometry))
+ {
+ min_x = XINT (Fnth (make_number (1), geometry));
+ min_y = XINT (Fnth (make_number (2), geometry));
+ max_x = min_x + XINT (Fnth (make_number (3), geometry));
+ max_y = min_y + XINT (Fnth (make_number (4), geometry));
+ if (min_x <= *root_x && *root_x < max_x
+ && min_y <= *root_y && *root_y < max_y)
+ {
+ break;
+ }
+ max_y = -1;
+ }
+
+ attributes = XCDR (attributes);
+ }
+ }
+
+ /* It was not possible to determine the monitor's geometry, so we
+ assign some sane defaults here: */
+ if ( max_y < 0 )
+ {
+ min_x = 0;
+ min_y = 0;
+ max_x = x_display_pixel_width (FRAME_DISPLAY_INFO (f));
+ max_y = x_display_pixel_height (FRAME_DISPLAY_INFO (f));
}
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
- <= x_display_pixel_height (FRAME_DISPLAY_INFO (f)))
+ else if (*root_y + XINT (dy) <= min_y)
+ *root_y = min_y; /* Can happen for negative dy */
+ else if (*root_y + XINT (dy) + height <= max_y)
/* It fits below the pointer */
*root_y += XINT (dy);
- else if (height + XINT (dy) <= *root_y)
+ else if (height + XINT (dy) + min_y <= *root_y)
/* It fits above the pointer. */
*root_y -= height + XINT (dy);
else
/* Put it on the top. */
- *root_y = 0;
+ *root_y = min_y;
if (INTEGERP (left))
*root_x = XINT (left);
else if (INTEGERP (right))
- *root_y = XINT (right) - width;
- else if (*root_x + XINT (dx) <= 0)
+ *root_x = XINT (right) - width;
+ else if (*root_x + XINT (dx) <= min_x)
*root_x = 0; /* Can happen for negative dx */
- else if (*root_x + XINT (dx) + width
- <= x_display_pixel_width (FRAME_DISPLAY_INFO (f)))
+ else if (*root_x + XINT (dx) + width <= max_x)
/* It fits to the right of the pointer. */
*root_x += XINT (dx);
- else if (width + XINT (dx) <= *root_x)
+ else if (width + XINT (dx) + min_x <= *root_x)
/* It fits to the left of the pointer. */
*root_x -= width + XINT (dx);
else
- /* Put it left-justified on the screen--it ought to fit that way. */
- *root_x = 0;
+ /* Put it left justified on the screen -- it ought to fit that way. */
+ *root_x = min_x;
}
+/* Hide tooltip frame F and delete it if DELETE is true. */
+
+static Lisp_Object
+x_hide_tip (struct frame *f, bool delete)
+{
+ if (f)
+ {
+ Lisp_Object frame, timer;
+
+ XSETFRAME (frame, f);
+ timer = Fframe_parameter (frame, Qtooltip_timer);
+
+ if (!NILP (timer))
+ call1 (Qcancel_timer, timer);
+
+ if (!delete && !FRAME_VISIBLE_P (f))
+ return Qnil;
+ else
+ {
+ ptrdiff_t count = SPECPDL_INDEX ();
+
+ specbind (Qinhibit_redisplay, Qt);
+ specbind (Qinhibit_quit, Qt);
+
+#ifdef USE_GTK
+ if (x_gtk_use_system_tooltips)
+ /* Should be handled by xg_hide_tooltip. */
+ emacs_abort ();
+#endif
+ if (delete)
+ delete_frame (frame, Qnil);
+ else
+ x_make_frame_invisible (f);
+
+#ifdef USE_LUCID
+ /* Bloodcurdling hack alert: The Lucid menu bar widget's
+ redisplay procedure is not called when a tip frame over
+ menu items is unmapped. Redisplay the menu manually... */
+ {
+ Widget w;
+ struct frame *sf = SELECTED_FRAME ();
+ if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
+ {
+ w = sf->output_data.x->menubar_widget;
+
+ if (!DoesSaveUnders (FRAME_DISPLAY_INFO (sf)->screen)
+ && w != NULL)
+ {
+ block_input ();
+ xlwmenu_redisplay (w);
+ unblock_input ();
+ }
+ }
+ }
+#endif /* USE_LUCID */
+ return unbind_to (count, Qt);
+ }
+ }
+ return Qnil;
+}
DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
doc: /* Show STRING in a "tooltip" window on frame FRAME.
A tooltip's maximum size is specified by `x-max-tooltip-size'.
Text larger than the specified size is clipped. */)
- (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
+ (Lisp_Object string, Lisp_Object frame, Lisp_Object parms,
+ Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
{
- struct frame *f;
+ struct frame *f, *tip_f;
struct window *w;
int root_x, root_y;
struct buffer *old_buffer;
struct text_pos pos;
- int i, width, height;
- bool seen_reversed_p;
+ int width, height;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
ptrdiff_t count = SPECPDL_INDEX ();
+ ptrdiff_t count_1;
+ Lisp_Object window, size, tip_frame, parameters;
+ AUTO_STRING (tip, " *tip*");
specbind (Qinhibit_redisplay, Qt);
{
bool ok;
- /* Hide a previous tip, if any. */
- Fx_hide_tip ();
+ /* Hide a previous tip on this frame, if any. */
+ xg_hide_tooltip (f);
block_input ();
ok = xg_prepare_tooltip (f, string, &width, &height);
{
compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
xg_show_tooltip (f, root_x, root_y);
- /* This is used in Fx_hide_tip. */
- XSETFRAME (tip_frame, f);
}
unblock_input ();
- if (ok) goto start_timer;
+ if (ok)
+ /* Schedule call to xg_hide_tip from GTK event loop
+ to allow the tip disappear after timeout seconds. */
+ FRAME_X_OUTPUT (f)->ttip_timeout
+ = g_timeout_add_seconds (XINT (timeout), xg_hide_tip, (gpointer) f);
+ else
+ /* FIXME: what if not ok? */
+ FRAME_X_OUTPUT (f)->ttip_timeout = 0;
+ return unbind_to (count, Qnil);
}
#endif /* USE_GTK */
- if (NILP (last_show_tip_args))
- last_show_tip_args = Fmake_vector (make_number (3), Qnil);
+ parameters = Fframe_parameter (frame, Qtooltip_parameters);
+ if (NILP (parameters))
+ parameters = Fmake_vector (make_number (3), Qnil);
- if (!NILP (tip_frame))
+ /* Look at current tooltip frame, if any. */
+ tip_f = FRAME_DISPLAY_INFO (f)->x_tooltip_frame;
+ if (tip_f)
+ XSETFRAME (tip_frame, tip_f);
+ else
+ tip_frame = Qnil;
+
+ if (tip_f && FRAME_LIVE_P (tip_f))
{
- Lisp_Object last_string = AREF (last_show_tip_args, 0);
- Lisp_Object last_frame = AREF (last_show_tip_args, 1);
- Lisp_Object last_parms = AREF (last_show_tip_args, 2);
+ Lisp_Object last_string = AREF (parameters, 0);
+ Lisp_Object last_frame = AREF (parameters, 1);
+ Lisp_Object last_parms = AREF (parameters, 2);
- if (EQ (frame, last_frame)
- && !NILP (Fequal (last_string, string))
+ if (FRAME_VISIBLE_P (tip_f)
+ && EQ (frame, last_frame)
+ && !NILP (Fequal_including_properties (last_string, string))
&& !NILP (Fequal (last_parms, parms)))
{
- struct frame *tip_f = XFRAME (tip_frame);
-
/* Only DX and DY have changed. */
- if (!NILP (tip_timer))
- {
- Lisp_Object timer = tip_timer;
- tip_timer = Qnil;
- call1 (Qcancel_timer, timer);
- }
+ Lisp_Object timer = Fframe_parameter (tip_frame, Qtooltip_timer);
+
+ if (!NILP (timer))
+ call1 (Qcancel_timer, timer);
block_input ();
compute_tip_xy (tip_f, parms, dx, dy, FRAME_PIXEL_WIDTH (tip_f),
XMoveWindow (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f),
root_x, root_y);
unblock_input ();
+
goto start_timer;
}
+ else if (tooltip_reuse_hidden_frame && EQ (frame, last_frame))
+ {
+ bool delete = false;
+ Lisp_Object tail, elt, parm, last;
+
+ /* Check if every parameter in PARMS has the same value in
+ last_parms unless it should be ignored by means of
+ Vtooltip_reuse_hidden_frame_parameters. This may destruct
+ last_parms which, however, will be recreated below. */
+ for (tail = parms; CONSP (tail); tail = XCDR (tail))
+ {
+ elt = XCAR (tail);
+ parm = Fcar (elt);
+ /* The left, top, right and bottom parameters are handled
+ by compute_tip_xy so they can be ignored here. */
+ if (!EQ (parm, Qleft) && !EQ (parm, Qtop)
+ && !EQ (parm, Qright) && !EQ (parm, Qbottom))
+ {
+ last = Fassq (parm, last_parms);
+ if (NILP (Fequal (Fcdr (elt), Fcdr (last))))
+ {
+ /* We lost, delete the old tooltip. */
+ delete = true;
+ break;
+ }
+ else
+ last_parms = call2 (Qassq_delete_all, parm, last_parms);
+ }
+ else
+ last_parms = call2 (Qassq_delete_all, parm, last_parms);
+ }
+
+ /* Now check if every parameter in what is left of last_parms
+ with a non-nil value has an association in PARMS unless it
+ should be ignored by means of
+ Vtooltip_reuse_hidden_frame_parameters. */
+ for (tail = last_parms; CONSP (tail); tail = XCDR (tail))
+ {
+ elt = XCAR (tail);
+ parm = Fcar (elt);
+ if (!EQ (parm, Qleft) && !EQ (parm, Qtop) && !EQ (parm, Qright)
+ && !EQ (parm, Qbottom) && !NILP (Fcdr (elt)))
+ {
+ /* We lost, delete the old tooltip. */
+ delete = true;
+ break;
+ }
+ }
+
+ x_hide_tip (tip_f, delete);
+ }
+ else
+ x_hide_tip (tip_f, true);
}
+ else
+ x_hide_tip (tip_f, true);
- /* Hide a previous tip, if any. */
- Fx_hide_tip ();
+ /* Update tooltip parameters. */
+ {
+ AUTO_FRAME_ARG (arg, Qtooltip_parameters, parameters);
+ ASET (parameters, 0, string);
+ ASET (parameters, 1, frame);
+ ASET (parameters, 2, parms);
+ Fmodify_frame_parameters (frame, arg);
+ }
+
+ if (!FRAMEP (tip_frame) || !FRAME_LIVE_P (XFRAME (tip_frame)))
+ {
+ /* Add default values to frame parameters. */
+ if (NILP (Fassq (Qname, parms)))
+ parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
+ if (NILP (Fassq (Qinternal_border_width, parms)))
+ parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
+ if (NILP (Fassq (Qborder_width, parms)))
+ parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
+ if (NILP (Fassq (Qborder_color, parms)))
+ parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
+ if (NILP (Fassq (Qbackground_color, parms)))
+ parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
+ parms);
+ if (NILP (tip_frame = x_create_tip_frame (FRAME_DISPLAY_INFO (f), parms)))
+ /* Creating the tip frame failed. */
+ return unbind_to (count, Qnil);
+ }
- ASET (last_show_tip_args, 0, string);
- ASET (last_show_tip_args, 1, frame);
- ASET (last_show_tip_args, 2, parms);
+ tip_f = XFRAME (tip_frame);
+ window = FRAME_ROOT_WINDOW (tip_f);
+ set_window_buffer (window, Fget_buffer_create (tip), false, false);
+ w = XWINDOW (window);
+ w->pseudo_window_p = true;
- /* Add default values to frame parameters. */
- if (NILP (Fassq (Qname, parms)))
- parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
- if (NILP (Fassq (Qinternal_border_width, parms)))
- parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
- if (NILP (Fassq (Qborder_width, parms)))
- parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
- if (NILP (Fassq (Qbottom_divider_width, parms)))
- parms = Fcons (Fcons (Qbottom_divider_width, make_number (0)), parms);
- if (NILP (Fassq (Qright_divider_width, parms)))
- parms = Fcons (Fcons (Qright_divider_width, make_number (0)), parms);
- if (NILP (Fassq (Qborder_color, parms)))
- parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
- if (NILP (Fassq (Qbackground_color, parms)))
- parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
- parms);
-
- /* Create a frame for the tooltip, and record it in the global
- variable tip_frame. */
- frame = x_create_tip_frame (FRAME_DISPLAY_INFO (f), parms, string);
- f = XFRAME (frame);
-
- /* Set up the frame's root window. */
- w = XWINDOW (FRAME_ROOT_WINDOW (f));
+ /* Set up the frame's root window. Note: The following code does not
+ try to size the window or its frame correctly. Its only purpose is
+ to make the subsequent text size calculations work. The right
+ sizes should get installed when the toolkit gets back to us. */
w->left_col = 0;
w->top_line = 0;
w->pixel_left = 0;
w->total_lines = 40;
}
- w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (f);
- w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (f);
-
- FRAME_TOTAL_COLS (f) = w->total_cols;
- adjust_frame_glyphs (f);
- w->pseudo_window_p = true;
+ w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (tip_f);
+ w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (tip_f);
+ FRAME_TOTAL_COLS (tip_f) = w->total_cols;
+ adjust_frame_glyphs (tip_f);
- /* Display the tooltip text in a temporary buffer. */
+ /* Insert STRING into root window's buffer and fit the frame to the
+ buffer. */
+ count_1 = SPECPDL_INDEX ();
old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->contents));
+ set_buffer_internal_1 (XBUFFER (w->contents));
bset_truncate_lines (current_buffer, Qnil);
+ specbind (Qinhibit_read_only, Qt);
+ specbind (Qinhibit_modification_hooks, Qt);
+ specbind (Qinhibit_point_motion_hooks, Qt);
+ Ferase_buffer ();
+ Finsert (1, &string);
clear_glyph_matrix (w->desired_matrix);
clear_glyph_matrix (w->current_matrix);
SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
- try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
-
- /* Compute width and height of the tooltip. */
- width = height = 0;
- seen_reversed_p = false;
- for (i = 0; i < w->desired_matrix->nrows; ++i)
- {
- struct glyph_row *row = &w->desired_matrix->rows[i];
- struct glyph *last;
- int row_width;
-
- /* Stop at the first empty row at the end. */
- if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
- break;
-
- /* Let the row go over the full width of the frame. */
- row->full_width_p = true;
-
- row_width = row->pixel_width;
- if (row->used[TEXT_AREA])
- {
- /* There's a glyph at the end of rows that is used to place
- the cursor there. Don't include the width of this glyph. */
- if (!row->reversed_p)
- {
- last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
- if (NILP (last->object))
- row_width -= last->pixel_width;
- }
- else
- {
- /* There could be a stretch glyph at the beginning of R2L
- rows that is produced by extend_face_to_end_of_line.
- Don't count that glyph. */
- struct glyph *g = row->glyphs[TEXT_AREA];
-
- if (g->type == STRETCH_GLYPH && NILP (g->object))
- {
- row_width -= g->pixel_width;
- seen_reversed_p = true;
- }
- }
- }
-
- height += row->height;
- width = max (width, row_width);
- }
-
- /* If we've seen partial-length R2L rows, we need to re-adjust the
- tool-tip frame width and redisplay it again, to avoid over-wide
- tips due to the stretch glyph that extends R2L lines to full
- width of the frame. */
- if (seen_reversed_p)
- {
- /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
- not in pixels. */
- w->pixel_width = width;
- width /= WINDOW_FRAME_COLUMN_WIDTH (w);
- w->total_cols = width;
- FRAME_TOTAL_COLS (f) = width;
- SET_FRAME_WIDTH (f, width);
- adjust_frame_glyphs (f);
- clear_glyph_matrix (w->desired_matrix);
- clear_glyph_matrix (w->current_matrix);
- try_window (FRAME_ROOT_WINDOW (f), pos, 0);
- width = height = 0;
- /* Recompute width and height of the tooltip. */
- for (i = 0; i < w->desired_matrix->nrows; ++i)
- {
- struct glyph_row *row = &w->desired_matrix->rows[i];
- struct glyph *last;
- int row_width;
-
- if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
- break;
- row->full_width_p = true;
- row_width = row->pixel_width;
- if (row->used[TEXT_AREA] && !row->reversed_p)
- {
- last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
- if (NILP (last->object))
- row_width -= last->pixel_width;
- }
-
- height += row->height;
- width = max (width, row_width);
- }
- }
-
- /* Add the frame's internal border to the width and height the X
- window should have. */
- height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
- width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
-
- /* Move the tooltip window where the mouse pointer is. Resize and
- show it. */
- compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
-
+ try_window (window, pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
+ /* Calculate size of tooltip window. */
+ size = Fwindow_text_pixel_size (window, Qnil, Qnil, Qnil,
+ make_number (w->pixel_height), Qnil);
+ /* Add the frame's internal border to calculated size. */
+ width = XINT (Fcar (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
+ height = XINT (Fcdr (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
+
+ /* Calculate position of tooltip frame. */
+ compute_tip_xy (tip_f, parms, dx, dy, width, height, &root_x, &root_y);
+
+ /* Show tooltip frame. */
block_input ();
- XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+ XMoveResizeWindow (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f),
root_x, root_y, width, height);
- XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
+ XMapRaised (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f));
unblock_input ();
- /* Draw into the window. */
w->must_be_updated_p = true;
update_single_window (w);
-
- /* Restore original current buffer. */
set_buffer_internal_1 (old_buffer);
+ unbind_to (count_1, Qnil);
windows_or_buffers_changed = old_windows_or_buffers_changed;
start_timer:
- /* Let the tip disappear after timeout seconds. */
- tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
- intern ("x-hide-tip"));
-
+ {
+ /* Let the tip disappear after timeout seconds. */
+ AUTO_FRAME_ARG (arg, Qtooltip_timer,
+ call3 (intern ("run-at-time"), timeout,
+ Qnil, intern ("x-hide-tip")));
+ Fmodify_frame_parameters (tip_frame, arg);
+ }
return unbind_to (count, Qnil);
}
-
-DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
+DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 1, 0,
doc: /* Hide the current tooltip window, if there is any.
+Optional FRAME is the frame to hide tooltip on.
Value is t if tooltip was open, nil otherwise. */)
- (void)
+ (Lisp_Object frame)
{
- ptrdiff_t count;
- Lisp_Object deleted, frame, timer;
-
- /* Return quickly if nothing to do. */
- if (NILP (tip_timer) && NILP (tip_frame))
- return Qnil;
-
- frame = tip_frame;
- timer = tip_timer;
- tip_frame = tip_timer = deleted = Qnil;
-
- count = SPECPDL_INDEX ();
- specbind (Qinhibit_redisplay, Qt);
- specbind (Qinhibit_quit, Qt);
-
- if (!NILP (timer))
- call1 (Qcancel_timer, timer);
+ Lisp_Object obj = Qnil;
#ifdef USE_GTK
- {
- /* When using system tooltip, tip_frame is the Emacs frame on which
- the tip is shown. */
- struct frame *f = XFRAME (frame);
- if (FRAME_LIVE_P (f) && xg_hide_tooltip (f))
- frame = Qnil;
- }
-#endif
-
- if (FRAMEP (frame))
+ if (x_gtk_use_system_tooltips)
{
- delete_frame (frame, Qnil);
- deleted = Qt;
+ if (NILP (frame))
+ {
+ Lisp_Object tail, frame;
-#ifdef USE_LUCID
- /* Bloodcurdling hack alert: The Lucid menu bar widget's
- redisplay procedure is not called when a tip frame over menu
- items is unmapped. Redisplay the menu manually... */
- {
- Widget w;
- struct frame *f = SELECTED_FRAME ();
- w = f->output_data.x->menubar_widget;
+ FOR_EACH_FRAME (tail, frame)
+ if (FRAME_X_P (XFRAME (frame)))
+ if (xg_hide_tooltip (XFRAME (frame)))
+ obj = Qt;
+ }
+ else
+ {
+ CHECK_FRAME (frame);
+ if (FRAME_X_P (XFRAME (frame)))
+ if (xg_hide_tooltip (XFRAME (frame)))
+ obj = Qt;
+ }
+ return obj;
+ }
+#endif /* USE_GTK */
- if (!DoesSaveUnders (FRAME_DISPLAY_INFO (f)->screen)
- && w != NULL)
- {
- block_input ();
- xlwmenu_redisplay (w);
- unblock_input ();
- }
- }
-#endif /* USE_LUCID */
+ if (NILP (frame))
+ {
+ struct x_display_info *dpyinfo;
+
+ for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
+ if (dpyinfo->x_tooltip_frame)
+ if (!NILP (x_hide_tip (dpyinfo->x_tooltip_frame,
+ !tooltip_reuse_hidden_frame)))
+ obj = Qt;
}
+ else
+ {
+ struct frame *f;
- return unbind_to (count, deleted);
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+ if (FRAME_DISPLAY_INFO (f)
+ && FRAME_DISPLAY_INFO (f)->x_tooltip_frame)
+ obj = x_hide_tip (FRAME_DISPLAY_INFO (f)->x_tooltip_frame,
+ !tooltip_reuse_hidden_frame);
+ }
+ return obj;
}
-
\f
/***********************************************************************
File selection dialog
default_name = xlispstrdup (font_param);
else
{
- font_param = Fframe_parameter (frame, Qfont_param);
+ font_param = Fframe_parameter (frame, Qfont_parameter);
if (STRINGP (font_param))
default_name = xlispstrdup (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 (Qundefined_color, "undefined-color");
DEFSYM (Qcompound_text, "compound-text");
DEFSYM (Qcancel_timer, "cancel-timer");
- DEFSYM (Qfont_param, "font-parameter");
+ DEFSYM (Qfont_parameter, "font-parameter");
DEFSYM (Qmono, "mono");
+ DEFSYM (Qassq_delete_all, "assq-delete-all");
#ifdef USE_CAIRO
+ DEFSYM (Qpdf, "pdf");
+
DEFSYM (Qorientation, "orientation");
DEFSYM (Qtop_margin, "top-margin");
DEFSYM (Qbottom_margin, "bottom-margin");
defsubr (&Sx_show_tip);
defsubr (&Sx_hide_tip);
- tip_timer = Qnil;
- staticpro (&tip_timer);
- tip_frame = Qnil;
- staticpro (&tip_frame);
-
- last_show_tip_args = Qnil;
- staticpro (&last_show_tip_args);
defsubr (&Sx_uses_old_gtk_dialog);
#if defined (USE_MOTIF) || defined (USE_GTK)