/* X Communication module for terminals which understand the X protocol.
Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GNU Emacs.
-GNU Emacs is free software; you can redistribute it and/or modify
+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, 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
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
/* New display code by Gerd Moellmann <gerd@gnu.org>. */
/* Xt features made by Fred Pierresteguy. */
#include <signal.h>
#include <stdio.h>
+#include <setjmp.h>
#ifdef HAVE_X_WINDOWS
#include "charset.h"
#include "character.h"
#include "coding.h"
-#include "ccl.h"
#include "frame.h"
#include "dispextern.h"
#include "fontset.h"
#include "process.h"
#include "atimer.h"
#include "keymap.h"
+#include "font.h"
+#include "fontset.h"
+#include "xsettings.h"
+#include "sysselect.h"
#ifdef USE_X_TOOLKIT
#include <X11/Shell.h>
#include "gtkutil.h"
#endif
-#ifdef USE_FONT_BACKEND
-#include "font.h"
-#endif /* USE_FONT_BACKEND */
-
#ifdef USE_LUCID
extern int xlwmenu_window_p P_ ((Widget w, Window window));
extern void xlwmenu_redisplay P_ ((Widget));
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
extern void free_frame_menubar P_ ((struct frame *));
-extern struct frame *x_menubar_window_to_frame P_ ((struct x_display_info *,
- int));
#endif
#ifdef USE_X_TOOLKIT
-#if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
+#if !defined(NO_EDITRES)
#define HACK_EDITRES
extern void _XEditResCheckMessages ();
#endif /* not NO_EDITRES */
#endif /* USE_X_TOOLKIT */
-#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
-#define x_any_window_to_frame x_window_to_frame
-#define x_top_window_to_frame x_window_to_frame
-#endif
-
#ifdef USE_X_TOOLKIT
#include "widget.h"
#ifndef XtNinitialState
/* This is a frame waiting to be auto-raised, within XTread_socket. */
-struct frame *pending_autoraise_frame;
+static struct frame *pending_autoraise_frame;
+
+/* This is a frame waiting for an event matching mask, within XTread_socket. */
+
+static struct {
+ struct frame *f;
+ int eventtype;
+} pending_event_wait;
#ifdef USE_X_TOOLKIT
/* The application context for Xt use. */
static Lisp_Object Qvendor_specific_keysyms;
static Lisp_Object Qlatin_1;
+#ifdef USE_GTK
+/* The name of the Emacs icon file. */
+static Lisp_Object xg_default_icon_file;
+
+/* Used in gtkutil.c. */
+Lisp_Object Qx_gtk_map_stock;
+#endif
+
/* Used in x_flush. */
extern Lisp_Object Vinhibit_redisplay;
static int x_io_error_quitter P_ ((Display *));
static struct terminal *x_create_terminal P_ ((struct x_display_info *));
void x_delete_terminal P_ ((struct terminal *));
-static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
-static int x_compute_min_glyph_bounds P_ ((struct frame *));
static void x_update_end P_ ((struct frame *));
static void XTframe_up_to_date P_ ((struct frame *));
static void XTset_terminal_modes P_ ((struct terminal *));
enum scroll_bar_part *,
Lisp_Object *, Lisp_Object *,
unsigned long *));
+static void x_handle_net_wm_state P_ ((struct frame *, XPropertyEvent *));
static void x_check_fullscreen P_ ((struct frame *));
static void x_check_expected_move P_ ((struct frame *, int, int));
static void x_sync_with_move P_ ((struct frame *, int, int, int));
return 0;
}
+#define OPAQUE 0xffffffff
+#define OPACITY "_NET_WM_WINDOW_OPACITY"
+
+void
+x_set_frame_alpha (f)
+ struct frame *f;
+{
+ struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ Display *dpy = FRAME_X_DISPLAY (f);
+ Window win = FRAME_OUTER_WINDOW (f);
+ double alpha = 1.0;
+ double alpha_min = 1.0;
+ unsigned long opac;
+
+ if (FRAME_X_DISPLAY_INFO (f)->root_window != FRAME_X_OUTPUT (f)->parent_desc)
+ /* Since the WM decoration lies under the FRAME_OUTER_WINDOW,
+ we must treat the former instead of the latter. */
+ win = FRAME_X_OUTPUT(f)->parent_desc;
+
+ if (dpyinfo->x_highlight_frame == f)
+ alpha = f->alpha[0];
+ else
+ alpha = f->alpha[1];
+
+ if (FLOATP (Vframe_alpha_lower_limit))
+ alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
+ else if (INTEGERP (Vframe_alpha_lower_limit))
+ alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
+
+ if (alpha < 0.0)
+ return;
+ else if (alpha > 1.0)
+ alpha = 1.0;
+ else if (0.0 <= alpha && alpha < alpha_min && alpha_min <= 1.0)
+ alpha = alpha_min;
+
+ opac = alpha * OPAQUE;
+
+ /* return unless necessary */
+ {
+ unsigned char *data;
+ Atom actual;
+ int rc, format;
+ unsigned long n, left;
+
+ x_catch_errors (dpy);
+ rc = XGetWindowProperty(dpy, win, XInternAtom(dpy, OPACITY, False),
+ 0L, 1L, False, XA_CARDINAL,
+ &actual, &format, &n, &left,
+ &data);
+
+ if (rc == Success && actual != None)
+ if (*(unsigned long *)data == opac)
+ {
+ XFree ((void *) data);
+ x_uncatch_errors ();
+ return;
+ }
+ else
+ XFree ((void *) data);
+ x_uncatch_errors ();
+ }
+
+ x_catch_errors (dpy);
+ XChangeProperty (dpy, win, XInternAtom (dpy, OPACITY, False),
+ XA_CARDINAL, 32, PropModeReplace,
+ (unsigned char *) &opac, 1L);
+ x_uncatch_errors ();
+}
+
+int
+x_display_pixel_height (dpyinfo)
+ struct x_display_info *dpyinfo;
+{
+ return HeightOfScreen (dpyinfo->screen);
+}
+
+int
+x_display_pixel_width (dpyinfo)
+ struct x_display_info *dpyinfo;
+{
+ return WidthOfScreen (dpyinfo->screen);
+}
\f
/***********************************************************************
highlighting. */
if (FRAME_GARBAGED_P (f))
display_info->mouse_face_window = Qnil;
-
-#if 0 /* Rows in a current matrix containing glyphs in mouse-face have
- their mouse_face_p flag set, which means that they are always
- unequal to rows in a desired matrix which never have that
- flag set. So, rows containing mouse-face glyphs are never
- scrolled, and we don't have to switch the mouse highlight off
- here to prevent it from being scrolled. */
-
- /* Can we tell that this update does not affect the window
- where the mouse highlight is? If so, no need to turn off.
- Likewise, don't do anything if the frame is garbaged;
- in that case, the frame's current matrix that we would use
- is all wrong, and we will redisplay that line anyway. */
- if (!NILP (display_info->mouse_face_window)
- && w == XWINDOW (display_info->mouse_face_window))
- {
- int i;
-
- for (i = 0; i < w->desired_matrix->nrows; ++i)
- if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
- break;
-
- if (i < w->desired_matrix->nrows)
- clear_mouse_face (display_info);
- }
-#endif /* 0 */
}
UNBLOCK_INPUT;
{
}
-
-\f
-/***********************************************************************
- Display Iterator
- ***********************************************************************/
-
-/* Function prototypes of this page. */
-
-static int x_encode_char P_ ((int, XChar2b *, struct font_info *,
- struct charset *, int *));
-
-
-/* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
- is not contained in the font. */
-
-static XCharStruct *
-x_per_char_metric (font, char2b, font_type)
- XFontStruct *font;
- XChar2b *char2b;
- int font_type; /* unused on X */
-{
- /* The result metric information. */
- XCharStruct *pcm = NULL;
-
- xassert (font && char2b);
-
- if (font->per_char != NULL)
- {
- if (font->min_byte1 == 0 && font->max_byte1 == 0)
- {
- /* min_char_or_byte2 specifies the linear character index
- corresponding to the first element of the per_char array,
- max_char_or_byte2 is the index of the last character. A
- character with non-zero CHAR2B->byte1 is not in the font.
- A character with byte2 less than min_char_or_byte2 or
- greater max_char_or_byte2 is not in the font. */
- if (char2b->byte1 == 0
- && char2b->byte2 >= font->min_char_or_byte2
- && char2b->byte2 <= font->max_char_or_byte2)
- pcm = font->per_char + char2b->byte2 - font->min_char_or_byte2;
- }
- else
- {
- /* If either min_byte1 or max_byte1 are nonzero, both
- min_char_or_byte2 and max_char_or_byte2 are less than
- 256, and the 2-byte character index values corresponding
- to the per_char array element N (counting from 0) are:
-
- byte1 = N/D + min_byte1
- byte2 = N\D + min_char_or_byte2
-
- where:
-
- D = max_char_or_byte2 - min_char_or_byte2 + 1
- / = integer division
- \ = integer modulus */
- if (char2b->byte1 >= font->min_byte1
- && char2b->byte1 <= font->max_byte1
- && char2b->byte2 >= font->min_char_or_byte2
- && char2b->byte2 <= font->max_char_or_byte2)
- {
- pcm = (font->per_char
- + ((font->max_char_or_byte2 - font->min_char_or_byte2 + 1)
- * (char2b->byte1 - font->min_byte1))
- + (char2b->byte2 - font->min_char_or_byte2));
- }
- }
- }
- else
- {
- /* If the per_char pointer is null, all glyphs between the first
- and last character indexes inclusive have the same
- information, as given by both min_bounds and max_bounds. */
- if (char2b->byte2 >= font->min_char_or_byte2
- && char2b->byte2 <= font->max_char_or_byte2)
- pcm = &font->max_bounds;
- }
-
- return ((pcm == NULL
- || (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0))
- ? NULL : pcm);
-}
-
-
-/* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
- the two-byte form of C. Encoding is returned in *CHAR2B. */
-
-static int
-x_encode_char (c, char2b, font_info, charset, two_byte_p)
- int c;
- XChar2b *char2b;
- struct font_info *font_info;
- struct charset *charset;
- int *two_byte_p;
-{
- XFontStruct *font = font_info->font;
-
- /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
- This may be either a program in a special encoder language or a
- fixed encoding. */
- if (font_info->font_encoder)
- {
- /* It's a program. */
- struct ccl_program *ccl = font_info->font_encoder;
-
- check_ccl_update (ccl);
- if (CHARSET_DIMENSION (charset) == 1)
- {
- ccl->reg[0] = CHARSET_ID (charset);
- ccl->reg[1] = char2b->byte2;
- ccl->reg[2] = -1;
- }
- else
- {
- ccl->reg[0] = CHARSET_ID (charset);
- ccl->reg[1] = char2b->byte1;
- ccl->reg[2] = char2b->byte2;
- }
-
- ccl_driver (ccl, NULL, NULL, 0, 0, Qnil);
-
- /* We assume that MSBs are appropriately set/reset by CCL
- program. */
- if (font->max_byte1 == 0) /* 1-byte font */
- STORE_XCHAR2B (char2b, 0, ccl->reg[1]);
- else
- STORE_XCHAR2B (char2b, ccl->reg[1], ccl->reg[2]);
- }
- else if (font_info->encoding_type)
- {
- /* Fixed encoding scheme. See fontset.h for the meaning of the
- encoding numbers. */
- unsigned char enc = font_info->encoding_type;
-
- if ((enc == 1 || enc == 2)
- && CHARSET_DIMENSION (charset) == 2)
- char2b->byte1 |= 0x80;
-
- if (enc == 1 || enc == 3)
- char2b->byte2 |= 0x80;
- }
-
- if (two_byte_p)
- *two_byte_p = ((XFontStruct *) (font_info->font))->max_byte1 > 0;
-
- return FONT_TYPE_UNKNOWN;
-}
-
-
\f
/***********************************************************************
Glyph display
int, int, int, XRectangle *));
#if GLYPH_DEBUG
-static void x_check_font P_ ((struct frame *, XFontStruct *));
+static void x_check_font P_ ((struct frame *, struct font *));
#endif
}
IF_DEBUG (x_check_font (s->f, s->font));
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- xgcv.font = FRAME_X_DISPLAY_INFO (s->f)->font->fid;
- else
-#endif
- xgcv.font = s->font->fid;
xgcv.graphics_exposures = False;
- mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
+ mask = GCForeground | GCBackground | GCGraphicsExposures;
if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
s->face = FACE_FROM_ID (s->f, face_id);
PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
- /* If font in this face is same as S->font, use it. */
if (s->font == s->face->font)
s->gc = s->face->gc;
-#ifdef USE_FONT_BACKEND
- else if (enable_font_backend)
- /* No need of setting a font for s->gc. */
- s->gc = s->face->gc;
-#endif /* USE_FONT_BACKEND */
else
{
/* Otherwise construct scratch_cursor_gc with values from FACE
- but font FONT. */
+ except for FONT. */
XGCValues xgcv;
unsigned long mask;
xgcv.background = s->face->background;
xgcv.foreground = s->face->foreground;
- IF_DEBUG (x_check_font (s->f, s->font));
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- xgcv.font = FRAME_X_DISPLAY_INFO (s->f)->font->fid;
- else
-#endif
- xgcv.font = s->font->fid;
xgcv.graphics_exposures = False;
- mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
+ mask = GCForeground | GCBackground | GCGraphicsExposures;
if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
= XCreateGC (s->display, s->window, mask, &xgcv);
s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
- }
+ }
xassert (s->gc != 0);
}
x_set_glyph_string_clipping (s)
struct glyph_string *s;
{
-#ifdef USE_FONT_BACKEND
XRectangle *r = s->clip;
-#else
- XRectangle r[2];
-#endif
int n = get_glyph_string_clip_rects (s, r, 2);
if (n > 0)
XSetClipRectangles (s->display, s->gc, 0, 0, r, n, Unsorted);
-#ifdef USE_FONT_BACKEND
s->num_clips = n;
-#endif
}
{
XRectangle r;
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- {
- r.x = src->x;
- r.width = src->width;
- r.y = src->y;
- r.height = src->height;
- dst->clip[0] = r;
- dst->num_clips = 1;
- }
- else
- {
-#endif /* USE_FONT_BACKEND */
- struct glyph_string *clip_head = src->clip_head;
- struct glyph_string *clip_tail = src->clip_tail;
-
- /* This foces clipping just this glyph string. */
- src->clip_head = src->clip_tail = src;
- get_glyph_string_clip_rect (src, &r);
- src->clip_head = clip_head, src->clip_tail = clip_tail;
-#ifdef USE_FONT_BACKEND
- }
-#endif /* USE_FONT_BACKEND */
+ r.x = src->x;
+ r.width = src->width;
+ r.y = src->y;
+ r.height = src->height;
+ dst->clip[0] = r;
+ dst->num_clips = 1;
XSetClipRectangles (dst->display, dst->gc, 0, 0, &r, 1, Unsorted);
}
struct glyph_string *s;
{
if (s->cmp == NULL
- && s->first_glyph->type == CHAR_GLYPH)
+ && (s->first_glyph->type == CHAR_GLYPH
+ || s->first_glyph->type == COMPOSITE_GLYPH))
{
- XCharStruct cs;
- int direction, font_ascent, font_descent;
+ struct font_metrics metrics;
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
+ if (s->first_glyph->type == CHAR_GLYPH)
{
unsigned *code = alloca (sizeof (unsigned) * s->nchars);
- struct font *font = (struct font *) s->font_info;
- struct font_metrics metrics;
+ struct font *font = s->font;
int i;
for (i = 0; i < s->nchars; i++)
code[i] = (s->char2b[i].byte1 << 8) | s->char2b[i].byte2;
font->driver->text_extents (font, code, s->nchars, &metrics);
- cs.rbearing = metrics.rbearing;
- cs.lbearing = metrics.lbearing;
- cs.width = metrics.width;
}
else
-#endif /* USE_FONT_BACKEND */
- XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
- &font_ascent, &font_descent, &cs);
- s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
- s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
+ {
+ Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
+
+ composition_gstring_width (gstring, s->cmp_from, s->cmp_to, &metrics);
+ }
+ s->right_overhang = (metrics.rbearing > metrics.width
+ ? metrics.rbearing - metrics.width : 0);
+ s->left_overhang = metrics.lbearing < 0 ? - metrics.lbearing : 0;
}
else if (s->cmp)
{
x += g->pixel_width;
}
}
-#ifdef USE_FONT_BACKEND
- else if (enable_font_backend)
+ else
{
- int boff = s->font_info->baseline_offset;
- struct font *font = (struct font *) s->font_info;
+ struct font *font = s->font;
+ int boff = font->baseline_offset;
int y;
- if (s->font_info->vertical_centering)
- boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
+ if (font->vertical_centering)
+ boff = VCENTER_BASELINE_OFFSET (font, s->f) - boff;
y = s->ybase - boff;
if (s->for_overlaps
if (s->face->overstrike)
font->driver->draw (s, 0, s->nchars, x + 1, y, 0);
}
-#endif /* USE_FONT_BACKEND */
- else
- {
- char *char1b = (char *) s->char2b;
- int boff = s->font_info->baseline_offset;
-
- if (s->font_info->vertical_centering)
- boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
-
- /* If we can use 8-bit functions, condense S->char2b. */
- if (!s->two_byte_p)
- for (i = 0; i < s->nchars; ++i)
- char1b[i] = s->char2b[i].byte2;
-
- /* Draw text with XDrawString if background has already been
- filled. Otherwise, use XDrawImageString. (Note that
- XDrawImageString is usually faster than XDrawString.) Always
- use XDrawImageString when drawing the cursor so that there is
- no chance that characters under a box cursor are invisible. */
- if (s->for_overlaps
- || (s->background_filled_p && s->hl != DRAW_CURSOR))
- {
- /* Draw characters with 16-bit or 8-bit functions. */
- if (s->two_byte_p)
- XDrawString16 (s->display, s->window, s->gc, x,
- s->ybase - boff, s->char2b, s->nchars);
- else
- XDrawString (s->display, s->window, s->gc, x,
- s->ybase - boff, char1b, s->nchars);
- }
- else
- {
- if (s->two_byte_p)
- XDrawImageString16 (s->display, s->window, s->gc, x,
- s->ybase - boff, s->char2b, s->nchars);
- else
- XDrawImageString (s->display, s->window, s->gc, x,
- s->ybase - boff, char1b, s->nchars);
- }
-
- if (s->face->overstrike)
- {
- /* For overstriking (to simulate bold-face), draw the
- characters again shifted to the right by one pixel. */
- if (s->two_byte_p)
- XDrawString16 (s->display, s->window, s->gc, x + 1,
- s->ybase - boff, s->char2b, s->nchars);
- else
- XDrawString (s->display, s->window, s->gc, x + 1,
- s->ybase - boff, char1b, s->nchars);
- }
- }
}
/* Draw the foreground of composite glyph string S. */
struct glyph_string *s;
{
int i, j, x;
+ struct font *font = s->font;
/* If first glyph of S has a left box line, start drawing the text
of S to the right of that box line. */
else
x = s->x;
- /* S is a glyph string for a composition. S->gidx is the index of
- the first character drawn for glyphs of this composition.
- S->gidx == 0 means we are drawing the very first character of
+ /* S is a glyph string for a composition. S->cmp_from is the index
+ of the first character drawn for glyphs of this composition.
+ S->cmp_from == 0 means we are drawing the very first character of
this composition. */
/* Draw a rectangle for the composition if the font for the very
first character of the composition could not be loaded. */
if (s->font_not_found_p)
{
- if (s->gidx == 0)
+ if (s->cmp_from == 0)
XDrawRectangle (s->display, s->window, s->gc, x, s->y,
s->width - 1, s->height - 1);
}
-#ifdef USE_FONT_BACKEND
- else if (enable_font_backend)
+ else if (! s->first_glyph->u.cmp.automatic)
+ {
+ int y = s->ybase;
+
+ for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
+ if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
+ {
+ int xx = x + s->cmp->offsets[j * 2];
+ int yy = y - s->cmp->offsets[j * 2 + 1];
+
+ font->driver->draw (s, j, j + 1, xx, yy, 0);
+ if (s->face->overstrike)
+ font->driver->draw (s, j, j + 1, xx + 1, yy, 0);
+ }
+ }
+ else
{
- struct font *font = (struct font *) s->font_info;
+ Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
+ Lisp_Object glyph;
int y = s->ybase;
int width = 0;
- if (s->cmp->method == COMPOSITION_WITH_GLYPH_STRING)
+ for (i = j = s->cmp_from; i < s->cmp_to; i++)
{
- Lisp_Object gstring = AREF (XHASH_TABLE (composition_hash_table)
- ->key_and_value,
- s->cmp->hash_index * 2);
- int from;
-
- for (i = from = 0; i < s->nchars; i++)
+ glyph = LGSTRING_GLYPH (gstring, i);
+ if (NILP (LGLYPH_ADJUSTMENT (glyph)))
+ width += LGLYPH_WIDTH (glyph);
+ else
{
- Lisp_Object g = LGSTRING_GLYPH (gstring, i);
- Lisp_Object adjustment = LGLYPH_ADJUSTMENT (g);
int xoff, yoff, wadjust;
- if (! VECTORP (adjustment))
- {
- width += LGLYPH_WIDTH (g);
- continue;
- }
- if (from < i)
+ if (j < i)
{
- font->driver->draw (s, from, i, x, y, 0);
+ font->driver->draw (s, j, i, x, y, 0);
x += width;
}
- xoff = XINT (AREF (adjustment, 0));
- yoff = XINT (AREF (adjustment, 1));
- wadjust = XINT (AREF (adjustment, 2));
-
+ xoff = LGLYPH_XOFF (glyph);
+ yoff = LGLYPH_YOFF (glyph);
+ wadjust = LGLYPH_WADJUST (glyph);
font->driver->draw (s, i, i + 1, x + xoff, y + yoff, 0);
x += wadjust;
- from = i + 1;
+ j = i + 1;
width = 0;
}
- if (from < i)
- font->driver->draw (s, from, i, x, y, 0);
- }
- else
- {
- for (i = 0, j = s->gidx; i < s->nchars; i++, j++)
- if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
- {
- int xx = x + s->cmp->offsets[j * 2];
- int yy = y - s->cmp->offsets[j * 2 + 1];
-
- font->driver->draw (s, j, j + 1, xx, yy, 0);
- if (s->face->overstrike)
- font->driver->draw (s, j, j + 1, xx + 1, yy, 0);
- }
}
- }
-#endif /* USE_FONT_BACKEND */
- else
- {
- for (i = 0, j = s->gidx; i < s->nchars; i++, j++)
- if (s->face)
- {
- XDrawString16 (s->display, s->window, s->gc,
- x + s->cmp->offsets[j * 2],
- s->ybase - s->cmp->offsets[j * 2 + 1],
- s->char2b + j, 1);
- if (s->face->overstrike)
- XDrawString16 (s->display, s->window, s->gc,
- x + s->cmp->offsets[j * 2] + 1,
- s->ybase - s->cmp->offsets[j * 2 + 1],
- s->char2b + j, 1);
- }
+ if (j < i)
+ font->driver->draw (s, j, i, x, y, 0);
}
}
int width;
struct glyph_string *next;
- for (width = 0, next = s->next; next;
+ for (width = 0, next = s->next;
+ next && width < s->right_overhang;
width += next->width, next = next->next)
if (next->first_glyph->type != IMAGE_GLYPH)
{
x_set_glyph_string_gc (next);
x_set_glyph_string_clipping (next);
- x_draw_glyph_string_background (next, 1);
-#ifdef USE_FONT_BACKEND
+ if (next->first_glyph->type == STRETCH_GLYPH)
+ x_draw_stretch_glyph_string (next);
+ else
+ x_draw_glyph_string_background (next, 1);
next->num_clips = 0;
-#endif /* USE_FONT_BACKEND */
}
}
x_set_glyph_string_clipping (s);
relief_drawn_p = 1;
}
- else if ((s->prev && s->prev->hl != s->hl && s->left_overhang)
- || (s->next && s->next->hl != s->hl && s->right_overhang))
+ else if (!s->clip_head /* draw_glyphs didn't specify a clip mask. */
+ && !s->clip_tail
+ && ((s->prev && s->prev->hl != s->hl && s->left_overhang)
+ || (s->next && s->next->hl != s->hl && s->right_overhang)))
/* We must clip just this glyph. left_overhang part has already
drawn when s->prev was drawn, and right_overhang part will be
drawn later when s->next is drawn. */
break;
case COMPOSITE_GLYPH:
- if (s->for_overlaps || s->gidx > 0)
+ if (s->for_overlaps || (s->cmp_from > 0
+ && ! s->first_glyph->u.cmp.automatic))
s->background_filled_p = 1;
else
x_draw_glyph_string_background (s, 1);
/* Draw underline. */
if (s->face->underline_p)
{
- unsigned long tem, h;
+ unsigned long thickness, position;
int y;
- /* Get the underline thickness. Default is 1 pixel. */
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- /* In the future, we must use information of font. */
- h = 1;
- else
-#endif /* USE_FONT_BACKEND */
- if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
- h = 1;
-
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
+ if (s->prev && s->prev->face->underline_p)
{
- if (s->face->font)
- /* In the future, we must use information of font. */
- y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
- else
- y = s->y + s->height - h;
+ /* We use the same underline style as the previous one. */
+ thickness = s->prev->underline_thickness;
+ position = s->prev->underline_position;
}
else
-#endif
{
- y = s->y + s->height - h;
- if (!x_underline_at_descent_line)
+ /* Get the underline thickness. Default is 1 pixel. */
+ if (s->font && s->font->underline_thickness > 0)
+ thickness = s->font->underline_thickness;
+ else
+ thickness = 1;
+ if (x_underline_at_descent_line)
+ position = (s->height - thickness) - (s->ybase - s->y);
+ else
{
/* Get the underline position. This is the recommended
vertical offset in pixels from the baseline to the top of
ROUND(x) = floor (x + 0.5) */
if (x_use_underline_position_properties
- && XGetFontProperty (s->font, XA_UNDERLINE_POSITION, &tem))
- y = s->ybase + (long) tem;
- else if (s->face->font)
- y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
+ && s->font && s->font->underline_position >= 0)
+ position = s->font->underline_position;
+ else if (s->font)
+ position = (s->font->descent + 1) / 2;
+ else
+ position = underline_minimum_offset;
}
+ position = max (position, underline_minimum_offset);
}
-
+ /* Check the sanity of thickness and position. We should
+ avoid drawing underline out of the current line area. */
+ if (s->y + s->height <= s->ybase + position)
+ position = (s->height - 1) - (s->ybase - s->y);
+ if (s->y + s->height < s->ybase + position + thickness)
+ thickness = (s->y + s->height) - (s->ybase + position);
+ s->underline_thickness = thickness;
+ s->underline_position = position;
+ y = s->ybase + position;
if (s->face->underline_defaulted_p)
XFillRectangle (s->display, s->window, s->gc,
- s->x, y, s->background_width, h);
+ s->x, y, s->width, thickness);
else
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
XSetForeground (s->display, s->gc, s->face->underline_color);
XFillRectangle (s->display, s->window, s->gc,
- s->x, y, s->background_width, h);
+ s->x, y, s->width, thickness);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
if (s->face->overline_color_defaulted_p)
XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
- s->background_width, h);
+ s->width, h);
else
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
XSetForeground (s->display, s->gc, s->face->overline_color);
XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
- s->background_width, h);
+ s->width, h);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
x_draw_composite_glyph_string_foreground (prev);
XSetClipMask (prev->display, prev->gc, None);
prev->hl = save;
-#ifdef USE_FONT_BACKEND
prev->num_clips = 0;
-#endif /* USE_FONT_BACKEND */
}
}
x_draw_composite_glyph_string_foreground (next);
XSetClipMask (next->display, next->gc, None);
next->hl = save;
-#ifdef USE_FONT_BACKEND
next->num_clips = 0;
-#endif /* USE_FONT_BACKEND */
}
}
}
/* Reset clipping. */
XSetClipMask (s->display, s->gc, None);
-#ifdef USE_FONT_BACKEND
s->num_clips = 0;
-#endif /* USE_FONT_BACKEND */
}
/* Shift display to make room for inserted glyphs. */
#endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
+static void
+XTtoggle_invisible_pointer (f, invisible)
+ FRAME_PTR f;
+ int invisible;
+{
+ BLOCK_INPUT;
+ if (invisible)
+ {
+ if (FRAME_X_DISPLAY_INFO (f)->invisible_cursor != 0)
+ XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+ FRAME_X_DISPLAY_INFO (f)->invisible_cursor);
+ }
+ else
+ XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+ f->output_data.x->current_cursor);
+ f->pointer_invisible = invisible;
+ UNBLOCK_INPUT;
+}
+
+
/* Make audible bell. */
void
f->output_data.x->border_pixel);
UNBLOCK_INPUT;
x_update_cursor (f, 1);
+ x_set_frame_alpha (f);
}
static void
f->output_data.x->border_tile);
UNBLOCK_INPUT;
x_update_cursor (f, 1);
+ x_set_frame_alpha (f);
}
/* The focus has changed. Update the frames as necessary to reflect
if (old_focus && old_focus->auto_lower)
x_lower_frame (old_focus);
-#if 0
- selected_frame = frame;
- XSETFRAME (XWINDOW (selected_frame->selected_window)->frame,
- selected_frame);
- Fselect_window (selected_frame->selected_window, Qnil);
- choose_minibuf_frame ();
-#endif /* ! 0 */
-
if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
pending_autoraise_frame = dpyinfo->x_focus_frame;
else
if (FRAME_XIC (frame))
XUnsetICFocus (FRAME_XIC (frame));
#endif
+ if (frame->pointer_invisible)
+ XTtoggle_invisible_pointer (frame, 0);
}
}
if (child == None || child == win)
break;
-
+#ifdef USE_GTK
+ /* We don't wan't to know the innermost window. We
+ want the edit window. For non-Gtk+ the innermost
+ window is the edit window. For Gtk+ it might not
+ be. It might be the tool bar for example. */
+ if (x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win))
+ break;
+#endif
win = child;
parent_x = win_x;
parent_y = win_y;
parent_{x,y} are invalid, but that's okay, because we'll
never use them in that case.) */
+#ifdef USE_GTK
+ /* We don't wan't to know the innermost window. We
+ want the edit window. */
+ f1 = x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
+#else
/* Is win one of our frames? */
f1 = x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
+#endif
#ifdef USE_X_TOOLKIT
/* If we end up with the menu bar window, say it's not
if (! FRAME_X_P (XFRAME (frame)))
continue;
-
+
/* Scan this frame's scroll bar list for a scroll bar with the
right window ID. */
condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
/* Set the cursor to an arrow. I didn't find a resource to do that.
And I'm wondering why it hasn't an arrow cursor by default. */
XDefineCursor (XtDisplay (widget), XtWindow (widget),
- f->output_data.x->nontext_cursor);
+ f->output_data.x->nontext_cursor);
#else /* !USE_MOTIF i.e. use Xaw */
if (f->output_data.x->scroll_bar_top_shadow_pixel == -1)
{
pixel = f->output_data.x->scroll_bar_background_pixel;
- if (!x_alloc_lighter_color (f, FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
- &pixel, 1.2, 0x8000))
- pixel = -1;
- f->output_data.x->scroll_bar_top_shadow_pixel = pixel;
+ if (pixel != -1)
+ {
+ if (!x_alloc_lighter_color (f, FRAME_X_DISPLAY (f),
+ FRAME_X_COLORMAP (f),
+ &pixel, 1.2, 0x8000))
+ pixel = -1;
+ f->output_data.x->scroll_bar_top_shadow_pixel = pixel;
+ }
}
if (f->output_data.x->scroll_bar_bottom_shadow_pixel == -1)
{
pixel = f->output_data.x->scroll_bar_background_pixel;
- if (!x_alloc_lighter_color (f, FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
- &pixel, 0.6, 0x4000))
- pixel = -1;
- f->output_data.x->scroll_bar_bottom_shadow_pixel = pixel;
+ if (pixel != -1)
+ {
+ if (!x_alloc_lighter_color (f, FRAME_X_DISPLAY (f),
+ FRAME_X_COLORMAP (f),
+ &pixel, 0.6, 0x4000))
+ pixel = -1;
+ f->output_data.x->scroll_bar_bottom_shadow_pixel = pixel;
+ }
}
#ifdef XtNbeNiceToColormap
emacs_event->arg = Qnil;
emacs_event->timestamp = event->xbutton.time;
{
-#if 0
- FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
- int internal_height
- = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, bar->height);
-#endif
int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
else
emacs_event->part = scroll_bar_below_handle;
- /* Just because the user has clicked on the handle doesn't mean
- they want to drag it. Lisp code needs to be able to decide
- whether or not we're dragging. */
-#if 0
- /* If the user has just clicked on the handle, record where they're
- holding it. */
- if (event->type == ButtonPress
- && emacs_event->part == scroll_bar_handle)
- XSETINT (bar->dragging, y - bar->start);
-#endif
-
#ifndef USE_TOOLKIT_SCROLL_BARS
/* If the user has released the handle, set it to its final position. */
if (event->type == ButtonRelease
}
#endif
- /* Same deal here as the other #if 0. */
-#if 0
- /* Clicks on the handle are always reported as occurring at the top of
- the handle. */
- if (emacs_event->part == scroll_bar_handle)
- emacs_event->x = bar->start;
- else
- XSETINT (emacs_event->x, y);
-#else
XSETINT (emacs_event->x, y);
-#endif
-
XSETINT (emacs_event->y, top_range);
}
}
;
else
{
-#if 0
- int inside_height
- = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, bar->height);
-#endif
int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
\f
/* The main X event-reading loop - XTread_socket. */
-#if 0
-/* Time stamp of enter window event. This is only used by XTread_socket,
- but we have to put it out here, since static variables within functions
- sometimes don't work. */
-
-static Time enter_timestamp;
-#endif
-
/* This holds the state XLookupString needs to implement dead keys
and other tricks known as "compose processing". _X Window System_
says that a portable program can't use this, but Stephen Gildea assures
EVENT_INIT (inev.ie);
inev.ie.kind = NO_EVENT;
inev.ie.arg = Qnil;
-
+
+ if (pending_event_wait.eventtype == event.type)
+ pending_event_wait.eventtype = 0; /* Indicates we got it. */
+
switch (event.type)
{
case ClientMessage:
goto done;
}
+ xft_settings_event (dpyinfo, &event);
+
f = x_any_window_to_frame (dpyinfo, event.xclient.window);
if (!f)
goto OTHER;
case PropertyNotify:
last_user_time = event.xproperty.time;
-#if 0 /* This is plain wrong. In the case that we are waiting for a
- PropertyNotify used as an ACK in incremental selection
- transfer, the property will be on the receiver's window. */
-#if defined USE_X_TOOLKIT
- if (!x_any_window_to_frame (dpyinfo, event.xproperty.window))
- goto OTHER;
-#endif
-#endif
+ f = x_top_window_to_frame (dpyinfo, event.xproperty.window);
+ if (f && event.xproperty.atom == dpyinfo->Xatom_net_wm_state)
+ x_handle_net_wm_state (f, &event.xproperty);
+
x_handle_property_notify (&event.xproperty);
+ xft_settings_event (dpyinfo, &event);
goto OTHER;
case ReparentNotify:
f = x_window_to_frame (dpyinfo, event.xexpose.window);
if (f)
{
- x_check_fullscreen (f);
-
#ifdef USE_GTK
/* This seems to be needed for GTK 2.6. */
x_clear_area (event.xexpose.display,
if (! f->async_iconified)
SET_FRAME_GARBAGED (f);
+ /* Check if fullscreen was specified before we where mapped the
+ first time, i.e. from the command line. */
+ if (!f->output_data.x->has_been_visible)
+ x_check_fullscreen (f);
+
f->async_visible = 1;
f->async_iconified = 0;
f->output_data.x->has_been_visible = 1;
to update the frame titles
in case this is the second frame. */
record_asynch_buffer_change ();
+
+#ifdef USE_GTK
+ xg_frame_resized (f, -1, -1);
+#endif
}
goto OTHER;
&status_return);
}
/* Xutf8LookupString is a new but already deprecated interface. -stef */
-#if 0 && defined X_HAVE_UTF8_STRING
- else if (status_return == XLookupKeySym)
- { /* Try again but with utf-8. */
- coding_system = Qutf_8;
- nbytes = Xutf8LookupString (FRAME_XIC (f),
- &event.xkey, copy_bufptr,
- copy_bufsiz, &keysym,
- &status_return);
- if (status_return == XBufferOverflow)
- {
- copy_bufsiz = nbytes + 1;
- copy_bufptr = (unsigned char *) alloca (copy_bufsiz);
- nbytes = Xutf8LookupString (FRAME_XIC (f),
- &event.xkey,
- copy_bufptr,
- copy_bufsiz, &keysym,
- &status_return);
- }
- }
-#endif
-
if (status_return == XLookupNone)
break;
else if (status_return == XLookupChars)
inev.ie.code = XFASTINT (c);
goto done_keysym;
}
-
+
/* Random non-modifier sorts of keysyms. */
if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
|| keysym == XK_Delete
if (nchars == nbytes)
c = copy_bufptr[i], len = 1;
else
- c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
- nbytes - i, len);
+ c = STRING_CHAR_AND_LENGTH (copy_bufptr + i, len);
inev.ie.kind = (SINGLE_BYTE_CHAR_P (c)
? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT);
if (f && x_mouse_click_focus_ignore_position)
ignore_next_mouse_click_timeout = event.xmotion.time + 200;
-#if 0
- if (event.xcrossing.focus)
- {
- /* Avoid nasty pop/raise loops. */
- if (f && (!(f->auto_raise)
- || !(f->auto_lower)
- || (event.xcrossing.time - enter_timestamp) > 500))
- {
- x_new_focus_frame (dpyinfo, f);
- enter_timestamp = event.xcrossing.time;
- }
- }
- else if (f == dpyinfo->x_focus_frame)
- x_new_focus_frame (dpyinfo, 0);
-#endif
-
/* EnterNotify counts as mouse movement,
so update things that depend on mouse position. */
if (f && !f->output_data.x->hourglass_p)
clear_mouse_face (dpyinfo);
}
+#ifdef USE_GTK
+ if (f && xg_event_is_for_scrollbar (f, &event))
+ f = 0;
+#endif
if (f)
{
- /* Generate SELECT_WINDOW_EVENTs when needed. */
- if (!NILP (Vmouse_autoselect_window))
+ /* Generate SELECT_WINDOW_EVENTs when needed.
+ Don't let popup menus influence things (bug#1261). */
+ if (!NILP (Vmouse_autoselect_window) && !popup_activated ())
{
Lisp_Object window;
{
#ifndef USE_X_TOOLKIT
#ifndef USE_GTK
- /* If there is a pending resize for fullscreen, don't
- do this one, the right one will come later.
- The toolkit version doesn't seem to need this, but we
- need to reset it below. */
- int dont_resize
- = ((f->want_fullscreen & FULLSCREEN_WAIT)
- && f->new_text_cols != 0);
int rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, event.xconfigure.height);
int columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, event.xconfigure.width);
- if (dont_resize)
- goto OTHER;
-
/* In the toolkit version, change_frame_size
is called by the code that handles resizing
of the EmacsFrame widget. */
#ifdef USE_GTK
/* GTK creates windows but doesn't map them.
- Only get real positions and check fullscreen when mapped. */
+ Only get real positions when mapped. */
if (FRAME_GTK_OUTER_WIDGET (f)
&& GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f)))
#endif
{
x_real_positions (f, &f->left_pos, &f->top_pos);
-
- if (f->want_fullscreen & FULLSCREEN_WAIT)
- f->want_fullscreen &= ~(FULLSCREEN_WAIT|FULLSCREEN_BOTH);
}
#ifdef HAVE_X_I18N
xic_set_statusarea (f);
#endif
- if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
- {
- /* Since the WM decorations come below top_pos now,
- we must put them below top_pos in the future. */
- f->win_gravity = NorthWestGravity;
- x_wm_set_size_hint (f, (long) 0, 0);
- }
}
goto OTHER;
else
f = x_window_to_frame (dpyinfo, event.xbutton.window);
+#ifdef USE_GTK
+ if (f && xg_event_is_for_scrollbar (f, &event))
+ f = 0;
+#endif
if (f)
{
/* Is this in the tool-bar? */
if (
#ifdef USE_GTK
! popup_activated ()
+ /* Gtk+ menus only react to the first three buttons. */
+ && event.xbutton.button < 3
&&
#endif
f && event.type == ButtonPress
}
goto OTHER;
+ case DestroyNotify:
+ xft_settings_event (dpyinfo, &event);
+ break;
+
default:
OTHER:
#ifdef USE_X_TOOLKIT
int count = 0;
XEvent event;
int event_found = 0;
-#if 0
- struct x_display_info *dpyinfo;
-#endif
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
+#ifdef SYNC_INPUT
+ pending_signals = 1;
+#endif
return -1;
}
interrupt_input_pending = 0;
+#ifdef SYNC_INPUT
+ pending_signals = pending_atimers;
+#endif
BLOCK_INPUT;
/* So people can tell when we have read the available input. */
XTread_socket_fake_io_error = 0;
x_io_error_quitter (terminal->display_info.x->display);
}
-
-#if 0 /* This loop is a noop now. */
- /* Find the display we are supposed to read input for.
- It's the one communicating on descriptor SD. */
- for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
- {
-#if 0 /* This ought to be unnecessary; let's verify it. */
-#ifdef FIOSNBIO
- /* If available, Xlib uses FIOSNBIO to make the socket
- non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
- FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
- a read returns 0, which Xlib interprets as equivalent to EPIPE. */
- fcntl (dpyinfo->connection, F_SETFL, 0);
-#endif /* ! defined (FIOSNBIO) */
-#endif
-
-#if 0 /* This code can't be made to work, with multiple displays,
- and appears not to be used on any system any more.
- Also keyboard.c doesn't turn O_NDELAY on and off
- for X connections. */
-#ifndef SIGIO
-#ifndef HAVE_SELECT
- if (! (fcntl (dpyinfo->connection, F_GETFL, 0) & O_NDELAY))
- {
- extern int read_alarm_should_throw;
- read_alarm_should_throw = 1;
- XPeekEvent (dpyinfo->display, &event);
- read_alarm_should_throw = 0;
- }
-#endif /* HAVE_SELECT */
-#endif /* SIGIO */
-#endif
- }
-#endif
#ifndef USE_GTK
while (XPending (terminal->display_info.x->display))
#ifdef HAVE_X_I18N
/* Filter events for the current X input method. */
if (x_filter_event (terminal->display_info.x, &event))
- break;
+ continue;
#endif
event_found = 1;
XGCValues xgcv;
/* If the glyph's background equals the color we normally draw
- the bar cursor in, the bar cursor in its normal color is
+ the bars cursor in, the bar cursor in its normal color is
invisible. Use the glyph's foreground color instead in this
case, on the assumption that the glyph's colors are chosen so
that the glyph is legible. */
FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
}
- if (width < 0)
- width = FRAME_CURSOR_WIDTH (f);
- width = min (cursor_glyph->pixel_width, width);
-
- w->phys_cursor_width = width;
x_clip_to_row (w, row, TEXT_AREA, gc);
if (kind == BAR_CURSOR)
+ {
+ if (width < 0)
+ width = FRAME_CURSOR_WIDTH (f);
+ width = min (cursor_glyph->pixel_width, width);
+
+ w->phys_cursor_width = width;
+
XFillRectangle (dpy, window, gc,
WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
width, row->height);
+ }
else
+ {
+ int dummy_x, dummy_y, dummy_h;
+
+ if (width < 0)
+ width = row->height;
+
+ width = min (row->height, width);
+
+ get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
+ &dummy_y, &dummy_h);
+
XFillRectangle (dpy, window, gc,
WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
row->height - width),
- cursor_glyph->pixel_width,
- width);
+ w->phys_cursor_width, width);
+ }
XSetClipMask (dpy, gc, None);
}
struct frame *f;
Cursor cursor;
{
- XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
+ if (!f->pointer_invisible
+ && f->output_data.x->current_cursor != cursor)
+ XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
+ f->output_data.x->current_cursor = cursor;
}
{
int rc = -1;
-#if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
#ifdef USE_GTK
- if (xg_set_icon_from_xpm_data (f, gnu_xpm_bits))
+
+ if (xg_set_icon (f, xg_default_icon_file)
+ || xg_set_icon_from_xpm_data (f, gnu_xpm_bits))
return 0;
-#else
+
+#elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
+
rc = x_create_bitmap_from_xpm_data (f, gnu_xpm_bits);
if (rc != -1)
FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id = rc;
-#endif /* USE_GTK */
-#endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
+
+#endif
/* If all else fails, use the (black and white) xbm image. */
if (rc == -1)
dpyinfo->reference_count++;
dpyinfo->terminal->reference_count++;
}
-
+
/* First delete frames whose mini-buffers are on frames
that are on the dead display. */
FOR_EACH_FRAME (tail, frame)
&& FRAME_X_P (XFRAME (minibuf_frame))
&& ! EQ (frame, minibuf_frame)
&& FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame)) == dpyinfo)
- Fdelete_frame (frame, Qnoelisp);
+ delete_frame (frame, Qnoelisp);
}
/* Now delete all remaining frames on the dead display.
if (FRAME_X_P (XFRAME (frame))
&& FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
{
- /* Set this to t so that Fdelete_frame won't get confused
+ /* Set this to t so that delete_frame won't get confused
trying to find a replacement. */
FRAME_KBOARD (XFRAME (frame))->Vdefault_minibuffer_frame = Qt;
- Fdelete_frame (frame, Qnoelisp);
+ delete_frame (frame, Qnoelisp);
}
/* We have to close the display to inform Xt that it doesn't
\f
/* Changing the font of the frame. */
-/* Give frame F the font named FONTNAME as its default font, and
- return the full name of that font. FONTNAME may be a wildcard
- pattern; in that case, we choose some font that fits the pattern.
- The return value shows which font we chose. */
+/* Give frame F the font FONT-OBJECT as its default font. The return
+ value is FONT-OBJECT. FONTSET is an ID of the fontset for the
+ frame. If it is negative, generate a new fontset from
+ FONT-OBJECT. */
Lisp_Object
-x_new_font (f, fontname)
+x_new_font (f, font_object, fontset)
struct frame *f;
- register char *fontname;
+ Lisp_Object font_object;
+ int fontset;
{
- struct font_info *fontp
- = FS_LOAD_FONT (f, fontname);
+ struct font *font = XFONT_OBJECT (font_object);
- if (!fontp)
- return Qnil;
-
- if (FRAME_FONT (f) == (XFontStruct *) (fontp->font))
+ if (fontset < 0)
+ fontset = fontset_from_font (font_object);
+ FRAME_FONTSET (f) = fontset;
+ if (FRAME_FONT (f) == font)
/* This font is already set in frame F. There's nothing more to
do. */
- return build_string (fontp->full_name);
-
- FRAME_FONT (f) = (XFontStruct *) (fontp->font);
- FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset;
- FRAME_FONTSET (f) = -1;
+ return font_object;
- FRAME_COLUMN_WIDTH (f) = fontp->average_width;
- FRAME_SPACE_WIDTH (f) = fontp->space_width;
- FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (FRAME_FONT (f));
+ FRAME_FONT (f) = font;
+ FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
+ FRAME_COLUMN_WIDTH (f) = font->average_width;
+ FRAME_SPACE_WIDTH (f) = font->space_width;
+ FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (font);
compute_fringe_widths (f, 1);
FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
}
- /* Now make the frame display the given font. */
if (FRAME_X_WINDOW (f) != 0)
{
- Font fid;
-
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- fid = FRAME_X_DISPLAY_INFO (f)->font->fid;
- else
-#endif
- fid = FRAME_FONT (f)->fid;
- XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc, fid);
- XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc, fid);
- XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc, fid);
-
/* Don't change the size of a tip frame; there's no point in
doing it because it's done in Fx_show_tip, and it leads to
problems because the tip frame has no widget. */
if (NILP (tip_frame) || XFRAME (tip_frame) != f)
- x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ {
+ int rows, cols;
+
+ /* When the frame is maximized/fullscreen or running under for
+ example Xmonad, x_set_window_size will be a no-op.
+ In that case, the right thing to do is extend rows/cols to
+ the current frame size. We do that first if x_set_window_size
+ turns out to not be a no-op (there is no way to know).
+ The size will be adjusted again if the frame gets a
+ ConfigureNotify event as a result of x_set_window_size. */
+ int pixelh = FRAME_PIXEL_HEIGHT (f);
+#ifdef USE_X_TOOLKIT
+ /* The menu bar is not part of text lines. The tool bar
+ is however. */
+ pixelh -= FRAME_MENUBAR_HEIGHT (f);
+#endif
+ rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixelh);
+ cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, FRAME_PIXEL_WIDTH (f));
+
+ change_frame_size (f, rows, cols, 0, 1, 0);
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ }
}
- return build_string (fontp->full_name);
-}
-
-/* Give frame F the fontset named FONTSETNAME as its default fontset,
- and return the full name of that fontset. FONTSETNAME may be a
- wildcard pattern; in that case, we choose some fontset that fits
- the pattern. FONTSETNAME may be a font name for ASCII characters;
- in that case, we create a fontset from that font name.
-
- The return value shows which fontset we chose.
- If FONTSETNAME specifies the default fontset, return Qt.
- If an ASCII font in the specified fontset can't be loaded, return
- Qnil. */
-
-Lisp_Object
-x_new_fontset (f, fontsetname)
- struct frame *f;
- Lisp_Object fontsetname;
-{
- int fontset = fs_query_fontset (fontsetname, 0);
- Lisp_Object result;
-
- if (fontset > 0 && f->output_data.x->fontset == fontset)
- /* This fontset is already set in frame F. There's nothing more
- to do. */
- return fontset_name (fontset);
- else if (fontset == 0)
- /* The default fontset can't be the default font. */
- return Qt;
-
- if (fontset > 0)
- result = x_new_font (f, (SDATA (fontset_ascii (fontset))));
- else
- result = x_new_font (f, SDATA (fontsetname));
-
- if (!STRINGP (result))
- /* Can't load ASCII font. */
- return Qnil;
-
- if (fontset < 0)
- fontset = new_fontset_from_font_name (result);
-
- /* Since x_new_font doesn't update any fontset information, do it now. */
- FRAME_FONTSET (f) = fontset;
-
#ifdef HAVE_X_I18N
if (FRAME_XIC (f)
&& (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
- xic_set_xfontset (f, SDATA (fontset_ascii (fontset)));
-#endif
-
- return fontset_name (fontset);
-}
-
-#ifdef USE_FONT_BACKEND
-Lisp_Object
-x_new_fontset2 (f, fontset, font_object)
- struct frame *f;
- int fontset;
- Lisp_Object font_object;
-{
- struct font *font = XSAVE_VALUE (font_object)->pointer;
-
- if (FRAME_FONT_OBJECT (f) == font)
- /* This font is already set in frame F. There's nothing more to
- do. */
- return fontset_name (fontset);
-
- BLOCK_INPUT;
-
- FRAME_FONT_OBJECT (f) = font;
- FRAME_FONT (f) = font->font.font;
- FRAME_BASELINE_OFFSET (f) = font->font.baseline_offset;
- FRAME_FONTSET (f) = fontset;
-
- FRAME_COLUMN_WIDTH (f) = font->font.average_width;
- FRAME_SPACE_WIDTH (f) = font->font.space_width;
- FRAME_LINE_HEIGHT (f) = font->font.height;
-
- compute_fringe_widths (f, 1);
-
- /* Compute the scroll bar width in character columns. */
- if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
- {
- int wid = FRAME_COLUMN_WIDTH (f);
- FRAME_CONFIG_SCROLL_BAR_COLS (f)
- = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
- }
- else
- {
- int wid = FRAME_COLUMN_WIDTH (f);
- FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
- }
-
- /* Now make the frame display the given font. */
- if (FRAME_X_WINDOW (f) != 0)
{
- /* Don't change the size of a tip frame; there's no point in
- doing it because it's done in Fx_show_tip, and it leads to
- problems because the tip frame has no widget. */
- if (NILP (tip_frame) || XFRAME (tip_frame) != f)
- x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ BLOCK_INPUT;
+ xic_set_xfontset (f, SDATA (fontset_ascii (fontset)));
+ UNBLOCK_INPUT;
}
-
-#ifdef HAVE_X_I18N
- if (FRAME_XIC (f)
- && (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
- xic_set_xfontset (f, SDATA (fontset_ascii (fontset)));
#endif
- UNBLOCK_INPUT;
-
- return fontset_name (fontset);
+ return font_object;
}
-#endif /* USE_FONT_BACKEND */
\f
/***********************************************************************
#ifdef HAVE_XIM
if (use_xim)
{
+ if (dpyinfo->xim)
+ XCloseIM (dpyinfo->xim);
xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name,
EMACS_CLASS);
dpyinfo->xim = xim;
#ifdef HAVE_X11R6_XIM
-struct xim_inst_t
-{
- struct x_display_info *dpyinfo;
- char *resource_name;
-};
-
/* XIM instantiate callback function, which is called whenever an XIM
server is available. DISPLAY is the display of the XIM.
CLIENT_DATA contains a pointer to an xim_inst_t structure created
struct x_display_info *dpyinfo;
char *resource_name;
{
+ dpyinfo->xim = NULL;
#ifdef HAVE_XIM
if (use_xim)
{
struct xim_inst_t *xim_inst;
int len;
- dpyinfo->xim = NULL;
xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
+ dpyinfo->xim_callback_data = xim_inst;
xim_inst->dpyinfo = dpyinfo;
len = strlen (resource_name);
xim_inst->resource_name = (char *) xmalloc (len + 1);
least, hence the configure test. */
(XRegisterIMInstantiateCallback_arg6) xim_inst);
#else /* not HAVE_X11R6_XIM */
- dpyinfo->xim = NULL;
xim_open_dpy (dpyinfo, resource_name);
#endif /* not HAVE_X11R6_XIM */
-
}
- else
#endif /* HAVE_XIM */
- dpyinfo->xim = NULL;
}
XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
NULL, EMACS_CLASS,
xim_instantiate_callback, NULL);
-#endif /* not HAVE_X11R6_XIM */
+ xfree (dpyinfo->xim_callback_data->resource_name);
+ xfree (dpyinfo->xim_callback_data);
+#endif /* HAVE_X11R6_XIM */
if (dpyinfo->display)
XCloseIM (dpyinfo->xim);
dpyinfo->xim = NULL;
/* Treat negative positions as relative to the leftmost bottommost
position that fits on the screen. */
if (flags & XNegative)
- f->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
- - FRAME_PIXEL_WIDTH (f) + f->left_pos);
+ f->left_pos = x_display_pixel_width (FRAME_X_DISPLAY_INFO (f))
+ - FRAME_PIXEL_WIDTH (f) + f->left_pos;
{
int height = FRAME_PIXEL_HEIGHT (f);
XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
#endif
- if (flags & YNegative)
- f->top_pos = (FRAME_X_DISPLAY_INFO (f)->height - height + f->top_pos);
+ if (flags & YNegative)
+ f->top_pos = x_display_pixel_height (FRAME_X_DISPLAY_INFO (f))
+ - height + f->top_pos;
}
/* The left_pos and top_pos
return rc;
}
+static void
+set_wm_state (frame, add, what, what2)
+ Lisp_Object frame;
+ int add;
+ const char *what;
+ const char *what2;
+{
+ const char *atom = "_NET_WM_STATE";
+ Fx_send_client_event (frame, make_number (0), frame,
+ make_unibyte_string (atom, strlen (atom)),
+ make_number (32),
+ /* 1 = add, 0 = remove */
+ Fcons
+ (make_number (add ? 1 : 0),
+ Fcons
+ (make_unibyte_string (what, strlen (what)),
+ what2 != 0
+ ? Fcons (make_unibyte_string (what2, strlen (what2)),
+ Qnil)
+ : Qnil)));
+}
+
+void
+x_set_sticky (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+ Lisp_Object frame;
+
+ XSETFRAME (frame, f);
+ set_wm_state (frame, NILP (new_value) ? 0 : 1,
+ "_NET_WM_STATE_STICKY", NULL);
+}
+
/* Do fullscreen as specified in extended window manager hints */
static int
if (have_net_atom)
{
Lisp_Object frame;
- const char *atom = "_NET_WM_STATE";
const char *fs = "_NET_WM_STATE_FULLSCREEN";
const char *fw = "_NET_WM_STATE_MAXIMIZED_HORZ";
const char *fh = "_NET_WM_STATE_MAXIMIZED_VERT";
- const char *what = NULL;
XSETFRAME (frame, f);
+ set_wm_state (frame, 0, fs, NULL);
+ set_wm_state (frame, 0, fh, NULL);
+ set_wm_state (frame, 0, fw, NULL);
+
/* If there are _NET_ atoms we assume we have extended window manager
hints. */
switch (f->want_fullscreen)
{
case FULLSCREEN_BOTH:
- what = fs;
+ set_wm_state (frame, 1, fs, NULL);
break;
case FULLSCREEN_WIDTH:
- what = fw;
+ set_wm_state (frame, 1, fw, NULL);
break;
case FULLSCREEN_HEIGHT:
- what = fh;
+ set_wm_state (frame, 1, fh, NULL);
+ break;
+ case FULLSCREEN_MAXIMIZED:
+ set_wm_state (frame, 1, fw, fh);
break;
}
- if (what != NULL && !wm_supports (f, what)) return 0;
-
-
- Fx_send_client_event (frame, make_number (0), frame,
- make_unibyte_string (atom, strlen (atom)),
- make_number (32),
- Fcons (make_number (0), /* Remove */
- Fcons
- (make_unibyte_string (fs,
- strlen (fs)),
- Qnil)));
- Fx_send_client_event (frame, make_number (0), frame,
- make_unibyte_string (atom, strlen (atom)),
- make_number (32),
- Fcons (make_number (0), /* Remove */
- Fcons
- (make_unibyte_string (fh,
- strlen (fh)),
- Qnil)));
- Fx_send_client_event (frame, make_number (0), frame,
- make_unibyte_string (atom, strlen (atom)),
- make_number (32),
- Fcons (make_number (0), /* Remove */
- Fcons
- (make_unibyte_string (fw,
- strlen (fw)),
- Qnil)));
f->want_fullscreen = FULLSCREEN_NONE;
- if (what != NULL)
- Fx_send_client_event (frame, make_number (0), frame,
- make_unibyte_string (atom, strlen (atom)),
- make_number (32),
- Fcons (make_number (1), /* Add */
- Fcons
- (make_unibyte_string (what,
- strlen (what)),
- Qnil)));
+
}
return have_net_atom;
if (f->async_visible)
{
BLOCK_INPUT;
- do_ewmh_fullscreen (f);
+ x_check_fullscreen (f);
x_sync (f);
UNBLOCK_INPUT;
}
}
+static void
+x_handle_net_wm_state (f, event)
+ struct frame *f;
+ XPropertyEvent *event;
+{
+ Atom actual_type;
+ unsigned long actual_size, bytes_remaining;
+ int i, rc, actual_format, value = FULLSCREEN_NONE;
+ struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ long max_len = 65536;
+ Display *dpy = FRAME_X_DISPLAY (f);
+ unsigned char *tmp_data = NULL;
+ Atom target_type = XA_ATOM;
+ Lisp_Object lval;
+ int sticky = 0;
+
+ BLOCK_INPUT;
+ x_catch_errors (dpy);
+ rc = XGetWindowProperty (dpy, event->window,
+ event->atom, 0, max_len, False, target_type,
+ &actual_type, &actual_format, &actual_size,
+ &bytes_remaining, &tmp_data);
+
+ if (rc != Success || actual_type != target_type || x_had_errors_p (dpy))
+ {
+ if (tmp_data) XFree (tmp_data);
+ x_uncatch_errors ();
+ UNBLOCK_INPUT;
+ return;
+ }
+
+ x_uncatch_errors ();
+
+ for (i = 0; i < actual_size; ++i)
+ {
+ Atom a = ((Atom*)tmp_data)[i];
+ if (a == dpyinfo->Xatom_net_wm_state_maximized_horz)
+ {
+ if (value == FULLSCREEN_HEIGHT)
+ value = FULLSCREEN_MAXIMIZED;
+ else
+ value = FULLSCREEN_WIDTH;
+ }
+ else if (a == dpyinfo->Xatom_net_wm_state_maximized_vert)
+ {
+ if (value == FULLSCREEN_WIDTH)
+ value = FULLSCREEN_MAXIMIZED;
+ else
+ value = FULLSCREEN_HEIGHT;
+ }
+ else if (a == dpyinfo->Xatom_net_wm_state_fullscreen_atom)
+ value = FULLSCREEN_BOTH;
+ else if (a == dpyinfo->Xatom_net_wm_state_sticky)
+ sticky = 1;
+ }
+
+ lval = Qnil;
+ switch (value)
+ {
+ case FULLSCREEN_WIDTH:
+ lval = Qfullwidth;
+ break;
+ case FULLSCREEN_HEIGHT:
+ lval = Qfullheight;
+ break;
+ case FULLSCREEN_BOTH:
+ lval = Qfullboth;
+ break;
+ case FULLSCREEN_MAXIMIZED:
+ lval = Qmaximized;
+ break;
+ }
+
+ store_frame_param (f, Qfullscreen, lval);
+ store_frame_param (f, Qsticky, sticky ? Qt : Qnil);
+
+ if (tmp_data) XFree (tmp_data);
+ UNBLOCK_INPUT;
+}
+
/* Check if we need to resize the frame due to a fullscreen request.
If so needed, resize the frame. */
static void
x_check_fullscreen (f)
struct frame *f;
{
- if (f->want_fullscreen & FULLSCREEN_BOTH)
- {
- int width, height, ign;
-
- if (do_ewmh_fullscreen (f))
- return;
+ if (do_ewmh_fullscreen (f))
+ return;
- x_real_positions (f, &f->left_pos, &f->top_pos);
+ if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
+ return; /* Only fullscreen without WM or with EWM hints (above). */
- x_fullscreen_adjust (f, &width, &height, &ign, &ign);
+ if (f->want_fullscreen != FULLSCREEN_NONE)
+ {
+ int width = FRAME_COLS (f), height = FRAME_LINES (f);
+ struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
- /* We do not need to move the window, it shall be taken care of
- when setting WM manager hints.
- If the frame is visible already, the position is checked by
- x_check_expected_move. */
+ switch (f->want_fullscreen)
+ {
+ /* No difference between these two when there is no WM */
+ case FULLSCREEN_BOTH:
+ case FULLSCREEN_MAXIMIZED:
+ width = x_display_pixel_width (dpyinfo);
+ height = x_display_pixel_height (dpyinfo);
+ break;
+ case FULLSCREEN_WIDTH:
+ width = x_display_pixel_width (dpyinfo);
+ break;
+ case FULLSCREEN_HEIGHT:
+ height = x_display_pixel_height (dpyinfo);
+ }
+
if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
{
change_frame_size (f, height, width, 0, 1, 0);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
-
- /* Wait for the change of frame size to occur */
- f->want_fullscreen |= FULLSCREEN_WAIT;
}
}
}
x_real_positions (f, ¤t_left, ¤t_top);
if (current_left != expected_left || current_top != expected_top)
- {
+ {
/* It's a "Type A" window manager. */
int adjusted_left;
adjusted_left, adjusted_top);
x_sync_with_move (f, expected_left, expected_top, 0);
- }
+ }
else
/* It's a "Type B" window manager. We don't have to adjust the
frame's position. */
}
+/* Wait for an event on frame F matching EVENTTYPE. */
+void
+x_wait_for_event (f, eventtype)
+ struct frame *f;
+ int eventtype;
+{
+ int level = interrupt_input_blocked;
+
+ SELECT_TYPE fds;
+ EMACS_TIME tmo, tmo_at, time_now;
+ int fd = ConnectionNumber (FRAME_X_DISPLAY (f));
+
+ pending_event_wait.f = f;
+ pending_event_wait.eventtype = eventtype;
+
+ /* Set timeout to 0.1 second. Hopefully not noticable.
+ Maybe it should be configurable. */
+ EMACS_SET_SECS_USECS (tmo, 0, 100000);
+ EMACS_GET_TIME (tmo_at);
+ EMACS_ADD_TIME (tmo_at, tmo_at, tmo);
+
+ while (pending_event_wait.eventtype)
+ {
+ interrupt_input_pending = 1;
+ TOTALLY_UNBLOCK_INPUT;
+ /* XTread_socket is called after unblock. */
+ BLOCK_INPUT;
+ interrupt_input_blocked = level;
+
+ FD_ZERO (&fds);
+ FD_SET (fd, &fds);
+
+ EMACS_GET_TIME (time_now);
+ EMACS_SUB_TIME (tmo, tmo_at, time_now);
+
+ if (EMACS_TIME_NEG_P (tmo) || select (fd+1, &fds, NULL, NULL, &tmo) == 0)
+ break; /* Timeout */
+ }
+ pending_event_wait.f = 0;
+ pending_event_wait.eventtype = 0;
+}
+
+
/* Change the size of frame F's X window to COLS/ROWS in the case F
doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
top-left-corner window gravity for this size change and subsequent
compute_fringe_widths (f, 0);
- pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
- pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
+ pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols)
+ + 2*f->border_width;
+ pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows)
+ + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f)
+ + 2*f->border_width;
- f->win_gravity = NorthWestGravity;
+ if (change_gravity) f->win_gravity = NorthWestGravity;
x_wm_set_size_hint (f, (long) 0, 0);
-
- XSync (FRAME_X_DISPLAY (f), False);
- XResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+ XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
pixelwidth, pixelheight);
+
+ /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
+ receive in the ConfigureNotify event; if we get what we asked
+ for, then the event won't cause the screen to become garbaged, so
+ we have to make sure to do it here. */
+ SET_FRAME_GARBAGED (f);
+
/* Now, strictly speaking, we can't be sure that this is accurate,
but the window manager will get around to dealing with the size
change request eventually, and we'll hear how it went when the
We pass 1 for DELAY since we can't run Lisp code inside of
a BLOCK_INPUT. */
- change_frame_size (f, rows, cols, 0, 1, 0);
- FRAME_PIXEL_WIDTH (f) = pixelwidth;
- FRAME_PIXEL_HEIGHT (f) = pixelheight;
- /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
- receive in the ConfigureNotify event; if we get what we asked
- for, then the event won't cause the screen to become garbaged, so
- we have to make sure to do it here. */
- SET_FRAME_GARBAGED (f);
-
- XFlush (FRAME_X_DISPLAY (f));
+ /* But the ConfigureNotify may in fact never arrive, and then this is
+ not right if the frame is visible. Instead wait (with timeout)
+ for the ConfigureNotify. */
+ if (f->async_visible)
+ x_wait_for_event (f, ConfigureNotify);
+ else
+ {
+ change_frame_size (f, rows, cols, 0, 1, 0);
+ FRAME_PIXEL_WIDTH (f) = pixelwidth;
+ FRAME_PIXEL_HEIGHT (f) = pixelheight;
+ x_sync (f);
+ }
}
xg_frame_set_char_size (f, cols, rows);
else
x_set_window_size_1 (f, change_gravity, cols, rows);
-#elif USE_X_TOOLKIT
-
- if (f->output_data.x->widget != NULL)
- {
- /* The x and y position of the widget is clobbered by the
- call to XtSetValues within EmacsFrameSetCharSize.
- This is a real kludge, but I don't understand Xt so I can't
- figure out a correct fix. Can anyone else tell me? -- rms. */
- int xpos = f->output_data.x->widget->core.x;
- int ypos = f->output_data.x->widget->core.y;
- EmacsFrameSetCharSize (f->output_data.x->edit_widget, cols, rows);
- f->output_data.x->widget->core.x = xpos;
- f->output_data.x->widget->core.y = ypos;
- }
- else
- x_set_window_size_1 (f, change_gravity, cols, rows);
-
-#else /* not USE_X_TOOLKIT */
+#else /* not USE_GTK */
x_set_window_size_1 (f, change_gravity, cols, rows);
-#endif /* not USE_X_TOOLKIT */
+#endif /* not USE_GTK */
/* If cursor was outside the new size, mark it as off. */
mark_window_cursors_off (XWINDOW (f->root_window));
x_focus_on_frame (f)
struct frame *f;
{
-#if 0 /* This proves to be unpleasant. */
- x_raise_frame (f);
-#endif
#if 0
/* I don't think that the ICCCM allows programs to do things like this
without the interaction of the window manager. Whatever you end up
XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif /* not USE_GTK */
#endif /* not USE_X_TOOLKIT */
-#if 0 /* This seems to bring back scroll bars in the wrong places
- if the window configuration has changed. They seem
- to come back ok without this. */
- if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
- XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
-#endif
}
XFlush (FRAME_X_DISPLAY (f));
if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
-#if 0/* This might add unreliability; I don't trust it -- rms. */
- if (! f->async_visible && ! f->async_iconified)
- return;
-#endif
-
BLOCK_INPUT;
/* Before unmapping the window, update the WM_SIZE_HINTS property to claim
commands to the X server. */
if (dpyinfo->display)
{
-#ifdef USE_FONT_BACKEND
/* We must free faces before destroying windows because some
font-driver (e.g. xft) access a window while finishing a
face. */
- if (enable_font_backend
- && FRAME_FACE_CACHE (f))
+ if (FRAME_FACE_CACHE (f))
free_frame_faces (f);
-#endif /* USE_FONT_BACKEND */
if (f->output_data.x->icon_desc)
XDestroyWindow (FRAME_X_DISPLAY (f), f->output_data.x->icon_desc);
if (f->output_data.x->black_relief.allocated_p)
unload_color (f, f->output_data.x->black_relief.pixel);
- if (FRAME_FACE_CACHE (f))
- free_frame_faces (f);
-
x_free_gcs (f);
XFlush (FRAME_X_DISPLAY (f));
}
- if (f->output_data.x->saved_menu_event)
- xfree (f->output_data.x->saved_menu_event);
-
+ xfree (f->output_data.x->saved_menu_event);
xfree (f->output_data.x);
f->output_data.x = NULL;
int user_position;
{
XSizeHints size_hints;
-
-#ifdef USE_X_TOOLKIT
- Arg al[2];
- int ac = 0;
- Dimension widget_width, widget_height;
-#endif
-
Window window = FRAME_OUTER_WINDOW (f);
/* Setting PMaxSize caused various problems. */
size_hints.x = f->left_pos;
size_hints.y = f->top_pos;
-#ifdef USE_X_TOOLKIT
- XtSetArg (al[ac], XtNwidth, &widget_width); ac++;
- XtSetArg (al[ac], XtNheight, &widget_height); ac++;
- XtGetValues (f->output_data.x->widget, al, ac);
- size_hints.height = widget_height;
- size_hints.width = widget_width;
-#else /* not USE_X_TOOLKIT */
size_hints.height = FRAME_PIXEL_HEIGHT (f);
size_hints.width = FRAME_PIXEL_WIDTH (f);
-#endif /* not USE_X_TOOLKIT */
size_hints.width_inc = FRAME_COLUMN_WIDTH (f);
size_hints.height_inc = FRAME_LINE_HEIGHT (f);
- size_hints.max_width
- = FRAME_X_DISPLAY_INFO (f)->width - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
- size_hints.max_height
- = FRAME_X_DISPLAY_INFO (f)->height - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0);
-
- /* Calculate the base and minimum sizes.
+ size_hints.max_width = x_display_pixel_width (FRAME_X_DISPLAY_INFO (f))
+ - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
+ size_hints.max_height = x_display_pixel_height (FRAME_X_DISPLAY_INFO (f))
+ - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0);
- (When we use the X toolkit, we don't do it here.
- Instead we copy the values that the widgets are using, below.) */
-#ifndef USE_X_TOOLKIT
+ /* Calculate the base and minimum sizes. */
{
int base_width, base_height;
int min_rows = 0, min_cols = 0;
size_hints.flags |= PBaseSize;
size_hints.base_width = base_width;
- size_hints.base_height = base_height;
+ size_hints.base_height = base_height + FRAME_MENUBAR_HEIGHT (f);
size_hints.min_width = base_width + min_cols * size_hints.width_inc;
size_hints.min_height = base_height + min_rows * size_hints.height_inc;
}
size_hints.flags |= flags;
goto no_read;
}
-#endif /* not USE_X_TOOLKIT */
{
XSizeHints hints; /* Sometimes I hate X Windows... */
value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
&supplied_return);
-#ifdef USE_X_TOOLKIT
- size_hints.base_height = hints.base_height;
- size_hints.base_width = hints.base_width;
- size_hints.min_height = hints.min_height;
- size_hints.min_width = hints.min_width;
-#endif
-
if (flags)
size_hints.flags |= flags;
else
}
}
-#ifndef USE_X_TOOLKIT
no_read:
-#endif
#ifdef PWinGravity
size_hints.win_gravity = f->win_gravity;
}
else
{
- /* It seems there is no way to turn off use of an icon pixmap.
- The following line does it, only if no icon has yet been created,
- for some window managers. But with mwm it crashes.
- Some people say it should clear the IconPixmapHint bit in this case,
- but that doesn't work, and the X consortium said it isn't the
- right thing at all. Since there is no way to win,
- best to explicitly give up. */
-#if 0
- f->output_data.x->wm_hints.icon_pixmap = None;
- f->output_data.x->wm_hints.icon_mask = None;
-#else
+ /* It seems there is no way to turn off use of an icon
+ pixmap. */
return;
-#endif
}
Fonts
***********************************************************************/
-/* Return a pointer to struct font_info of font FONT_IDX of frame F. */
-
-struct font_info *
-x_get_font_info (f, font_idx)
- FRAME_PTR f;
- int font_idx;
-{
- return (FRAME_X_FONT_TABLE (f) + font_idx);
-}
-
-
-/* Return a list of names of available fonts matching PATTERN on frame F.
-
- If SIZE is > 0, it is the size (maximum bounds width) of fonts
- to be listed.
-
- SIZE < 0 means include auto scaled fonts.
-
- Frame F null means we have not yet created any frame on X, and
- consult the first display in x_display_list. MAXNAMES sets a limit
- on how many fonts to match. */
-
-Lisp_Object
-x_list_fonts (f, pattern, size, maxnames)
- struct frame *f;
- Lisp_Object pattern;
- int size;
- int maxnames;
-{
- Lisp_Object list = Qnil, patterns, newlist = Qnil, key = Qnil;
- Lisp_Object tem, second_best;
- struct x_display_info *dpyinfo
- = f ? FRAME_X_DISPLAY_INFO (f) : x_display_list;
- Display *dpy = dpyinfo->display;
- int try_XLoadQueryFont = 0;
- int allow_auto_scaled_font = 0;
-
- if (size < 0)
- {
- allow_auto_scaled_font = 1;
- size = 0;
- }
-
- patterns = Fassoc (pattern, Valternate_fontname_alist);
- if (NILP (patterns))
- patterns = Fcons (pattern, Qnil);
-
- if (maxnames == 1 && !size)
- /* We can return any single font matching PATTERN. */
- try_XLoadQueryFont = 1;
-
- for (; CONSP (patterns); patterns = XCDR (patterns))
- {
- int num_fonts;
- char **names = NULL;
-
- pattern = XCAR (patterns);
- /* See if we cached the result for this particular query.
- The cache is an alist of the form:
- ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
- tem = XCDR (dpyinfo->name_list_element);
- key = Fcons (Fcons (pattern, make_number (maxnames)),
- allow_auto_scaled_font ? Qt : Qnil);
- list = Fassoc (key, tem);
- if (!NILP (list))
- {
- list = Fcdr_safe (list);
- /* We have a cashed list. Don't have to get the list again. */
- goto label_cached;
- }
-
- /* At first, put PATTERN in the cache. */
-
- BLOCK_INPUT;
- x_catch_errors (dpy);
-
- if (try_XLoadQueryFont)
- {
- XFontStruct *font;
- unsigned long value;
-
- font = XLoadQueryFont (dpy, SDATA (pattern));
- if (x_had_errors_p (dpy))
- {
- /* This error is perhaps due to insufficient memory on X
- server. Let's just ignore it. */
- font = NULL;
- x_clear_errors (dpy);
- }
-
- if (font
- && XGetFontProperty (font, XA_FONT, &value))
- {
- char *name = (char *) XGetAtomName (dpy, (Atom) value);
- int len = strlen (name);
- char *tmp;
-
- /* If DXPC (a Differential X Protocol Compressor)
- Ver.3.7 is running, XGetAtomName will return null
- string. We must avoid such a name. */
- if (len == 0)
- try_XLoadQueryFont = 0;
- else
- {
- num_fonts = 1;
- names = (char **) alloca (sizeof (char *));
- /* Some systems only allow alloca assigned to a
- simple var. */
- tmp = (char *) alloca (len + 1); names[0] = tmp;
- bcopy (name, names[0], len + 1);
- XFree (name);
- }
- }
- else
- try_XLoadQueryFont = 0;
-
- if (font)
- XFreeFont (dpy, font);
- }
-
- if (!try_XLoadQueryFont)
- {
- /* We try at least 10 fonts because XListFonts will return
- auto-scaled fonts at the head. */
- if (maxnames < 0)
- {
- int limit;
-
- for (limit = 500;;)
- {
- names = XListFonts (dpy, SDATA (pattern), limit, &num_fonts);
- if (num_fonts == limit)
- {
- BLOCK_INPUT;
- XFreeFontNames (names);
- UNBLOCK_INPUT;
- limit *= 2;
- }
- else
- break;
- }
- }
- else
- names = XListFonts (dpy, SDATA (pattern), max (maxnames, 10),
- &num_fonts);
-
- if (x_had_errors_p (dpy))
- {
- /* This error is perhaps due to insufficient memory on X
- server. Let's just ignore it. */
- names = NULL;
- x_clear_errors (dpy);
- }
- }
-
- x_uncatch_errors ();
- UNBLOCK_INPUT;
-
- if (names)
- {
- int i;
-
- /* Make a list of all the fonts we got back.
- Store that in the font cache for the display. */
- for (i = 0; i < num_fonts; i++)
- {
- int width = 0;
- char *p = names[i];
- int average_width = -1, resx = 0, dashes = 0;
-
- /* Count the number of dashes in NAMES[I]. If there are
- 14 dashes, the field value following 9th dash
- (RESOLUTION_X) is nonzero, and the field value
- following 12th dash (AVERAGE_WIDTH) is 0, this is a
- auto-scaled font which is usually too ugly to be used
- for editing. Let's ignore it. */
- while (*p)
- if (*p++ == '-')
- {
- dashes++;
- if (dashes == 7) /* PIXEL_SIZE field */
- width = atoi (p);
- else if (dashes == 9)
- resx = atoi (p);
- else if (dashes == 12) /* AVERAGE_WIDTH field */
- average_width = atoi (p);
- }
-
- if (allow_auto_scaled_font
- || dashes < 14 || average_width != 0 || resx == 0)
- {
- tem = build_string (names[i]);
- if (NILP (Fassoc (tem, list)))
- {
- if (STRINGP (Vx_pixel_size_width_font_regexp)
- && ((fast_c_string_match_ignore_case
- (Vx_pixel_size_width_font_regexp, names[i]))
- >= 0))
- /* We can set the value of PIXEL_SIZE to the
- width of this font. */
- list = Fcons (Fcons (tem, make_number (width)), list);
- else
- /* For the moment, width is not known. */
- list = Fcons (Fcons (tem, Qnil), list);
- }
- }
- }
-
- if (!try_XLoadQueryFont)
- {
- BLOCK_INPUT;
- XFreeFontNames (names);
- UNBLOCK_INPUT;
- }
- }
-
- /* Now store the result in the cache. */
- XSETCDR (dpyinfo->name_list_element,
- Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element)));
-
- label_cached:
- if (NILP (list)) continue; /* Try the remaining alternatives. */
-
- newlist = second_best = Qnil;
- /* Make a list of the fonts that have the right width. */
- for (; CONSP (list); list = XCDR (list))
- {
- int found_size;
-
- tem = XCAR (list);
-
- if (!CONSP (tem) || NILP (XCAR (tem)))
- continue;
- if (!size)
- {
- newlist = Fcons (XCAR (tem), newlist);
- continue;
- }
-
- if (!INTEGERP (XCDR (tem)))
- {
- /* Since we have not yet known the size of this font, we
- must try slow function call XLoadQueryFont. */
- XFontStruct *thisinfo;
-
- BLOCK_INPUT;
- x_catch_errors (dpy);
- thisinfo = XLoadQueryFont (dpy,
- SDATA (XCAR (tem)));
- if (x_had_errors_p (dpy))
- {
- /* This error is perhaps due to insufficient memory on X
- server. Let's just ignore it. */
- thisinfo = NULL;
- x_clear_errors (dpy);
- }
- x_uncatch_errors ();
- UNBLOCK_INPUT;
-
- if (thisinfo)
- {
- XSETCDR (tem,
- (thisinfo->min_bounds.width == 0
- ? make_number (0)
- : make_number (thisinfo->max_bounds.width)));
- BLOCK_INPUT;
- XFreeFont (dpy, thisinfo);
- UNBLOCK_INPUT;
- }
- else
- /* For unknown reason, the previous call of XListFont had
- returned a font which can't be opened. Record the size
- as 0 not to try to open it again. */
- XSETCDR (tem, make_number (0));
- }
-
- found_size = XINT (XCDR (tem));
- if (found_size == size)
- newlist = Fcons (XCAR (tem), newlist);
- else if (found_size > 0)
- {
- if (NILP (second_best))
- second_best = tem;
- else if (found_size < size)
- {
- if (XINT (XCDR (second_best)) > size
- || XINT (XCDR (second_best)) < found_size)
- second_best = tem;
- }
- else
- {
- if (XINT (XCDR (second_best)) > size
- && XINT (XCDR (second_best)) > found_size)
- second_best = tem;
- }
- }
- }
- if (!NILP (newlist))
- break;
- else if (!NILP (second_best))
- {
- newlist = Fcons (XCAR (second_best), Qnil);
- break;
- }
- }
-
- return newlist;
-}
-
-
#if GLYPH_DEBUG
/* Check that FONT is valid on frame F. It is if it can be found in F's
static void
x_check_font (f, font)
struct frame *f;
- XFontStruct *font;
+ struct font *font;
{
- int i;
- struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
-
- xassert (font != NULL);
-
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- /* Fixme: Perhaps we should check all cached fonts. */
- return;
-#endif
- for (i = 0; i < dpyinfo->n_fonts; i++)
- if (dpyinfo->font_table[i].name
- && font == dpyinfo->font_table[i].font)
- break;
+ Lisp_Object frame;
- xassert (i < dpyinfo->n_fonts);
+ xassert (font != NULL && ! NILP (font->props[FONT_TYPE_INDEX]));
+ if (font->driver->check)
+ xassert (font->driver->check (f, font) == 0);
}
#endif /* GLYPH_DEBUG != 0 */
-/* Set *W to the minimum width, *H to the minimum font height of FONT.
- Note: There are (broken) X fonts out there with invalid XFontStruct
- min_bounds contents. For example, handa@etl.go.jp reports that
- "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
- have font->min_bounds.width == 0. */
-
-static INLINE void
-x_font_min_bounds (font, w, h)
- XFontStruct *font;
- int *w, *h;
-{
- *h = FONT_HEIGHT (font);
- *w = font->min_bounds.width;
-
- /* Try to handle the case where FONT->min_bounds has invalid
- contents. Since the only font known to have invalid min_bounds
- is fixed-width, use max_bounds if min_bounds seems to be invalid. */
- if (*w <= 0)
- *w = font->max_bounds.width;
-}
-
-
-/* Compute the smallest character width and smallest font height over
- all fonts available on frame F. Set the members smallest_char_width
- and smallest_font_height in F's x_display_info structure to
- the values computed. Value is non-zero if smallest_font_height or
- smallest_char_width become smaller than they were before. */
-
-static int
-x_compute_min_glyph_bounds (f)
- struct frame *f;
-{
- int i;
- struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
- XFontStruct *font;
- int old_width = dpyinfo->smallest_char_width;
- int old_height = dpyinfo->smallest_font_height;
-
- dpyinfo->smallest_font_height = 100000;
- dpyinfo->smallest_char_width = 100000;
-
- for (i = 0; i < dpyinfo->n_fonts; ++i)
- if (dpyinfo->font_table[i].name)
- {
- struct font_info *fontp = dpyinfo->font_table + i;
- int w, h;
-
- font = (XFontStruct *) fontp->font;
- xassert (font != (XFontStruct *) ~0);
- x_font_min_bounds (font, &w, &h);
-
- dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
- dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
- }
-
- xassert (dpyinfo->smallest_char_width > 0
- && dpyinfo->smallest_font_height > 0);
-
- return (dpyinfo->n_fonts == 1
- || dpyinfo->smallest_char_width < old_width
- || dpyinfo->smallest_font_height < old_height);
-}
-
-
-/* Load font named FONTNAME of the size SIZE for frame F, and return a
- pointer to the structure font_info while allocating it dynamically.
- If SIZE is 0, load any size of font.
- If loading is failed, return NULL. */
-
-struct font_info *
-x_load_font (f, fontname, size)
- struct frame *f;
- register char *fontname;
- int size;
-{
- struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
- Lisp_Object font_names;
-
- /* Get a list of all the fonts that match this name. Once we
- have a list of matching fonts, we compare them against the fonts
- we already have by comparing names. */
- font_names = x_list_fonts (f, build_string (fontname), size, 1);
-
- if (!NILP (font_names))
- {
- Lisp_Object tail;
- int i;
-
- for (i = 0; i < dpyinfo->n_fonts; i++)
- for (tail = font_names; CONSP (tail); tail = XCDR (tail))
- if (dpyinfo->font_table[i].name
- && (!strcmp (dpyinfo->font_table[i].name,
- SDATA (XCAR (tail)))
- || !strcmp (dpyinfo->font_table[i].full_name,
- SDATA (XCAR (tail)))))
- return (dpyinfo->font_table + i);
- }
-
- /* Load the font and add it to the table. */
- {
- char *full_name;
- XFontStruct *font;
- struct font_info *fontp;
- unsigned long value;
- int i;
-
- /* If we have found fonts by x_list_font, load one of them. If
- not, we still try to load a font by the name given as FONTNAME
- because XListFonts (called in x_list_font) of some X server has
- a bug of not finding a font even if the font surely exists and
- is loadable by XLoadQueryFont. */
- if (size > 0 && !NILP (font_names))
- fontname = (char *) SDATA (XCAR (font_names));
-
- BLOCK_INPUT;
- x_catch_errors (FRAME_X_DISPLAY (f));
- font = (XFontStruct *) XLoadQueryFont (FRAME_X_DISPLAY (f), fontname);
- if (x_had_errors_p (FRAME_X_DISPLAY (f)))
- {
- /* This error is perhaps due to insufficient memory on X
- server. Let's just ignore it. */
- font = NULL;
- x_clear_errors (FRAME_X_DISPLAY (f));
- }
- x_uncatch_errors ();
- UNBLOCK_INPUT;
- if (!font)
- return NULL;
-
- /* Find a free slot in the font table. */
- for (i = 0; i < dpyinfo->n_fonts; ++i)
- if (dpyinfo->font_table[i].name == NULL)
- break;
-
- /* If no free slot found, maybe enlarge the font table. */
- if (i == dpyinfo->n_fonts
- && dpyinfo->n_fonts == dpyinfo->font_table_size)
- {
- int sz;
- dpyinfo->font_table_size = max (16, 2 * dpyinfo->font_table_size);
- sz = dpyinfo->font_table_size * sizeof *dpyinfo->font_table;
- dpyinfo->font_table
- = (struct font_info *) xrealloc (dpyinfo->font_table, sz);
- }
-
- fontp = dpyinfo->font_table + i;
- if (i == dpyinfo->n_fonts)
- ++dpyinfo->n_fonts;
-
- /* Now fill in the slots of *FONTP. */
- BLOCK_INPUT;
- bzero (fontp, sizeof (*fontp));
- fontp->font = font;
- fontp->font_idx = i;
- fontp->charset = -1; /* fs_load_font sets it. */
- fontp->name = (char *) xmalloc (strlen (fontname) + 1);
- bcopy (fontname, fontp->name, strlen (fontname) + 1);
-
- if (font->min_bounds.width == font->max_bounds.width)
- {
- /* Fixed width font. */
- fontp->average_width = fontp->space_width = font->min_bounds.width;
- }
- else
- {
- XChar2b char2b;
- XCharStruct *pcm;
-
- char2b.byte1 = 0x00, char2b.byte2 = 0x20;
- pcm = x_per_char_metric (font, &char2b, 0);
- if (pcm)
- fontp->space_width = pcm->width;
- else
- fontp->space_width = FONT_WIDTH (font);
-
- fontp->average_width
- = (XGetFontProperty (font, dpyinfo->Xatom_AVERAGE_WIDTH, &value)
- ? (long) value / 10 : 0);
- if (fontp->average_width < 0)
- fontp->average_width = - fontp->average_width;
- if (fontp->average_width == 0)
- {
- if (pcm)
- {
- int width = pcm->width;
- for (char2b.byte2 = 33; char2b.byte2 <= 126; char2b.byte2++)
- if ((pcm = x_per_char_metric (font, &char2b, 0)) != NULL)
- width += pcm->width;
- fontp->average_width = width / 95;
- }
- else
- fontp->average_width = FONT_WIDTH (font);
- }
- }
-
- /* Try to get the full name of FONT. Put it in FULL_NAME. */
- full_name = 0;
- if (XGetFontProperty (font, XA_FONT, &value))
- {
- char *name = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
- char *p = name;
- int dashes = 0;
-
- /* Count the number of dashes in the "full name".
- If it is too few, this isn't really the font's full name,
- so don't use it.
- In X11R4, the fonts did not come with their canonical names
- stored in them. */
- while (*p)
- {
- if (*p == '-')
- dashes++;
- p++;
- }
-
- if (dashes >= 13)
- {
- full_name = (char *) xmalloc (p - name + 1);
- bcopy (name, full_name, p - name + 1);
- }
-
- XFree (name);
- }
-
- if (full_name != 0)
- fontp->full_name = full_name;
- else
- fontp->full_name = fontp->name;
-
- fontp->size = font->max_bounds.width;
- fontp->height = FONT_HEIGHT (font);
-
- if (NILP (font_names))
- {
- /* We come here because of a bug of XListFonts mentioned at
- the head of this block. Let's store this information in
- the cache for x_list_fonts. */
- Lisp_Object lispy_name = build_string (fontname);
- Lisp_Object lispy_full_name = build_string (fontp->full_name);
- Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
- Qnil);
-
- XSETCDR (dpyinfo->name_list_element,
- Fcons (Fcons (key,
- Fcons (Fcons (lispy_full_name,
- make_number (fontp->size)),
- Qnil)),
- XCDR (dpyinfo->name_list_element)));
- if (full_name)
- {
- key = Fcons (Fcons (lispy_full_name, make_number (256)),
- Qnil);
- XSETCDR (dpyinfo->name_list_element,
- Fcons (Fcons (key,
- Fcons (Fcons (lispy_full_name,
- make_number (fontp->size)),
- Qnil)),
- XCDR (dpyinfo->name_list_element)));
- }
- }
-
- /* The slot `encoding' specifies how to map a character
- code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
- the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
- (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
- 2:0xA020..0xFF7F). For the moment, we don't know which charset
- uses this font. So, we set information in fontp->encoding_type
- which is never used by any charset. If mapping can't be
- decided, set FONT_ENCODING_NOT_DECIDED. */
- fontp->encoding_type
- = (font->max_byte1 == 0
- /* 1-byte font */
- ? (font->min_char_or_byte2 < 0x80
- ? (font->max_char_or_byte2 < 0x80
- ? 0 /* 0x20..0x7F */
- : FONT_ENCODING_NOT_DECIDED) /* 0x20..0xFF */
- : 1) /* 0xA0..0xFF */
- /* 2-byte font */
- : (font->min_byte1 < 0x80
- ? (font->max_byte1 < 0x80
- ? (font->min_char_or_byte2 < 0x80
- ? (font->max_char_or_byte2 < 0x80
- ? 0 /* 0x2020..0x7F7F */
- : FONT_ENCODING_NOT_DECIDED) /* 0x2020..0x7FFF */
- : 3) /* 0x20A0..0x7FFF */
- : FONT_ENCODING_NOT_DECIDED) /* 0x20??..0xA0?? */
- : (font->min_char_or_byte2 < 0x80
- ? (font->max_char_or_byte2 < 0x80
- ? 2 /* 0xA020..0xFF7F */
- : FONT_ENCODING_NOT_DECIDED) /* 0xA020..0xFFFF */
- : 1))); /* 0xA0A0..0xFFFF */
-
- fontp->baseline_offset
- = (XGetFontProperty (font, dpyinfo->Xatom_MULE_BASELINE_OFFSET, &value)
- ? (long) value : 0);
- fontp->relative_compose
- = (XGetFontProperty (font, dpyinfo->Xatom_MULE_RELATIVE_COMPOSE, &value)
- ? (long) value : 0);
- fontp->default_ascent
- = (XGetFontProperty (font, dpyinfo->Xatom_MULE_DEFAULT_ASCENT, &value)
- ? (long) value : 0);
-
- /* Set global flag fonts_changed_p to non-zero if the font loaded
- has a character with a smaller width than any other character
- before, or if the font loaded has a smaller height than any
- other font loaded before. If this happens, it will make a
- glyph matrix reallocation necessary. */
- fonts_changed_p |= x_compute_min_glyph_bounds (f);
- UNBLOCK_INPUT;
- return fontp;
- }
-}
-
-
-/* Return a pointer to struct font_info of a font named FONTNAME for
- frame F. If no such font is loaded, return NULL. */
-
-struct font_info *
-x_query_font (f, fontname)
- struct frame *f;
- register char *fontname;
-{
- struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
- int i;
-
- for (i = 0; i < dpyinfo->n_fonts; i++)
- if (dpyinfo->font_table[i].name
- && (!xstricmp (dpyinfo->font_table[i].name, fontname)
- || !xstricmp (dpyinfo->font_table[i].full_name, fontname)))
- return (dpyinfo->font_table + i);
- return NULL;
-}
-
-
-/* Find a CCL program for a font specified by FONTP, and set the member
- `encoder' of the structure. */
-
-void
-x_find_ccl_program (fontp)
- struct font_info *fontp;
-{
- Lisp_Object list, elt;
-
- elt = Qnil;
- for (list = Vfont_ccl_encoder_alist; CONSP (list); list = XCDR (list))
- {
- elt = XCAR (list);
- if (CONSP (elt)
- && STRINGP (XCAR (elt))
- && ((fast_c_string_match_ignore_case (XCAR (elt), fontp->name)
- >= 0)
- || (fast_c_string_match_ignore_case (XCAR (elt), fontp->full_name)
- >= 0)))
- break;
- }
-
- if (! NILP (list))
- {
- struct ccl_program *ccl
- = (struct ccl_program *) xmalloc (sizeof (struct ccl_program));
-
- if (setup_ccl_program (ccl, XCDR (elt)) < 0)
- xfree (ccl);
- else
- fontp->font_encoder = ccl;
- }
-}
-
-
-/* Return a char-table whose elements are t if the font FONT_INFO
- contains a glyph for the corresponding character, and nil if
- not. */
-
-Lisp_Object
-x_get_font_repertory (f, font_info)
- FRAME_PTR f;
- struct font_info *font_info;
-{
- XFontStruct *font = (XFontStruct *) font_info->font;
- Lisp_Object table;
- int min_byte1, max_byte1, min_byte2, max_byte2;
- int c;
- struct charset *charset = CHARSET_FROM_ID (font_info->charset);
- int offset = CHARSET_OFFSET (charset);
-
- table = Fmake_char_table (Qnil, Qnil);
-
- min_byte1 = font->min_byte1;
- max_byte1 = font->max_byte1;
- min_byte2 = font->min_char_or_byte2;
- max_byte2 = font->max_char_or_byte2;
- if (min_byte1 == 0 && max_byte1 == 0)
- {
- if (! font->per_char || font->all_chars_exist == True)
- {
- if (offset >= 0)
- char_table_set_range (table, offset + min_byte2,
- offset + max_byte2, Qt);
- else
- for (; min_byte2 <= max_byte2; min_byte2++)
- {
- c = DECODE_CHAR (charset, min_byte2);
- CHAR_TABLE_SET (table, c, Qt);
- }
- }
- else
- {
- XCharStruct *pcm = font->per_char;
- int from = -1;
- int i;
-
- for (i = min_byte2; i <= max_byte2; i++, pcm++)
- {
- if (pcm->width == 0 && pcm->rbearing == pcm->lbearing)
- {
- if (from >= 0)
- {
- if (offset >= 0)
- char_table_set_range (table, offset + from,
- offset + i - 1, Qt);
- else
- for (; from < i; from++)
- {
- c = DECODE_CHAR (charset, from);
- CHAR_TABLE_SET (table, c, Qt);
- }
- from = -1;
- }
- }
- else if (from < 0)
- from = i;
- }
- if (from >= 0)
- {
- if (offset >= 0)
- char_table_set_range (table, offset + from, offset + i - 1,
- Qt);
- else
- for (; from < i; from++)
- {
- c = DECODE_CHAR (charset, from);
- CHAR_TABLE_SET (table, c, Qt);
- }
- }
- }
- }
- else
- {
- if (! font->per_char || font->all_chars_exist == True)
- {
- int i, j;
-
- if (offset >= 0)
- for (i = min_byte1; i <= max_byte1; i++)
- char_table_set_range
- (table, offset + ((i << 8) | min_byte2),
- offset + ((i << 8) | max_byte2), Qt);
- else
- for (i = min_byte1; i <= max_byte1; i++)
- for (j = min_byte2; j <= max_byte2; j++)
- {
- unsigned code = (i << 8) | j;
- c = DECODE_CHAR (charset, code);
- CHAR_TABLE_SET (table, c, Qt);
- }
- }
- else
- {
- XCharStruct *pcm = font->per_char;
- int i;
-
- for (i = min_byte1; i <= max_byte1; i++)
- {
- int from = -1;
- int j;
-
- for (j = min_byte2; j <= max_byte2; j++, pcm++)
- {
- if (pcm->width == 0 && pcm->rbearing == pcm->lbearing)
- {
- if (from >= 0)
- {
- if (offset >= 0)
- char_table_set_range
- (table, offset + ((i << 8) | from),
- offset + ((i << 8) | (j - 1)), Qt);
- else
- {
- for (; from < j; from++)
- {
- unsigned code = (i << 8) | from;
- c = ENCODE_CHAR (charset, code);
- CHAR_TABLE_SET (table, c, Qt);
- }
- }
- from = -1;
- }
- }
- else if (from < 0)
- from = j;
- }
- if (from >= 0)
- {
- if (offset >= 0)
- char_table_set_range
- (table, offset + ((i << 8) | from),
- offset + ((i << 8) | (j - 1)), Qt);
- else
- {
- for (; from < j; from++)
- {
- unsigned code = (i << 8) | from;
- c = DECODE_CHAR (charset, code);
- CHAR_TABLE_SET (table, c, Qt);
- }
- }
- }
- }
- }
- }
-
- return table;
-}
\f
/***********************************************************************
Initialization
static int x_session_initialized;
#endif
-#ifdef MULTI_KBOARD
/* Test whether two display-name strings agree up to the dot that separates
the screen number from the server number. */
static int
&& (*name1 == '.' || *name1 == '\0')
&& (*name2 == '.' || *name2 == '\0'));
}
-#endif
/* Count number of set bits in mask and number of bits to shift to
get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
GdkAtom atom;
#ifndef HAVE_GTK_MULTIDISPLAY
- if (!EQ (Vinitial_window_system, intern ("x")))
+ if (!EQ (Vinitial_window_system, Qx))
error ("Sorry, you cannot connect to X servers with the GTK toolkit");
#endif
terminal = x_create_terminal (dpyinfo);
-#ifdef MULTI_KBOARD
{
struct x_display_info *share;
Lisp_Object tail;
{
terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
init_kboard (terminal->kboard);
- terminal->kboard->Vwindow_system = intern ("x");
+ terminal->kboard->Vwindow_system = Qx;
if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
{
char *vendor = ServerVendor (dpy);
+ /* Temporarily hide the partially initialized terminal */
+ terminal_list = terminal->next_terminal;
UNBLOCK_INPUT;
terminal->kboard->Vsystem_key_alist
= call1 (Qvendor_specific_keysyms,
vendor ? build_string (vendor) : empty_unibyte_string);
BLOCK_INPUT;
+ terminal->next_terminal = terminal_list;
+ terminal_list = terminal;
}
terminal->kboard->next_kboard = all_kboards;
}
terminal->kboard->reference_count++;
}
-#endif
/* Put this display on the chain. */
dpyinfo->next = x_display_list;
terminal->name = (char *) xmalloc (SBYTES (display_name) + 1);
strncpy (terminal->name, SDATA (display_name), SBYTES (display_name));
terminal->name[SBYTES (display_name)] = 0;
-
+
#if 0
XSetAfterFunction (x_current_display, x_trace_wire);
#endif /* ! 0 */
DefaultScreen (dpyinfo->display));
select_visual (dpyinfo);
dpyinfo->cmap = DefaultColormapOfScreen (dpyinfo->screen);
- dpyinfo->height = HeightOfScreen (dpyinfo->screen);
- dpyinfo->width = WidthOfScreen (dpyinfo->screen);
dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
dpyinfo->client_leader_window = 0;
dpyinfo->grabbed = 0;
dpyinfo->reference_count = 0;
dpyinfo->icon_bitmap_id = -1;
- dpyinfo->font_table = NULL;
dpyinfo->n_fonts = 0;
- dpyinfo->font_table_size = 0;
-#ifdef USE_FONT_BACKEND
- dpyinfo->font = XLoadQueryFont (dpyinfo->display, "fixed");
- if (! dpyinfo->font)
- dpyinfo->font = XLoadQueryFont (dpyinfo->display, "*");
- if (! dpyinfo->font)
- abort ();
-#endif /* USE_FONT_BACKEND */
dpyinfo->bitmaps = 0;
dpyinfo->bitmaps_size = 0;
dpyinfo->bitmaps_last = 0;
dpyinfo->x_focus_frame = 0;
dpyinfo->x_focus_event_frame = 0;
dpyinfo->x_highlight_frame = 0;
- dpyinfo->terminal->image_cache = make_image_cache ();
dpyinfo->wm_type = X_WMTYPE_UNKNOWN;
/* See if we can construct pixel values from RGB values. */
dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
dpyinfo->visual, AllocNone);
+#ifdef HAVE_XFT
{
- int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
- double pixels = DisplayHeight (dpyinfo->display, screen_number);
- double mm = DisplayHeightMM (dpyinfo->display, screen_number);
- /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
- dpyinfo->resy = (mm < 1) ? 100 : pixels * 25.4 / mm;
- pixels = DisplayWidth (dpyinfo->display, screen_number);
- mm = DisplayWidthMM (dpyinfo->display, screen_number);
- /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
- dpyinfo->resx = (mm < 1) ? 100 : pixels * 25.4 / mm;
+ /* If we are using Xft, check dpi value in X resources.
+ It is better we use it as well, since Xft will use it, as will all
+ Gnome applications. If our real DPI is smaller or larger than the
+ one Xft uses, our font will look smaller or larger than other
+ for other applications, even if it is the same font name (monospace-10
+ for example). */
+ char *v = XGetDefault (dpyinfo->display, "Xft", "dpi");
+ double d;
+ if (v != NULL && sscanf (v, "%lf", &d) == 1)
+ dpyinfo->resy = dpyinfo->resx = d;
}
+#endif
+
+ if (dpyinfo->resy < 1)
+ {
+ int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
+ double pixels = DisplayHeight (dpyinfo->display, screen_number);
+ double mm = DisplayHeightMM (dpyinfo->display, screen_number);
+ /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
+ dpyinfo->resy = (mm < 1) ? 100 : pixels * 25.4 / mm;
+ pixels = DisplayWidth (dpyinfo->display, screen_number);
+ mm = DisplayWidthMM (dpyinfo->display, screen_number);
+ /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
+ dpyinfo->resx = (mm < 1) ? 100 : pixels * 25.4 / mm;
+ }
dpyinfo->Xatom_wm_protocols
= XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
dpyinfo->Xatom_XEMBED = XInternAtom (dpyinfo->display, "_XEMBED",
False);
+ dpyinfo->Xatom_net_wm_state
+ = XInternAtom (dpyinfo->display, "_NET_WM_STATE", False);
+ dpyinfo->Xatom_net_wm_state_fullscreen_atom
+ = XInternAtom (dpyinfo->display, "_NET_WM_STATE_FULLSCREEN", False);
+ dpyinfo->Xatom_net_wm_state_maximized_horz
+ = XInternAtom (dpyinfo->display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+ dpyinfo->Xatom_net_wm_state_maximized_vert
+ = XInternAtom (dpyinfo->display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
+ dpyinfo->Xatom_net_wm_state_sticky
+ = XInternAtom (dpyinfo->display, "_NET_WM_STATE_STICKY", False);
+
dpyinfo->cut_buffers_initialized = 0;
dpyinfo->x_dnd_atoms_size = 8;
connection = ConnectionNumber (dpyinfo->display);
dpyinfo->connection = connection;
- {
- char null_bits[1];
-
- null_bits[0] = 0x00;
-
- dpyinfo->null_pixel
- = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
- null_bits, 1, 1, (long) 0, (long) 0,
- 1);
- }
-
{
extern int gray_bitmap_width, gray_bitmap_height;
extern char *gray_bitmap_bits;
xim_initialize (dpyinfo, resource_name);
#endif
+ xsettings_initialize (dpyinfo);
+
#ifdef subprocesses
/* This is only needed for distinguishing keyboard and process input. */
if (connection != 0)
tail->next = tail->next->next;
}
-#ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
-#ifndef AIX /* On AIX, XCloseDisplay calls this. */
- XrmDestroyDatabase (dpyinfo->xrdb);
-#endif
-#endif
-#ifdef HAVE_X_I18N
- if (dpyinfo->xim)
- xim_close_dpy (dpyinfo);
-#endif
-
-#ifdef USE_FONT_BACKEND
- if (! enable_font_backend)
- {
-#endif
- /* Free the font names in the font table. */
- for (i = 0; i < dpyinfo->n_fonts; i++)
- if (dpyinfo->font_table[i].name)
- {
- if (dpyinfo->font_table[i].name != dpyinfo->font_table[i].full_name)
- xfree (dpyinfo->font_table[i].full_name);
- xfree (dpyinfo->font_table[i].name);
- }
-
- if (dpyinfo->font_table)
- {
- if (dpyinfo->font_table->font_encoder)
- xfree (dpyinfo->font_table->font_encoder);
- xfree (dpyinfo->font_table);
- }
-#ifdef USE_FONT_BACKEND
- }
-#endif
-
- if (dpyinfo->x_id_name)
- xfree (dpyinfo->x_id_name);
- if (dpyinfo->color_cells)
- xfree (dpyinfo->color_cells);
+ xfree (dpyinfo->x_id_name);
+ xfree (dpyinfo->x_dnd_atoms);
+ xfree (dpyinfo->color_cells);
xfree (dpyinfo);
}
x_draw_fringe_bitmap,
0, /* define_fringe_bitmap */
0, /* destroy_fringe_bitmap */
- x_per_char_metric,
- x_encode_char,
x_compute_glyph_string_overhangs,
x_draw_glyph_string,
x_define_frame_cursor,
struct x_display_info *dpyinfo = terminal->display_info.x;
int i;
- /* Protect against recursive calls. Fdelete_frame in
+ /* Protect against recursive calls. delete_frame in
delete_terminal calls us back when it deletes our last frame. */
if (!terminal->name)
return;
BLOCK_INPUT;
+#ifdef HAVE_X_I18N
+ /* We must close our connection to the XIM server before closing the
+ X display. */
+ if (dpyinfo->xim)
+ xim_close_dpy (dpyinfo);
+#endif
+
/* If called from x_connection_closed, the display may already be closed
and dpyinfo->display was set to 0 to indicate that. */
if (dpyinfo->display)
{
-#ifdef USE_FONT_BACKEND
- if (enable_font_backend)
- XFreeFont (dpyinfo->display, dpyinfo->font);
- else
-#endif
- /* Free the fonts in the font table. */
- for (i = 0; i < dpyinfo->n_fonts; i++)
- if (dpyinfo->font_table[i].name)
- {
- XFreeFont (dpyinfo->display, dpyinfo->font_table[i].font);
- }
-
x_destroy_all_bitmaps (dpyinfo);
XSetCloseDownMode (dpyinfo->display, DestroyAll);
+ /* Whether or not XCloseDisplay destroys the associated resource
+ database depends on the version of libX11. To avoid both
+ crash and memory leak, we dissociate the database from the
+ display and then destroy dpyinfo->xrdb ourselves.
+
+ Unfortunately, the above strategy does not work in some
+ situations due to a bug in newer versions of libX11: because
+ XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
+ dpy->db is NULL, XCloseDisplay destroys the associated
+ database whereas it has not been created by XGetDefault
+ (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
+ don't destroy the database here in order to avoid the crash
+ in the above situations for now, though that may cause memory
+ leaks in other situations. */
+#if 0
+#ifdef HAVE_XRMSETDATABASE
+ XrmSetDatabase (dpyinfo->display, NULL);
+#else
+ dpyinfo->display->db = NULL;
+#endif
+ /* We used to call XrmDestroyDatabase from x_delete_display, but
+ some older versions of libX11 crash if we call it after
+ closing all the displays. */
+ XrmDestroyDatabase (dpyinfo->xrdb);
+#endif
+
#ifdef USE_GTK
xg_display_close (dpyinfo->display);
#else
x_create_terminal (struct x_display_info *dpyinfo)
{
struct terminal *terminal;
-
+
terminal = create_terminal ();
terminal->type = output_x_window;
dpyinfo->terminal = terminal;
/* kboard is initialized in x_term_init. */
-
+
terminal->clear_frame_hook = x_clear_frame;
terminal->ins_del_lines_hook = x_ins_del_lines;
terminal->delete_glyphs_hook = x_delete_glyphs;
terminal->ring_bell_hook = XTring_bell;
+ terminal->toggle_invisible_pointer_hook = XTtoggle_invisible_pointer;
terminal->reset_terminal_modes_hook = XTreset_terminal_modes;
terminal->set_terminal_modes_hook = XTset_terminal_modes;
terminal->update_begin_hook = x_update_begin;
terminal->delete_frame_hook = x_destroy_window;
terminal->delete_terminal_hook = x_delete_terminal;
-
+
terminal->rif = &x_redisplay_interface;
terminal->scroll_region_ok = 1; /* We'll scroll partial frames. */
terminal->char_ins_del_ok = 1;
#endif
#endif
+ pending_autoraise_frame = 0;
+ pending_event_wait.f = 0;
+ pending_event_wait.eventtype = 0;
+
/* Note that there is no real way portable across R3/R4 to get the
original error handler. */
XSetErrorHandler (x_error_handler);
XSetIOErrorHandler (x_io_error_quitter);
- /* Disable Window Change signals; they are handled by X events. */
-#if 0 /* Don't. We may want to open tty frames later. */
-#ifdef SIGWINCH
- signal (SIGWINCH, SIG_DFL);
-#endif /* SIGWINCH */
-#endif
-
signal (SIGPIPE, x_connection_signal);
}
last_mouse_scroll_bar = Qnil;
staticpro (&Qvendor_specific_keysyms);
- Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
+ Qvendor_specific_keysyms = intern_c_string ("vendor-specific-keysyms");
staticpro (&Qlatin_1);
- Qlatin_1 = intern ("latin-1");
+ Qlatin_1 = intern_c_string ("latin-1");
staticpro (&last_mouse_press_frame);
last_mouse_press_frame = Qnil;
+#ifdef USE_GTK
+ xg_default_icon_file = make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
+ staticpro (&xg_default_icon_file);
+
+ Qx_gtk_map_stock = intern_c_string ("x-gtk-map-stock");
+ staticpro (&Qx_gtk_map_stock);
+#endif
+
DEFVAR_BOOL ("x-use-underline-position-properties",
&x_use_underline_position_properties,
doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
A value of nil means ignore them. If you encounter fonts with bogus
UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
-to 4.1, set this to nil. */);
+to 4.1, set this to nil. You can also use `underline-minimum-offset'
+to override the font's UNDERLINE_POSITION for small font display
+sizes. */);
x_use_underline_position_properties = 1;
DEFVAR_BOOL ("x-underline-at-descent-line",
Otherwise, value is a symbol describing the X toolkit. */);
#ifdef USE_TOOLKIT_SCROLL_BARS
#ifdef USE_MOTIF
- Vx_toolkit_scroll_bars = intern ("motif");
+ Vx_toolkit_scroll_bars = intern_c_string ("motif");
#elif defined HAVE_XAW3D
- Vx_toolkit_scroll_bars = intern ("xaw3d");
+ Vx_toolkit_scroll_bars = intern_c_string ("xaw3d");
#elif USE_GTK
- Vx_toolkit_scroll_bars = intern ("gtk");
+ Vx_toolkit_scroll_bars = intern_c_string ("gtk");
#else
- Vx_toolkit_scroll_bars = intern ("xaw");
+ Vx_toolkit_scroll_bars = intern_c_string ("xaw");
#endif
#else
Vx_toolkit_scroll_bars = Qnil;
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;
- Qmodifier_value = intern ("modifier-value");
- Qalt = intern ("alt");
+ Qmodifier_value = intern_c_string ("modifier-value");
+ Qalt = intern_c_string ("alt");
Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
- Qhyper = intern ("hyper");
+ Qhyper = intern_c_string ("hyper");
Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
- Qmeta = intern ("meta");
+ Qmeta = intern_c_string ("meta");
Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
- Qsuper = intern ("super");
+ Qsuper = intern_c_string ("super");
Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym,
HCoop / bpt / emacs.git / blobdiff