#include <config.h>
#include <signal.h>
#include <stdio.h>
#ifdef HAVE_X_WINDOWS
#include "lisp.h"
#include "blockinput.h"
#include "syssignal.h"
#include "xterm.h"
#include <X11/cursorfont.h>
#ifndef makedev
#include <sys/types.h>
#endif
#ifdef BSD_SYSTEM
#include <sys/ioctl.h>
#endif
#include "systty.h"
#include "systime.h"
#ifndef INCLUDED_FCNTL
#include <fcntl.h>
#endif
#include <ctype.h>
#include <errno.h>
#include <setjmp.h>
#include <sys/stat.h>
#include "charset.h"
#include "coding.h"
#include "ccl.h"
#include "frame.h"
#include "dispextern.h"
#include "fontset.h"
#include "termhooks.h"
#include "termopts.h"
#include "termchar.h"
#include "gnu.h"
#include "disptab.h"
#include "buffer.h"
#include "window.h"
#include "keyboard.h"
#include "intervals.h"
#include "process.h"
#include "atimer.h"
#include "keymap.h"
#ifdef USE_X_TOOLKIT
#include <X11/Shell.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef USE_GTK
#include "gtkutil.h"
#endif
#ifdef USE_LUCID
extern int xlwmenu_window_p P_ ((Widget w, Window window));
extern void xlwmenu_redisplay P_ ((Widget));
#endif
#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)
#define HACK_EDITRES
extern void _XEditResCheckMessages ();
#endif
#ifdef USE_TOOLKIT_SCROLL_BARS
#if defined USE_MOTIF
#include <Xm/Xm.h>
#include <Xm/ScrollBar.h>
#else
#ifdef HAVE_XAW3D
#include <X11/Xaw3d/Simple.h>
#include <X11/Xaw3d/Scrollbar.h>
#include <X11/Xaw3d/ThreeD.h>
#else
#include <X11/Xaw/Simple.h>
#include <X11/Xaw/Scrollbar.h>
#endif
#ifndef XtNpickTop
#define XtNpickTop "pickTop"
#endif
#endif
#endif
#endif
#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
#define XtNinitialState "initialState"
#endif
#endif
#define abs(x) ((x) < 0 ? -(x) : (x))
#ifdef USE_XIM
int use_xim = 1;
#else
int use_xim = 0;
#endif
Lisp_Object Vx_toolkit_scroll_bars;
static int any_help_event_p;
static Lisp_Object last_window;
int x_use_underline_position_properties;
int x_underline_at_descent_line;
struct x_display_info *x_display_list;
Lisp_Object x_display_name_list;
extern struct frame *updating_frame;
struct frame *pending_autoraise_frame;
#ifdef USE_X_TOOLKIT
XtAppContext Xt_app_con;
static String Xt_default_resources[] = {0};
#endif
static int toolkit_scroll_bar_interaction;
int x_mouse_click_focus_ignore_position;
static unsigned long ignore_next_mouse_click_timeout;
static XRectangle last_mouse_glyph;
static FRAME_PTR last_mouse_glyph_frame;
static Lisp_Object last_mouse_press_frame;
static Lisp_Object last_mouse_scroll_bar;
static Time last_mouse_movement_time;
static Time last_user_time;
#ifdef __STDC__
static int volatile input_signal_count;
#else
static int input_signal_count;
#endif
static int x_noop_count;
extern char **initial_argv;
extern int initial_argc;
extern Lisp_Object Vcommand_line_args, Vsystem_name;
extern Lisp_Object Vx_no_window_manager;
extern Lisp_Object Qeql;
extern int errno;
extern EMACS_INT extra_keyboard_modifiers;
Lisp_Object Vx_alt_keysym, Vx_hyper_keysym, Vx_meta_keysym, Vx_super_keysym;
Lisp_Object Vx_keysym_table;
static Lisp_Object Qalt, Qhyper, Qmeta, Qsuper, Qmodifier_value;
static Lisp_Object Qvendor_specific_keysyms;
static Lisp_Object Qlatin_1;
extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
extern int x_bitmap_mask P_ ((FRAME_PTR, int));
static int x_alloc_nearest_color_1 P_ ((Display *, Colormap, XColor *));
static void x_set_window_size_1 P_ ((struct frame *, int, int, int));
static const XColor *x_color_cells P_ ((Display *, int *));
static void x_update_window_end P_ ((struct window *, int, int));
static int x_io_error_quitter P_ ((Display *));
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_ ((void));
static void XTreset_terminal_modes P_ ((void));
static void x_clear_frame P_ ((void));
static void frame_highlight P_ ((struct frame *));
static void frame_unhighlight P_ ((struct frame *));
static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
static void x_focus_changed P_ ((int, int, struct x_display_info *,
struct frame *, struct input_event *));
static void x_detect_focus_change P_ ((struct x_display_info *,
XEvent *, struct input_event *));
static void XTframe_rehighlight P_ ((struct frame *));
static void x_frame_rehighlight P_ ((struct x_display_info *));
static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
enum text_cursor_kinds));
static void x_clip_to_row P_ ((struct window *, struct glyph_row *, int, GC));
static void x_flush P_ ((struct frame *f));
static void x_update_begin P_ ((struct frame *));
static void x_update_window_begin P_ ((struct window *));
static void x_after_update_window_line P_ ((struct glyph_row *));
static struct scroll_bar *x_window_to_scroll_bar P_ ((Display *, Window));
static void x_scroll_bar_report_motion P_ ((struct frame **, Lisp_Object *,
enum scroll_bar_part *,
Lisp_Object *, Lisp_Object *,
unsigned long *));
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));
static int handle_one_xevent P_ ((struct x_display_info *, XEvent *,
int *, struct input_event *));
static SIGTYPE x_connection_closed P_ ((Display *, char *));
static void
x_flush (f)
struct frame *f;
{
BLOCK_INPUT;
if (f == NULL)
{
Lisp_Object rest, frame;
FOR_EACH_FRAME (rest, frame)
x_flush (XFRAME (frame));
}
else if (FRAME_X_P (f))
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
#define XFlush(DISPLAY) (void) 0
#if 0
struct record
{
char *locus;
int type;
};
struct record event_record[100];
int event_record_index;
record_event (locus, type)
char *locus;
int type;
{
if (event_record_index == sizeof (event_record) / sizeof (struct record))
event_record_index = 0;
event_record[event_record_index].locus = locus;
event_record[event_record_index].type = type;
event_record_index++;
}
#endif
struct x_display_info *
x_display_info_for_display (dpy)
Display *dpy;
{
struct x_display_info *dpyinfo;
for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
if (dpyinfo->display == dpy)
return dpyinfo;
return 0;
}
static void
x_update_begin (f)
struct frame *f;
{
}
static void
x_update_window_begin (w)
struct window *w;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
updated_window = w;
set_output_cursor (&w->cursor);
BLOCK_INPUT;
if (f == display_info->mouse_face_mouse_frame)
{
display_info->mouse_face_defer = 1;
if (FRAME_GARBAGED_P (f))
display_info->mouse_face_window = Qnil;
#if 0
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
}
UNBLOCK_INPUT;
}
static void
x_draw_vertical_window_border (w, x, y0, y1)
struct window *w;
int x, y0, y1;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct face *face;
face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
if (face)
XSetForeground (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
face->foreground);
XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc, x, y0, x, y1);
}
static void
x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
struct window *w;
int cursor_on_p, mouse_face_overwritten_p;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
if (!w->pseudo_window_p)
{
BLOCK_INPUT;
if (cursor_on_p)
display_and_set_cursor (w, 1, output_cursor.hpos,
output_cursor.vpos,
output_cursor.x, output_cursor.y);
if (draw_window_fringes (w, 1))
x_draw_vertical_border (w);
UNBLOCK_INPUT;
}
if (mouse_face_overwritten_p)
{
dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
dpyinfo->mouse_face_window = Qnil;
}
updated_window = NULL;
}
static void
x_update_end (f)
struct frame *f;
{
FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
#ifndef XFlush
BLOCK_INPUT;
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
#endif
}
static void
XTframe_up_to_date (f)
struct frame *f;
{
if (FRAME_X_P (f))
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (dpyinfo->mouse_face_deferred_gc
|| f == dpyinfo->mouse_face_mouse_frame)
{
BLOCK_INPUT;
if (dpyinfo->mouse_face_mouse_frame)
note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
dpyinfo->mouse_face_mouse_x,
dpyinfo->mouse_face_mouse_y);
dpyinfo->mouse_face_deferred_gc = 0;
UNBLOCK_INPUT;
}
}
}
static void
x_after_update_window_line (desired_row)
struct glyph_row *desired_row;
{
struct window *w = updated_window;
struct frame *f;
int width, height;
xassert (w);
if (!desired_row->mode_line_p && !w->pseudo_window_p)
desired_row->redraw_fringe_bitmaps_p = 1;
if (windows_or_buffers_changed
&& desired_row->full_width_p
&& (f = XFRAME (w->frame),
width = FRAME_INTERNAL_BORDER_WIDTH (f),
width != 0)
&& (height = desired_row->visible_height,
height > 0))
{
int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
if (WINDOWP (f->tool_bar_window)
&& w == XWINDOW (f->tool_bar_window))
y -= width;
BLOCK_INPUT;
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
0, y, width, height, False);
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
FRAME_PIXEL_WIDTH (f) - width,
y, width, height, False);
UNBLOCK_INPUT;
}
}
static void
x_draw_fringe_bitmap (w, row, p)
struct window *w;
struct glyph_row *row;
struct draw_fringe_bitmap_params *p;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
Display *display = FRAME_X_DISPLAY (f);
Window window = FRAME_X_WINDOW (f);
GC gc = f->output_data.x->normal_gc;
struct face *face = p->face;
int rowY;
rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
if (p->y < rowY)
{
int oldY = row->y;
int oldVH = row->visible_height;
row->visible_height = p->h;
row->y -= rowY - p->y;
x_clip_to_row (w, row, -1, gc);
row->y = oldY;
row->visible_height = oldVH;
}
else
x_clip_to_row (w, row, -1, gc);
if (p->bx >= 0 && !p->overlay_p)
{
if (face->stipple)
XSetFillStyle (display, face->gc, FillOpaqueStippled);
else
XSetForeground (display, face->gc, face->background);
XFillRectangle (display, window, face->gc,
p->bx, p->by, p->nx, p->ny);
if (!face->stipple)
XSetForeground (display, face->gc, face->foreground);
}
if (p->which)
{
unsigned char *bits;
Pixmap pixmap, clipmask = (Pixmap) 0;
int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
XGCValues gcv;
if (p->wd > 8)
bits = (unsigned char *)(p->bits + p->dh);
else
bits = (unsigned char *)p->bits + p->dh;
pixmap = XCreatePixmapFromBitmapData (display, window, bits, p->wd, p->h,
(p->cursor_p
? (p->overlay_p ? face->background
: f->output_data.x->cursor_pixel)
: face->foreground),
face->background, depth);
if (p->overlay_p)
{
clipmask = XCreatePixmapFromBitmapData (display,
FRAME_X_DISPLAY_INFO (f)->root_window,
bits, p->wd, p->h,
1, 0, 1);
gcv.clip_mask = clipmask;
gcv.clip_x_origin = p->x;
gcv.clip_y_origin = p->y;
XChangeGC (display, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
}
XCopyArea (display, pixmap, window, gc, 0, 0,
p->wd, p->h, p->x, p->y);
XFreePixmap (display, pixmap);
if (p->overlay_p)
{
gcv.clip_mask = (Pixmap) 0;
XChangeGC (display, gc, GCClipMask, &gcv);
XFreePixmap (display, clipmask);
}
}
XSetClipMask (display, gc, None);
}
static void
XTset_terminal_modes ()
{
}
static void
XTreset_terminal_modes ()
{
}
static int x_encode_char P_ ((int, XChar2b *, struct font_info *, int *));
static XCharStruct *
x_per_char_metric (font, char2b, font_type)
XFontStruct *font;
XChar2b *char2b;
int font_type;
{
XCharStruct *pcm = NULL;
xassert (font && char2b);
if (font->per_char != NULL)
{
if (font->min_byte1 == 0 && font->max_byte1 == 0)
{
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 (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 (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);
}
static int
x_encode_char (c, char2b, font_info, two_byte_p)
int c;
XChar2b *char2b;
struct font_info *font_info;
int *two_byte_p;
{
int charset = CHAR_CHARSET (c);
XFontStruct *font = font_info->font;
if (font_info->font_encoder)
{
struct ccl_program *ccl = font_info->font_encoder;
check_ccl_update (ccl);
if (CHARSET_DIMENSION (charset) == 1)
{
ccl->reg[0] = charset;
ccl->reg[1] = char2b->byte2;
ccl->reg[2] = -1;
}
else
{
ccl->reg[0] = charset;
ccl->reg[1] = char2b->byte1;
ccl->reg[2] = char2b->byte2;
}
ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
if (font->max_byte1 == 0)
char2b->byte1 = 0, char2b->byte2 = ccl->reg[1];
else
char2b->byte1 = ccl->reg[1], char2b->byte2 = ccl->reg[2];
}
else if (font_info->encoding[charset])
{
int enc = font_info->encoding[charset];
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;
}
static void x_set_glyph_string_clipping P_ ((struct glyph_string *));
static void x_set_glyph_string_gc P_ ((struct glyph_string *));
static void x_draw_glyph_string_background P_ ((struct glyph_string *,
int));
static void x_draw_glyph_string_foreground P_ ((struct glyph_string *));
static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *));
static void x_draw_glyph_string_box P_ ((struct glyph_string *));
static void x_draw_glyph_string P_ ((struct glyph_string *));
static void x_compute_glyph_string_overhangs P_ ((struct glyph_string *));
static void x_set_cursor_gc P_ ((struct glyph_string *));
static void x_set_mode_line_face_gc P_ ((struct glyph_string *));
static void x_set_mouse_face_gc P_ ((struct glyph_string *));
static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
unsigned long *, double, int));
static void x_setup_relief_color P_ ((struct frame *, struct relief *,
double, int, unsigned long));
static void x_setup_relief_colors P_ ((struct glyph_string *));
static void x_draw_image_glyph_string P_ ((struct glyph_string *));
static void x_draw_image_relief P_ ((struct glyph_string *));
static void x_draw_image_foreground P_ ((struct glyph_string *));
static void x_draw_image_foreground_1 P_ ((struct glyph_string *, Pixmap));
static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
int, int, int));
static void x_draw_relief_rect P_ ((struct frame *, int, int, int, int,
int, int, int, int, int, int,
XRectangle *));
static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
int, int, int, XRectangle *));
#if GLYPH_DEBUG
static void x_check_font P_ ((struct frame *, XFontStruct *));
#endif
static void
x_set_cursor_gc (s)
struct glyph_string *s;
{
if (s->font == FRAME_FONT (s->f)
&& s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
&& s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
&& !s->cmp)
s->gc = s->f->output_data.x->cursor_gc;
else
{
XGCValues xgcv;
unsigned long mask;
xgcv.background = s->f->output_data.x->cursor_pixel;
xgcv.foreground = s->face->background;
if (xgcv.foreground == xgcv.background)
xgcv.foreground = s->face->foreground;
if (xgcv.foreground == xgcv.background)
xgcv.foreground = s->f->output_data.x->cursor_foreground_pixel;
if (xgcv.foreground == xgcv.background)
xgcv.foreground = s->face->foreground;
if (xgcv.background == s->face->background
&& xgcv.foreground == s->face->foreground)
{
xgcv.background = s->face->foreground;
xgcv.foreground = s->face->background;
}
IF_DEBUG (x_check_font (s->f, s->font));
xgcv.font = s->font->fid;
xgcv.graphics_exposures = False;
mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
mask, &xgcv);
else
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;
}
}
static void
x_set_mouse_face_gc (s)
struct glyph_string *s;
{
int face_id;
struct face *face;
face_id = FRAME_X_DISPLAY_INFO (s->f)->mouse_face_face_id;
face = FACE_FROM_ID (s->f, face_id);
if (face == NULL)
face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
if (s->first_glyph->type == CHAR_GLYPH)
face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
else
face_id = FACE_FOR_CHAR (s->f, face, 0);
s->face = FACE_FROM_ID (s->f, face_id);
PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
if (s->font == s->face->font)
s->gc = s->face->gc;
else
{
XGCValues xgcv;
unsigned long mask;
xgcv.background = s->face->background;
xgcv.foreground = s->face->foreground;
IF_DEBUG (x_check_font (s->f, s->font));
xgcv.font = s->font->fid;
xgcv.graphics_exposures = False;
mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
mask, &xgcv);
else
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);
}
static INLINE void
x_set_mode_line_face_gc (s)
struct glyph_string *s;
{
s->gc = s->face->gc;
}
static INLINE void
x_set_glyph_string_gc (s)
struct glyph_string *s;
{
PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
if (s->hl == DRAW_NORMAL_TEXT)
{
s->gc = s->face->gc;
s->stippled_p = s->face->stipple != 0;
}
else if (s->hl == DRAW_INVERSE_VIDEO)
{
x_set_mode_line_face_gc (s);
s->stippled_p = s->face->stipple != 0;
}
else if (s->hl == DRAW_CURSOR)
{
x_set_cursor_gc (s);
s->stippled_p = 0;
}
else if (s->hl == DRAW_MOUSE_FACE)
{
x_set_mouse_face_gc (s);
s->stippled_p = s->face->stipple != 0;
}
else if (s->hl == DRAW_IMAGE_RAISED
|| s->hl == DRAW_IMAGE_SUNKEN)
{
s->gc = s->face->gc;
s->stippled_p = s->face->stipple != 0;
}
else
{
s->gc = s->face->gc;
s->stippled_p = s->face->stipple != 0;
}
xassert (s->gc != 0);
}
static INLINE void
x_set_glyph_string_clipping (s)
struct glyph_string *s;
{
XRectangle r;
get_glyph_string_clip_rect (s, &r);
XSetClipRectangles (s->display, s->gc, 0, 0, &r, 1, Unsorted);
}
static void
x_compute_glyph_string_overhangs (s)
struct glyph_string *s;
{
if (s->cmp == NULL
&& s->first_glyph->type == CHAR_GLYPH)
{
XCharStruct cs;
int direction, font_ascent, font_descent;
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;
}
}
static INLINE void
x_clear_glyph_string_rect (s, x, y, w, h)
struct glyph_string *s;
int x, y, w, h;
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
XSetForeground (s->display, s->gc, xgcv.background);
XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
static void
x_draw_glyph_string_background (s, force_p)
struct glyph_string *s;
int force_p;
{
if (!s->background_filled_p)
{
int box_line_width = max (s->face->box_line_width, 0);
if (s->stippled_p)
{
XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
XFillRectangle (s->display, s->window, s->gc, s->x,
s->y + box_line_width,
s->background_width,
s->height - 2 * box_line_width);
XSetFillStyle (s->display, s->gc, FillSolid);
s->background_filled_p = 1;
}
else if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
|| s->font_not_found_p
|| s->extends_to_end_of_line_p
|| force_p)
{
x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
s->background_width,
s->height - 2 * box_line_width);
s->background_filled_p = 1;
}
}
}
static void
x_draw_glyph_string_foreground (s)
struct glyph_string *s;
{
int i, x;
if (s->face->box != FACE_NO_BOX
&& s->first_glyph->left_box_line_p)
x = s->x + abs (s->face->box_line_width);
else
x = s->x;
if (s->font_not_found_p)
{
for (i = 0; i < s->nchars; ++i)
{
struct glyph *g = s->first_glyph + i;
XDrawRectangle (s->display, s->window,
s->gc, x, s->y, g->pixel_width - 1,
s->height - 1);
x += g->pixel_width;
}
}
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 (!s->two_byte_p)
for (i = 0; i < s->nchars; ++i)
char1b[i] = s->char2b[i].byte2;
if (s->for_overlaps
|| (s->background_filled_p && s->hl != DRAW_CURSOR))
{
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)
{
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);
}
}
}
static void
x_draw_composite_glyph_string_foreground (s)
struct glyph_string *s;
{
int i, x;
if (s->face->box != FACE_NO_BOX
&& s->first_glyph->left_box_line_p)
x = s->x + abs (s->face->box_line_width);
else
x = s->x;
if (s->font_not_found_p)
{
if (s->gidx == 0)
XDrawRectangle (s->display, s->window, s->gc, x, s->y,
s->width - 1, s->height - 1);
}
else
{
for (i = 0; i < s->nchars; i++, ++s->gidx)
{
XDrawString16 (s->display, s->window, s->gc,
x + s->cmp->offsets[s->gidx * 2],
s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
s->char2b + i, 1);
if (s->face->overstrike)
XDrawString16 (s->display, s->window, s->gc,
x + s->cmp->offsets[s->gidx * 2] + 1,
s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
s->char2b + i, 1);
}
}
}
#ifdef USE_X_TOOLKIT
static struct frame *x_frame_of_widget P_ ((Widget));
static Boolean cvt_string_to_pixel P_ ((Display *, XrmValue *, Cardinal *,
XrmValue *, XrmValue *, XtPointer *));
static void cvt_pixel_dtor P_ ((XtAppContext, XrmValue *, XtPointer,
XrmValue *, Cardinal *));
static struct frame *
x_frame_of_widget (widget)
Widget widget;
{
struct x_display_info *dpyinfo;
Lisp_Object tail;
struct frame *f;
dpyinfo = x_display_info_for_display (XtDisplay (widget));
while (!XtIsTopLevelShell (widget))
widget = XtParent (widget);
for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
if (GC_FRAMEP (XCAR (tail))
&& (f = XFRAME (XCAR (tail)),
(f->output_data.nothing != 1
&& FRAME_X_DISPLAY_INFO (f) == dpyinfo))
&& f->output_data.x->widget == widget)
return f;
abort ();
}
int
x_alloc_nearest_color_for_widget (widget, cmap, color)
Widget widget;
Colormap cmap;
XColor *color;
{
struct frame *f = x_frame_of_widget (widget);
return x_alloc_nearest_color (f, cmap, color);
}
int
x_alloc_lighter_color_for_widget (widget, display, cmap, pixel, factor, delta)
Widget widget;
Display *display;
Colormap cmap;
unsigned long *pixel;
double factor;
int delta;
{
struct frame *f = x_frame_of_widget (widget);
return x_alloc_lighter_color (f, display, cmap, pixel, factor, delta);
}
static XtConvertArgRec cvt_string_to_pixel_args[] =
{
{XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.screen),
sizeof (Screen *)},
{XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.colormap),
sizeof (Colormap)}
};
static Pixel cvt_string_to_pixel_value;
static Boolean
cvt_string_to_pixel (dpy, args, nargs, from, to, closure_ret)
Display *dpy;
XrmValue *args;
Cardinal *nargs;
XrmValue *from, *to;
XtPointer *closure_ret;
{
Screen *screen;
Colormap cmap;
Pixel pixel;
String color_name;
XColor color;
if (*nargs != 2)
{
XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
"wrongParameters", "cvt_string_to_pixel",
"XtToolkitError",
"Screen and colormap args required", NULL, NULL);
return False;
}
screen = *(Screen **) args[0].addr;
cmap = *(Colormap *) args[1].addr;
color_name = (String) from->addr;
if (strcmp (color_name, XtDefaultBackground) == 0)
{
*closure_ret = (XtPointer) False;
pixel = WhitePixelOfScreen (screen);
}
else if (strcmp (color_name, XtDefaultForeground) == 0)
{
*closure_ret = (XtPointer) False;
pixel = BlackPixelOfScreen (screen);
}
else if (XParseColor (dpy, cmap, color_name, &color)
&& x_alloc_nearest_color_1 (dpy, cmap, &color))
{
pixel = color.pixel;
*closure_ret = (XtPointer) True;
}
else
{
String params[1];
Cardinal nparams = 1;
params[0] = color_name;
XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
"badValue", "cvt_string_to_pixel",
"XtToolkitError", "Invalid color `%s'",
params, &nparams);
return False;
}
if (to->addr != NULL)
{
if (to->size < sizeof (Pixel))
{
to->size = sizeof (Pixel);
return False;
}
*(Pixel *) to->addr = pixel;
}
else
{
cvt_string_to_pixel_value = pixel;
to->addr = (XtPointer) &cvt_string_to_pixel_value;
}
to->size = sizeof (Pixel);
return True;
}
static void
cvt_pixel_dtor (app, to, closure, args, nargs)
XtAppContext app;
XrmValuePtr to;
XtPointer closure;
XrmValuePtr args;
Cardinal *nargs;
{
if (*nargs != 2)
{
XtAppWarningMsg (app, "wrongParameters", "cvt_pixel_dtor",
"XtToolkitError",
"Screen and colormap arguments required",
NULL, NULL);
}
else if (closure != NULL)
{
Screen *screen = *(Screen **) args[0].addr;
Colormap cmap = *(Colormap *) args[1].addr;
x_free_dpy_colors (DisplayOfScreen (screen), screen, cmap,
(Pixel *) to->addr, 1);
}
}
#endif
static const XColor *
x_color_cells (dpy, ncells)
Display *dpy;
int *ncells;
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
if (dpyinfo->color_cells == NULL)
{
Screen *screen = dpyinfo->screen;
int i;
dpyinfo->ncolor_cells
= XDisplayCells (dpy, XScreenNumberOfScreen (screen));
dpyinfo->color_cells
= (XColor *) xmalloc (dpyinfo->ncolor_cells
* sizeof *dpyinfo->color_cells);
for (i = 0; i < dpyinfo->ncolor_cells; ++i)
dpyinfo->color_cells[i].pixel = i;
XQueryColors (dpy, dpyinfo->cmap,
dpyinfo->color_cells, dpyinfo->ncolor_cells);
}
*ncells = dpyinfo->ncolor_cells;
return dpyinfo->color_cells;
}
void
x_query_colors (f, colors, ncolors)
struct frame *f;
XColor *colors;
int ncolors;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (dpyinfo->color_cells)
{
int i;
for (i = 0; i < ncolors; ++i)
{
unsigned long pixel = colors[i].pixel;
xassert (pixel < dpyinfo->ncolor_cells);
xassert (dpyinfo->color_cells[pixel].pixel == pixel);
colors[i] = dpyinfo->color_cells[pixel];
}
}
else
XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors, ncolors);
}
void
x_query_color (f, color)
struct frame *f;
XColor *color;
{
x_query_colors (f, color, 1);
}
static int
x_alloc_nearest_color_1 (dpy, cmap, color)
Display *dpy;
Colormap cmap;
XColor *color;
{
int rc;
rc = XAllocColor (dpy, cmap, color);
if (rc == 0)
{
int nearest, i;
unsigned long nearest_delta = ~0;
int ncells;
const XColor *cells = x_color_cells (dpy, &ncells);
for (nearest = i = 0; i < ncells; ++i)
{
long dred = (color->red >> 8) - (cells[i].red >> 8);
long dgreen = (color->green >> 8) - (cells[i].green >> 8);
long dblue = (color->blue >> 8) - (cells[i].blue >> 8);
unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue;
if (delta < nearest_delta)
{
nearest = i;
nearest_delta = delta;
}
}
color->red = cells[nearest].red;
color->green = cells[nearest].green;
color->blue = cells[nearest].blue;
rc = XAllocColor (dpy, cmap, color);
}
else
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
XColor *cached_color;
if (dpyinfo->color_cells
&& (cached_color = &dpyinfo->color_cells[color->pixel],
(cached_color->red != color->red
|| cached_color->blue != color->blue
|| cached_color->green != color->green)))
{
xfree (dpyinfo->color_cells);
dpyinfo->color_cells = NULL;
dpyinfo->ncolor_cells = 0;
}
}
#ifdef DEBUG_X_COLORS
if (rc)
register_color (color->pixel);
#endif
return rc;
}
int
x_alloc_nearest_color (f, cmap, color)
struct frame *f;
Colormap cmap;
XColor *color;
{
gamma_correct (f, color);
return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f), cmap, color);
}
unsigned long
x_copy_color (f, pixel)
struct frame *f;
unsigned long pixel;
{
XColor color;
color.pixel = pixel;
BLOCK_INPUT;
x_query_color (f, &color);
XAllocColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &color);
UNBLOCK_INPUT;
#ifdef DEBUG_X_COLORS
register_color (pixel);
#endif
return color.pixel;
}
unsigned long
x_copy_dpy_color (dpy, cmap, pixel)
Display *dpy;
Colormap cmap;
unsigned long pixel;
{
XColor color;
color.pixel = pixel;
BLOCK_INPUT;
XQueryColor (dpy, cmap, &color);
XAllocColor (dpy, cmap, &color);
UNBLOCK_INPUT;
#ifdef DEBUG_X_COLORS
register_color (pixel);
#endif
return color.pixel;
}
#define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
static int
x_alloc_lighter_color (f, display, cmap, pixel, factor, delta)
struct frame *f;
Display *display;
Colormap cmap;
unsigned long *pixel;
double factor;
int delta;
{
XColor color, new;
long bright;
int success_p;
color.pixel = *pixel;
x_query_color (f, &color);
xassert (factor >= 0);
new.red = min (0xffff, factor * color.red);
new.green = min (0xffff, factor * color.green);
new.blue = min (0xffff, factor * color.blue);
bright = (2 * color.red + 3 * color.green + color.blue) / 6;
if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
{
double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
int min_delta = delta * dimness * factor / 2;
if (factor < 1)
{
new.red = max (0, new.red - min_delta);
new.green = max (0, new.green - min_delta);
new.blue = max (0, new.blue - min_delta);
}
else
{
new.red = min (0xffff, min_delta + new.red);
new.green = min (0xffff, min_delta + new.green);
new.blue = min (0xffff, min_delta + new.blue);
}
}
success_p = x_alloc_nearest_color (f, cmap, &new);
if (success_p)
{
if (new.pixel == *pixel)
{
x_free_colors (f, &new.pixel, 1);
new.red = min (0xffff, delta + color.red);
new.green = min (0xffff, delta + color.green);
new.blue = min (0xffff, delta + color.blue);
success_p = x_alloc_nearest_color (f, cmap, &new);
}
else
success_p = 1;
*pixel = new.pixel;
}
return success_p;
}
static void
x_setup_relief_color (f, relief, factor, delta, default_pixel)
struct frame *f;
struct relief *relief;
double factor;
int delta;
unsigned long default_pixel;
{
XGCValues xgcv;
struct x_output *di = f->output_data.x;
unsigned long mask = GCForeground | GCLineWidth | GCGraphicsExposures;
unsigned long pixel;
unsigned long background = di->relief_background;
Colormap cmap = FRAME_X_COLORMAP (f);
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Display *dpy = FRAME_X_DISPLAY (f);
xgcv.graphics_exposures = False;
xgcv.line_width = 1;
if (relief->gc
&& relief->allocated_p)
{
x_free_colors (f, &relief->pixel, 1);
relief->allocated_p = 0;
}
xgcv.foreground = default_pixel;
pixel = background;
if (dpyinfo->n_planes != 1
&& x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
{
relief->allocated_p = 1;
xgcv.foreground = relief->pixel = pixel;
}
if (relief->gc == 0)
{
xgcv.stipple = dpyinfo->gray;
mask |= GCStipple;
relief->gc = XCreateGC (dpy, FRAME_X_WINDOW (f), mask, &xgcv);
}
else
XChangeGC (dpy, relief->gc, mask, &xgcv);
}
static void
x_setup_relief_colors (s)
struct glyph_string *s;
{
struct x_output *di = s->f->output_data.x;
unsigned long color;
if (s->face->use_box_color_for_shadows_p)
color = s->face->box_color;
else if (s->first_glyph->type == IMAGE_GLYPH
&& s->img->pixmap
&& !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
color = IMAGE_BACKGROUND (s->img, s->f, 0);
else
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
color = xgcv.background;
}
if (di->white_relief.gc == 0
|| color != di->relief_background)
{
di->relief_background = color;
x_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
WHITE_PIX_DEFAULT (s->f));
x_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
BLACK_PIX_DEFAULT (s->f));
}
}
static void
x_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
raised_p, top_p, bot_p, left_p, right_p, clip_rect)
struct frame *f;
int left_x, top_y, right_x, bottom_y, width;
int top_p, bot_p, left_p, right_p, raised_p;
XRectangle *clip_rect;
{
Display *dpy = FRAME_X_DISPLAY (f);
Window window = FRAME_X_WINDOW (f);
int i;
GC gc;
if (raised_p)
gc = f->output_data.x->white_relief.gc;
else
gc = f->output_data.x->black_relief.gc;
XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
if (top_p)
for (i = 0; i < width; ++i)
XDrawLine (dpy, window, gc,
left_x + i * left_p, top_y + i,
right_x + 1 - i * right_p, top_y + i);
if (left_p)
for (i = 0; i < width; ++i)
XDrawLine (dpy, window, gc,
left_x + i, top_y + i, left_x + i, bottom_y - i + 1);
XSetClipMask (dpy, gc, None);
if (raised_p)
gc = f->output_data.x->black_relief.gc;
else
gc = f->output_data.x->white_relief.gc;
XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
if (bot_p)
for (i = 0; i < width; ++i)
XDrawLine (dpy, window, gc,
left_x + i * left_p, bottom_y - i,
right_x + 1 - i * right_p, bottom_y - i);
if (right_p)
for (i = 0; i < width; ++i)
XDrawLine (dpy, window, gc,
right_x - i, top_y + i + 1, right_x - i, bottom_y - i);
XSetClipMask (dpy, gc, None);
}
static void
x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
left_p, right_p, clip_rect)
struct glyph_string *s;
int left_x, top_y, right_x, bottom_y, width, left_p, right_p;
XRectangle *clip_rect;
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
XSetForeground (s->display, s->gc, s->face->box_color);
XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
XFillRectangle (s->display, s->window, s->gc,
left_x, top_y, right_x - left_x + 1, width);
if (left_p)
XFillRectangle (s->display, s->window, s->gc,
left_x, top_y, width, bottom_y - top_y + 1);
XFillRectangle (s->display, s->window, s->gc,
left_x, bottom_y - width + 1, right_x - left_x + 1, width);
if (right_p)
XFillRectangle (s->display, s->window, s->gc,
right_x - width + 1, top_y, width, bottom_y - top_y + 1);
XSetForeground (s->display, s->gc, xgcv.foreground);
XSetClipMask (s->display, s->gc, None);
}
static void
x_draw_glyph_string_box (s)
struct glyph_string *s;
{
int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
int left_p, right_p;
struct glyph *last_glyph;
XRectangle clip_rect;
last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
? WINDOW_RIGHT_EDGE_X (s->w)
: window_box_right (s->w, s->area));
last_glyph = (s->cmp || s->img
? s->first_glyph
: s->first_glyph + s->nchars - 1);
width = abs (s->face->box_line_width);
raised_p = s->face->box == FACE_RAISED_BOX;
left_x = s->x;
right_x = (s->row->full_width_p && s->extends_to_end_of_line_p
? last_x - 1
: min (last_x, s->x + s->background_width) - 1);
top_y = s->y;
bottom_y = top_y + s->height - 1;
left_p = (s->first_glyph->left_box_line_p
|| (s->hl == DRAW_MOUSE_FACE
&& (s->prev == NULL
|| s->prev->hl != s->hl)));
right_p = (last_glyph->right_box_line_p
|| (s->hl == DRAW_MOUSE_FACE
&& (s->next == NULL
|| s->next->hl != s->hl)));
get_glyph_string_clip_rect (s, &clip_rect);
if (s->face->box == FACE_SIMPLE_BOX)
x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
left_p, right_p, &clip_rect);
else
{
x_setup_relief_colors (s);
x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
width, raised_p, 1, 1, left_p, right_p, &clip_rect);
}
}
static void
x_draw_image_foreground (s)
struct glyph_string *s;
{
int x = s->x;
int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
if (s->face->box != FACE_NO_BOX
&& s->first_glyph->left_box_line_p
&& s->slice.x == 0)
x += abs (s->face->box_line_width);
if (s->slice.x == 0)
x += s->img->hmargin;
if (s->slice.y == 0)
y += s->img->vmargin;
if (s->img->pixmap)
{
if (s->img->mask)
{
unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
| GCFunction);
XGCValues xgcv;
XRectangle clip_rect, image_rect, r;
xgcv.clip_mask = s->img->mask;
xgcv.clip_x_origin = x;
xgcv.clip_y_origin = y;
xgcv.function = GXcopy;
XChangeGC (s->display, s->gc, mask, &xgcv);
get_glyph_string_clip_rect (s, &clip_rect);
image_rect.x = x;
image_rect.y = y;
image_rect.width = s->slice.width;
image_rect.height = s->slice.height;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
s->slice.x + r.x - x, s->slice.y + r.y - y,
r.width, r.height, r.x, r.y);
}
else
{
XRectangle clip_rect, image_rect, r;
get_glyph_string_clip_rect (s, &clip_rect);
image_rect.x = x;
image_rect.y = y;
image_rect.width = s->slice.width;
image_rect.height = s->slice.height;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
s->slice.x + r.x - x, s->slice.y + r.y - y,
r.width, r.height, r.x, r.y);
if (s->hl == DRAW_CURSOR)
{
int r = s->img->relief;
if (r < 0) r = -r;
XDrawRectangle (s->display, s->window, s->gc,
x - r, y - r,
s->slice.width + r*2 - 1,
s->slice.height + r*2 - 1);
}
}
}
else
XDrawRectangle (s->display, s->window, s->gc, x, y,
s->slice.width - 1, s->slice.height - 1);
}
static void
x_draw_image_relief (s)
struct glyph_string *s;
{
int x0, y0, x1, y1, thick, raised_p;
XRectangle r;
int x = s->x;
int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
if (s->face->box != FACE_NO_BOX
&& s->first_glyph->left_box_line_p
&& s->slice.x == 0)
x += abs (s->face->box_line_width);
if (s->slice.x == 0)
x += s->img->hmargin;
if (s->slice.y == 0)
y += s->img->vmargin;
if (s->hl == DRAW_IMAGE_SUNKEN
|| s->hl == DRAW_IMAGE_RAISED)
{
thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
raised_p = s->hl == DRAW_IMAGE_RAISED;
}
else
{
thick = abs (s->img->relief);
raised_p = s->img->relief > 0;
}
x0 = x - thick;
y0 = y - thick;
x1 = x + s->slice.width + thick - 1;
y1 = y + s->slice.height + thick - 1;
x_setup_relief_colors (s);
get_glyph_string_clip_rect (s, &r);
x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p,
s->slice.y == 0,
s->slice.y + s->slice.height == s->img->height,
s->slice.x == 0,
s->slice.x + s->slice.width == s->img->width,
&r);
}
static void
x_draw_image_foreground_1 (s, pixmap)
struct glyph_string *s;
Pixmap pixmap;
{
int x = 0;
int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
if (s->face->box != FACE_NO_BOX
&& s->first_glyph->left_box_line_p
&& s->slice.x == 0)
x += abs (s->face->box_line_width);
if (s->slice.x == 0)
x += s->img->hmargin;
if (s->slice.y == 0)
y += s->img->vmargin;
if (s->img->pixmap)
{
if (s->img->mask)
{
unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
| GCFunction);
XGCValues xgcv;
xgcv.clip_mask = s->img->mask;
xgcv.clip_x_origin = x - s->slice.x;
xgcv.clip_y_origin = y - s->slice.y;
xgcv.function = GXcopy;
XChangeGC (s->display, s->gc, mask, &xgcv);
XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
s->slice.x, s->slice.y,
s->slice.width, s->slice.height, x, y);
XSetClipMask (s->display, s->gc, None);
}
else
{
XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
s->slice.x, s->slice.y,
s->slice.width, s->slice.height, x, y);
if (s->hl == DRAW_CURSOR)
{
int r = s->img->relief;
if (r < 0) r = -r;
XDrawRectangle (s->display, s->window, s->gc, x - r, y - r,
s->slice.width + r*2 - 1,
s->slice.height + r*2 - 1);
}
}
}
else
XDrawRectangle (s->display, pixmap, s->gc, x, y,
s->slice.width - 1, s->slice.height - 1);
}
static void
x_draw_glyph_string_bg_rect (s, x, y, w, h)
struct glyph_string *s;
int x, y, w, h;
{
if (s->stippled_p)
{
XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
XSetFillStyle (s->display, s->gc, FillSolid);
}
else
x_clear_glyph_string_rect (s, x, y, w, h);
}
static void
x_draw_image_glyph_string (s)
struct glyph_string *s;
{
int box_line_hwidth = abs (s->face->box_line_width);
int box_line_vwidth = max (s->face->box_line_width, 0);
int height;
Pixmap pixmap = None;
height = s->height;
if (s->slice.y == 0)
height -= box_line_vwidth;
if (s->slice.y + s->slice.height >= s->img->height)
height -= box_line_vwidth;
s->stippled_p = s->face->stipple != 0;
if (height > s->slice.height
|| s->img->hmargin
|| s->img->vmargin
|| s->img->mask
|| s->img->pixmap == 0
|| s->width != s->background_width)
{
if (s->img->mask)
{
Screen *screen = FRAME_X_SCREEN (s->f);
int depth = DefaultDepthOfScreen (screen);
pixmap = XCreatePixmap (s->display, s->window,
s->background_width,
s->height, depth);
XSetClipMask (s->display, s->gc, None);
if (s->stippled_p)
{
XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
XFillRectangle (s->display, pixmap, s->gc,
0, 0, s->background_width, s->height);
XSetFillStyle (s->display, s->gc, FillSolid);
}
else
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
&xgcv);
XSetForeground (s->display, s->gc, xgcv.background);
XFillRectangle (s->display, pixmap, s->gc,
0, 0, s->background_width, s->height);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
else
{
int x = s->x;
int y = s->y;
if (s->first_glyph->left_box_line_p
&& s->slice.x == 0)
x += box_line_hwidth;
if (s->slice.y == 0)
y += box_line_vwidth;
x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
}
s->background_filled_p = 1;
}
if (pixmap != None)
{
x_draw_image_foreground_1 (s, pixmap);
x_set_glyph_string_clipping (s);
XCopyArea (s->display, pixmap, s->window, s->gc,
0, 0, s->background_width, s->height, s->x, s->y);
XFreePixmap (s->display, pixmap);
}
else
x_draw_image_foreground (s);
if (s->img->relief
|| s->hl == DRAW_IMAGE_RAISED
|| s->hl == DRAW_IMAGE_SUNKEN)
x_draw_image_relief (s);
}
static void
x_draw_stretch_glyph_string (s)
struct glyph_string *s;
{
xassert (s->first_glyph->type == STRETCH_GLYPH);
s->stippled_p = s->face->stipple != 0;
if (s->hl == DRAW_CURSOR
&& !x_stretch_cursor_p)
{
int width, background_width = s->background_width;
int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
if (x < left_x)
{
background_width -= left_x - x;
x = left_x;
}
width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
if (width < background_width)
{
int y = s->y;
int w = background_width - width, h = s->height;
XRectangle r;
GC gc;
x += width;
if (s->row->mouse_face_p
&& cursor_in_mouse_face_p (s->w))
{
x_set_mouse_face_gc (s);
gc = s->gc;
}
else
gc = s->face->gc;
get_glyph_string_clip_rect (s, &r);
XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
if (s->face->stipple)
{
XSetFillStyle (s->display, gc, FillOpaqueStippled);
XFillRectangle (s->display, s->window, gc, x, y, w, h);
XSetFillStyle (s->display, gc, FillSolid);
}
else
{
XGCValues xgcv;
XGetGCValues (s->display, gc, GCForeground | GCBackground, &xgcv);
XSetForeground (s->display, gc, xgcv.background);
XFillRectangle (s->display, s->window, gc, x, y, w, h);
XSetForeground (s->display, gc, xgcv.foreground);
}
}
}
else if (!s->background_filled_p)
{
int background_width = s->background_width;
int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
if (x < left_x && !s->row->mode_line_p)
{
background_width -= left_x - x;
x = left_x;
}
if (background_width > 0)
x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
}
s->background_filled_p = 1;
}
static void
x_draw_glyph_string (s)
struct glyph_string *s;
{
int relief_drawn_p = 0;
if (s->next && s->right_overhang && !s->for_overlaps)
{
xassert (s->next->img == NULL);
x_set_glyph_string_gc (s->next);
x_set_glyph_string_clipping (s->next);
x_draw_glyph_string_background (s->next, 1);
}
x_set_glyph_string_gc (s);
if (!s->for_overlaps
&& s->face->box != FACE_NO_BOX
&& (s->first_glyph->type == CHAR_GLYPH
|| s->first_glyph->type == COMPOSITE_GLYPH))
{
x_set_glyph_string_clipping (s);
x_draw_glyph_string_background (s, 1);
x_draw_glyph_string_box (s);
x_set_glyph_string_clipping (s);
relief_drawn_p = 1;
}
else
x_set_glyph_string_clipping (s);
switch (s->first_glyph->type)
{
case IMAGE_GLYPH:
x_draw_image_glyph_string (s);
break;
case STRETCH_GLYPH:
x_draw_stretch_glyph_string (s);
break;
case CHAR_GLYPH:
if (s->for_overlaps)
s->background_filled_p = 1;
else
x_draw_glyph_string_background (s, 0);
x_draw_glyph_string_foreground (s);
break;
case COMPOSITE_GLYPH:
if (s->for_overlaps || s->gidx > 0)
s->background_filled_p = 1;
else
x_draw_glyph_string_background (s, 1);
x_draw_composite_glyph_string_foreground (s);
break;
default:
abort ();
}
if (!s->for_overlaps)
{
if (s->face->underline_p)
{
unsigned long tem, h;
int y;
if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
h = 1;
y = s->y + s->height - h;
if (!x_underline_at_descent_line)
{
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;
}
if (s->face->underline_defaulted_p)
XFillRectangle (s->display, s->window, s->gc,
s->x, y, s->background_width, h);
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);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
if (s->face->overline_p)
{
unsigned long dy = 0, h = 1;
if (s->face->overline_color_defaulted_p)
XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
s->background_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);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
if (s->face->strike_through_p)
{
unsigned long h = 1;
unsigned long dy = (s->height - h) / 2;
if (s->face->strike_through_color_defaulted_p)
XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
s->width, h);
else
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
XSetForeground (s->display, s->gc, s->face->strike_through_color);
XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
s->width, h);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
x_draw_glyph_string_box (s);
}
XSetClipMask (s->display, s->gc, None);
}
void
x_shift_glyphs_for_insert (f, x, y, width, height, shift_by)
struct frame *f;
int x, y, width, height, shift_by;
{
XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc,
x, y, width, height,
x + shift_by, y);
}
static void
x_delete_glyphs (n)
register int n;
{
abort ();
}
void
x_clear_area (dpy, window, x, y, width, height, exposures)
Display *dpy;
Window window;
int x, y;
int width, height;
int exposures;
{
xassert (width > 0 && height > 0);
XClearArea (dpy, window, x, y, width, height, exposures);
}
static void
x_clear_frame ()
{
struct frame *f;
if (updating_frame)
f = updating_frame;
else
f = SELECTED_FRAME ();
mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
output_cursor.hpos = output_cursor.vpos = 0;
output_cursor.x = -1;
BLOCK_INPUT;
XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
x_scroll_bar_clear (f);
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
static int
timeval_subtract (result, x, y)
struct timeval *result, x, y;
{
if (x.tv_usec < y.tv_usec)
{
int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
y.tv_usec -= 1000000 * nsec;
y.tv_sec += nsec;
}
if (x.tv_usec - y.tv_usec > 1000000)
{
int nsec = (y.tv_usec - x.tv_usec) / 1000000;
y.tv_usec += 1000000 * nsec;
y.tv_sec -= nsec;
}
result->tv_sec = x.tv_sec - y.tv_sec;
result->tv_usec = x.tv_usec - y.tv_usec;
return x.tv_sec < y.tv_sec;
}
void
XTflash (f)
struct frame *f;
{
BLOCK_INPUT;
{
GC gc;
{
XGCValues values;
values.function = GXxor;
values.foreground = (f->output_data.x->foreground_pixel
^ f->output_data.x->background_pixel);
gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
GCFunction | GCForeground, &values);
}
{
int height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
int flash_height = FRAME_LINE_HEIGHT (f);
int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
int flash_right = FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
int width;
switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f))
{
case vertical_scroll_bar_left:
flash_left += VERTICAL_SCROLL_BAR_WIDTH_TRIM;
break;
case vertical_scroll_bar_right:
flash_right -= VERTICAL_SCROLL_BAR_WIDTH_TRIM;
break;
default:
break;
}
width = flash_right - flash_left;
if (height > 3 * FRAME_LINE_HEIGHT (f))
{
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left,
(FRAME_INTERNAL_BORDER_WIDTH (f)
+ FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f)),
width, flash_height);
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left,
(height - flash_height
- FRAME_INTERNAL_BORDER_WIDTH (f)),
width, flash_height);
}
else
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
x_flush (f);
{
struct timeval wakeup;
EMACS_GET_TIME (wakeup);
wakeup.tv_usec += 150000;
wakeup.tv_sec += (wakeup.tv_usec / 1000000);
wakeup.tv_usec %= 1000000;
while (! detect_input_pending ())
{
struct timeval current;
struct timeval timeout;
EMACS_GET_TIME (current);
if (timeval_subtract (¤t, wakeup, current))
break;
timeout.tv_sec = 0;
timeout.tv_usec = 10000;
select (0, NULL, NULL, NULL, &timeout);
}
}
if (height > 3 * FRAME_LINE_HEIGHT (f))
{
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left,
(FRAME_INTERNAL_BORDER_WIDTH (f)
+ FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f)),
width, flash_height);
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left,
(height - flash_height
- FRAME_INTERNAL_BORDER_WIDTH (f)),
width, flash_height);
}
else
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
XFreeGC (FRAME_X_DISPLAY (f), gc);
x_flush (f);
}
}
UNBLOCK_INPUT;
}
#endif
void
XTring_bell ()
{
struct frame *f = SELECTED_FRAME ();
if (FRAME_X_DISPLAY (f))
{
#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
if (visible_bell)
XTflash (f);
else
#endif
{
BLOCK_INPUT;
XBell (FRAME_X_DISPLAY (f), 0);
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
}
}
static void
XTset_terminal_window (n)
register int n;
{
}
static void
x_ins_del_lines (vpos, n)
int vpos, n;
{
abort ();
}
static void
x_scroll_run (w, run)
struct window *w;
struct run *run;
{
struct frame *f = XFRAME (w->frame);
int x, y, width, height, from_y, to_y, bottom_y;
window_box (w, -1, &x, &y, &width, &height);
from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
bottom_y = y + height;
if (to_y < from_y)
{
if (from_y + run->height > bottom_y)
height = bottom_y - from_y;
else
height = run->height;
}
else
{
if (to_y + run->height > bottom_y)
height = bottom_y - to_y;
else
height = run->height;
}
BLOCK_INPUT;
updated_window = w;
x_clear_cursor (w);
XCopyArea (FRAME_X_DISPLAY (f),
FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc,
x, from_y,
width, height,
x, to_y);
UNBLOCK_INPUT;
}
static void
frame_highlight (f)
struct frame *f;
{
BLOCK_INPUT;
XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->border_pixel);
UNBLOCK_INPUT;
x_update_cursor (f, 1);
}
static void
frame_unhighlight (f)
struct frame *f;
{
BLOCK_INPUT;
XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->border_tile);
UNBLOCK_INPUT;
x_update_cursor (f, 1);
}
static void
x_new_focus_frame (dpyinfo, frame)
struct x_display_info *dpyinfo;
struct frame *frame;
{
struct frame *old_focus = dpyinfo->x_focus_frame;
if (frame != dpyinfo->x_focus_frame)
{
dpyinfo->x_focus_frame = frame;
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
if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
pending_autoraise_frame = dpyinfo->x_focus_frame;
else
pending_autoraise_frame = 0;
}
x_frame_rehighlight (dpyinfo);
}
static void
x_focus_changed (type, state, dpyinfo, frame, bufp)
int type;
int state;
struct x_display_info *dpyinfo;
struct frame *frame;
struct input_event *bufp;
{
if (type == FocusIn)
{
if (dpyinfo->x_focus_event_frame != frame)
{
x_new_focus_frame (dpyinfo, frame);
dpyinfo->x_focus_event_frame = frame;
if (GC_NILP (Vterminal_frame)
&& GC_CONSP (Vframe_list)
&& !GC_NILP (XCDR (Vframe_list)))
{
bufp->kind = FOCUS_IN_EVENT;
XSETFRAME (bufp->frame_or_window, frame);
}
}
frame->output_data.x->focus_state |= state;
#ifdef HAVE_X_I18N
if (FRAME_XIC (frame))
XSetICFocus (FRAME_XIC (frame));
#endif
}
else if (type == FocusOut)
{
frame->output_data.x->focus_state &= ~state;
if (dpyinfo->x_focus_event_frame == frame)
{
dpyinfo->x_focus_event_frame = 0;
x_new_focus_frame (dpyinfo, 0);
}
#ifdef HAVE_X_I18N
if (FRAME_XIC (frame))
XUnsetICFocus (FRAME_XIC (frame));
#endif
}
}
static void
x_detect_focus_change (dpyinfo, event, bufp)
struct x_display_info *dpyinfo;
XEvent *event;
struct input_event *bufp;
{
struct frame *frame;
frame = x_any_window_to_frame (dpyinfo, event->xany.window);
if (! frame)
return;
switch (event->type)
{
case EnterNotify:
case LeaveNotify:
{
struct frame *focus_frame = dpyinfo->x_focus_event_frame;
int focus_state
= focus_frame ? focus_frame->output_data.x->focus_state : 0;
if (event->xcrossing.detail != NotifyInferior
&& event->xcrossing.focus
&& ! (focus_state & FOCUS_EXPLICIT))
x_focus_changed ((event->type == EnterNotify ? FocusIn : FocusOut),
FOCUS_IMPLICIT,
dpyinfo, frame, bufp);
}
break;
case FocusIn:
case FocusOut:
x_focus_changed (event->type,
(event->xfocus.detail == NotifyPointer ?
FOCUS_IMPLICIT : FOCUS_EXPLICIT),
dpyinfo, frame, bufp);
break;
}
}
void
x_mouse_leave (dpyinfo)
struct x_display_info *dpyinfo;
{
x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
}
static void
XTframe_rehighlight (frame)
struct frame *frame;
{
x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame));
}
static void
x_frame_rehighlight (dpyinfo)
struct x_display_info *dpyinfo;
{
struct frame *old_highlight = dpyinfo->x_highlight_frame;
if (dpyinfo->x_focus_frame)
{
dpyinfo->x_highlight_frame
= ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame)))
? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
: dpyinfo->x_focus_frame);
if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
{
FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame) = Qnil;
dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
}
}
else
dpyinfo->x_highlight_frame = 0;
if (dpyinfo->x_highlight_frame != old_highlight)
{
if (old_highlight)
frame_unhighlight (old_highlight);
if (dpyinfo->x_highlight_frame)
frame_highlight (dpyinfo->x_highlight_frame);
}
}
static void
x_find_modifier_meanings (dpyinfo)
struct x_display_info *dpyinfo;
{
int min_code, max_code;
KeySym *syms;
int syms_per_code;
XModifierKeymap *mods;
dpyinfo->meta_mod_mask = 0;
dpyinfo->shift_lock_mask = 0;
dpyinfo->alt_mod_mask = 0;
dpyinfo->super_mod_mask = 0;
dpyinfo->hyper_mod_mask = 0;
#ifdef HAVE_X11R4
XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
#else
min_code = dpyinfo->display->min_keycode;
max_code = dpyinfo->display->max_keycode;
#endif
syms = XGetKeyboardMapping (dpyinfo->display,
min_code, max_code - min_code + 1,
&syms_per_code);
mods = XGetModifierMapping (dpyinfo->display);
{
int row, col;
int found_alt_or_meta;
for (row = 3; row < 8; row++)
{
found_alt_or_meta = 0;
for (col = 0; col < mods->max_keypermod; col++)
{
KeyCode code = mods->modifiermap[(row * mods->max_keypermod) + col];
if (code == 0)
continue;
{
int code_col;
for (code_col = 0; code_col < syms_per_code; code_col++)
{
int sym = syms[((code - min_code) * syms_per_code) + code_col];
switch (sym)
{
case XK_Meta_L:
case XK_Meta_R:
found_alt_or_meta = 1;
dpyinfo->meta_mod_mask |= (1 << row);
break;
case XK_Alt_L:
case XK_Alt_R:
found_alt_or_meta = 1;
dpyinfo->alt_mod_mask |= (1 << row);
break;
case XK_Hyper_L:
case XK_Hyper_R:
if (!found_alt_or_meta)
dpyinfo->hyper_mod_mask |= (1 << row);
code_col = syms_per_code;
col = mods->max_keypermod;
break;
case XK_Super_L:
case XK_Super_R:
if (!found_alt_or_meta)
dpyinfo->super_mod_mask |= (1 << row);
code_col = syms_per_code;
col = mods->max_keypermod;
break;
case XK_Shift_Lock:
if (!found_alt_or_meta && ((1 << row) == LockMask))
dpyinfo->shift_lock_mask = LockMask;
code_col = syms_per_code;
col = mods->max_keypermod;
break;
}
}
}
}
}
}
if (! dpyinfo->meta_mod_mask)
{
dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
dpyinfo->alt_mod_mask = 0;
}
if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
{
dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
}
XFree ((char *) syms);
XFreeModifiermap (mods);
}
unsigned int
x_x_to_emacs_modifiers (dpyinfo, state)
struct x_display_info *dpyinfo;
unsigned int state;
{
EMACS_UINT mod_meta = meta_modifier;
EMACS_UINT mod_alt = alt_modifier;
EMACS_UINT mod_hyper = hyper_modifier;
EMACS_UINT mod_super = super_modifier;
Lisp_Object tem;
tem = Fget (Vx_alt_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_alt = XUINT (tem);
tem = Fget (Vx_meta_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_meta = XUINT (tem);
tem = Fget (Vx_hyper_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_hyper = XUINT (tem);
tem = Fget (Vx_super_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_super = XUINT (tem);
return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
| ((state & ControlMask) ? ctrl_modifier : 0)
| ((state & dpyinfo->meta_mod_mask) ? mod_meta : 0)
| ((state & dpyinfo->alt_mod_mask) ? mod_alt : 0)
| ((state & dpyinfo->super_mod_mask) ? mod_super : 0)
| ((state & dpyinfo->hyper_mod_mask) ? mod_hyper : 0));
}
static unsigned int
x_emacs_to_x_modifiers (dpyinfo, state)
struct x_display_info *dpyinfo;
unsigned int state;
{
EMACS_UINT mod_meta = meta_modifier;
EMACS_UINT mod_alt = alt_modifier;
EMACS_UINT mod_hyper = hyper_modifier;
EMACS_UINT mod_super = super_modifier;
Lisp_Object tem;
tem = Fget (Vx_alt_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_alt = XUINT (tem);
tem = Fget (Vx_meta_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_meta = XUINT (tem);
tem = Fget (Vx_hyper_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_hyper = XUINT (tem);
tem = Fget (Vx_super_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_super = XUINT (tem);
return ( ((state & mod_alt) ? dpyinfo->alt_mod_mask : 0)
| ((state & mod_super) ? dpyinfo->super_mod_mask : 0)
| ((state & mod_hyper) ? dpyinfo->hyper_mod_mask : 0)
| ((state & shift_modifier) ? ShiftMask : 0)
| ((state & ctrl_modifier) ? ControlMask : 0)
| ((state & mod_meta) ? dpyinfo->meta_mod_mask : 0));
}
char *
x_get_keysym_name (keysym)
KeySym keysym;
{
char *value;
BLOCK_INPUT;
value = XKeysymToString (keysym);
UNBLOCK_INPUT;
return value;
}
static Lisp_Object
construct_mouse_click (result, event, f)
struct input_event *result;
XButtonEvent *event;
struct frame *f;
{
result->kind = MOUSE_CLICK_EVENT;
result->code = event->button - Button1;
result->timestamp = event->time;
result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
event->state)
| (event->type == ButtonRelease
? up_modifier
: down_modifier));
XSETINT (result->x, event->x);
XSETINT (result->y, event->y);
XSETFRAME (result->frame_or_window, f);
result->arg = Qnil;
return Qnil;
}
static XMotionEvent last_mouse_motion_event;
static Lisp_Object last_mouse_motion_frame;
static int
note_mouse_movement (frame, event)
FRAME_PTR frame;
XMotionEvent *event;
{
last_mouse_movement_time = event->time;
last_mouse_motion_event = *event;
XSETFRAME (last_mouse_motion_frame, frame);
if (!FRAME_X_OUTPUT (frame))
return 0;
if (event->window != FRAME_X_WINDOW (frame))
{
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
note_mouse_highlight (frame, -1, -1);
last_mouse_glyph_frame = 0;
return 1;
}
if (frame != last_mouse_glyph_frame
|| event->x < last_mouse_glyph.x
|| event->x >= last_mouse_glyph.x + last_mouse_glyph.width
|| event->y < last_mouse_glyph.y
|| event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
{
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
note_mouse_highlight (frame, event->x, event->y);
remember_mouse_glyph (frame, event->x, event->y, &last_mouse_glyph);
last_mouse_glyph_frame = frame;
return 1;
}
return 0;
}
static void
redo_mouse_highlight ()
{
if (!NILP (last_mouse_motion_frame)
&& FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
note_mouse_highlight (XFRAME (last_mouse_motion_frame),
last_mouse_motion_event.x,
last_mouse_motion_event.y);
}
static void
XTmouse_position (fp, insist, bar_window, part, x, y, time)
FRAME_PTR *fp;
int insist;
Lisp_Object *bar_window;
enum scroll_bar_part *part;
Lisp_Object *x, *y;
unsigned long *time;
{
FRAME_PTR f1;
BLOCK_INPUT;
if (! NILP (last_mouse_scroll_bar) && insist == 0)
x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
else
{
Window root;
int root_x, root_y;
Window dummy_window;
int dummy;
Lisp_Object frame, tail;
FOR_EACH_FRAME (tail, frame)
if (FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
XFRAME (frame)->mouse_moved = 0;
last_mouse_scroll_bar = Qnil;
XQueryPointer (FRAME_X_DISPLAY (*fp),
DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
&root,
&dummy_window,
&root_x, &root_y,
&dummy, &dummy,
(unsigned int *) &dummy);
{
Window win, child;
int win_x, win_y;
int parent_x = 0, parent_y = 0;
win = root;
x_catch_errors (FRAME_X_DISPLAY (*fp));
if (FRAME_X_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
{
XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
root, FRAME_X_WINDOW (last_mouse_frame),
root_x, root_y, &win_x, &win_y,
&child);
f1 = last_mouse_frame;
}
else
{
while (1)
{
XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
root, win,
root_x, root_y, &win_x, &win_y,
&child);
if (child == None || child == win)
break;
win = child;
parent_x = win_x;
parent_y = win_y;
}
f1 = x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
#ifdef USE_X_TOOLKIT
if (f1 != NULL
&& f1->output_data.x->menubar_widget
&& win == XtWindow (f1->output_data.x->menubar_widget))
f1 = NULL;
#endif
}
if (x_had_errors_p (FRAME_X_DISPLAY (*fp)))
f1 = 0;
x_uncatch_errors ();
if (! f1)
{
struct scroll_bar *bar;
bar = x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp), win);
if (bar)
{
f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
win_x = parent_x;
win_y = parent_y;
}
}
if (f1 == 0 && insist > 0)
f1 = SELECTED_FRAME ();
if (f1)
{
remember_mouse_glyph (f1, win_x, win_y, &last_mouse_glyph);
last_mouse_glyph_frame = f1;
*bar_window = Qnil;
*part = 0;
*fp = f1;
XSETINT (*x, win_x);
XSETINT (*y, win_y);
*time = last_mouse_movement_time;
}
}
}
UNBLOCK_INPUT;
}
static struct scroll_bar *
x_window_to_scroll_bar (display, window_id)
Display *display;
Window window_id;
{
Lisp_Object tail;
#if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
window_id = (Window) xg_get_scroll_id_for_window (display, window_id);
#endif
for (tail = Vframe_list;
XGCTYPE (tail) == Lisp_Cons;
tail = XCDR (tail))
{
Lisp_Object frame, bar, condemned;
frame = XCAR (tail);
if (! GC_FRAMEP (frame))
abort ();
condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
! GC_NILP (bar) || (bar = condemned,
condemned = Qnil,
! GC_NILP (bar));
bar = XSCROLL_BAR (bar)->next)
if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)) == window_id &&
FRAME_X_DISPLAY (XFRAME (frame)) == display)
return XSCROLL_BAR (bar);
}
return 0;
}
#if defined USE_LUCID
static Widget
x_window_to_menu_bar (window)
Window window;
{
Lisp_Object tail;
for (tail = Vframe_list;
XGCTYPE (tail) == Lisp_Cons;
tail = XCDR (tail))
{
Lisp_Object frame = XCAR (tail);
Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
if (menu_bar && xlwmenu_window_p (menu_bar, window))
return menu_bar;
}
return NULL;
}
#endif
#ifdef USE_TOOLKIT_SCROLL_BARS
static void x_scroll_bar_to_input_event P_ ((XEvent *, struct input_event *));
static void x_send_scroll_bar_event P_ ((Lisp_Object, int, int, int));
static void x_create_toolkit_scroll_bar P_ ((struct frame *,
struct scroll_bar *));
static void x_set_toolkit_scroll_bar_thumb P_ ((struct scroll_bar *,
int, int, int));
static Lisp_Object window_being_scrolled;
static int last_scroll_bar_part;
#ifndef USE_GTK
static XtActionHookId action_hook_id;
static Boolean xaw3d_arrow_scroll;
static Boolean xaw3d_pick_top;
static void
xt_action_hook (widget, client_data, action_name, event, params,
num_params)
Widget widget;
XtPointer client_data;
String action_name;
XEvent *event;
String *params;
Cardinal *num_params;
{
int scroll_bar_p;
char *end_action;
#ifdef USE_MOTIF
scroll_bar_p = XmIsScrollBar (widget);
end_action = "Release";
#else
scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
end_action = "EndScroll";
#endif
if (scroll_bar_p
&& strcmp (action_name, end_action) == 0
&& WINDOWP (window_being_scrolled))
{
struct window *w;
x_send_scroll_bar_event (window_being_scrolled,
scroll_bar_end_scroll, 0, 0);
w = XWINDOW (window_being_scrolled);
if (!NILP (XSCROLL_BAR (w->vertical_scroll_bar)->dragging))
{
XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
set_vertical_scroll_bar (w);
}
window_being_scrolled = Qnil;
last_scroll_bar_part = -1;
toolkit_scroll_bar_interaction = 0;
}
}
#endif
static struct window **scroll_bar_windows;
static int scroll_bar_windows_size;
static void
x_send_scroll_bar_event (window, part, portion, whole)
Lisp_Object window;
int part, portion, whole;
{
XEvent event;
XClientMessageEvent *ev = (XClientMessageEvent *) &event;
struct window *w = XWINDOW (window);
struct frame *f = XFRAME (w->frame);
int i;
BLOCK_INPUT;
ev->type = ClientMessage;
ev->message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_Scrollbar;
ev->display = FRAME_X_DISPLAY (f);
ev->window = FRAME_X_WINDOW (f);
ev->format = 32;
for (i = 0; i < scroll_bar_windows_size; ++i)
if (scroll_bar_windows[i] == NULL)
break;
if (i == scroll_bar_windows_size)
{
int new_size = max (10, 2 * scroll_bar_windows_size);
size_t nbytes = new_size * sizeof *scroll_bar_windows;
size_t old_nbytes = scroll_bar_windows_size * sizeof *scroll_bar_windows;
scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
nbytes);
bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
scroll_bar_windows_size = new_size;
}
scroll_bar_windows[i] = w;
ev->data.l[0] = (long) i;
ev->data.l[1] = (long) part;
ev->data.l[2] = (long) 0;
ev->data.l[3] = (long) portion;
ev->data.l[4] = (long) whole;
toolkit_scroll_bar_interaction = 1;
#ifdef USE_X_TOOLKIT
x_activate_timeout_atimer ();
#endif
XSendEvent (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), False, 0, &event);
UNBLOCK_INPUT;
}
static void
x_scroll_bar_to_input_event (event, ievent)
XEvent *event;
struct input_event *ievent;
{
XClientMessageEvent *ev = (XClientMessageEvent *) event;
Lisp_Object window;
struct frame *f;
struct window *w;
w = scroll_bar_windows[ev->data.l[0]];
scroll_bar_windows[ev->data.l[0]] = NULL;
XSETWINDOW (window, w);
f = XFRAME (w->frame);
ievent->kind = SCROLL_BAR_CLICK_EVENT;
ievent->frame_or_window = window;
ievent->arg = Qnil;
#ifdef USE_GTK
ievent->timestamp = CurrentTime;
#else
ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
#endif
ievent->part = ev->data.l[1];
ievent->code = ev->data.l[2];
ievent->x = make_number ((int) ev->data.l[3]);
ievent->y = make_number ((int) ev->data.l[4]);
ievent->modifiers = 0;
}
#ifdef USE_MOTIF
#define XM_SB_MAX 10000000
static void
xm_scroll_callback (widget, client_data, call_data)
Widget widget;
XtPointer client_data, call_data;
{
struct scroll_bar *bar = (struct scroll_bar *) client_data;
XmScrollBarCallbackStruct *cs = (XmScrollBarCallbackStruct *) call_data;
int part = -1, whole = 0, portion = 0;
switch (cs->reason)
{
case XmCR_DECREMENT:
bar->dragging = Qnil;
part = scroll_bar_up_arrow;
break;
case XmCR_INCREMENT:
bar->dragging = Qnil;
part = scroll_bar_down_arrow;
break;
case XmCR_PAGE_DECREMENT:
bar->dragging = Qnil;
part = scroll_bar_above_handle;
break;
case XmCR_PAGE_INCREMENT:
bar->dragging = Qnil;
part = scroll_bar_below_handle;
break;
case XmCR_TO_TOP:
bar->dragging = Qnil;
part = scroll_bar_to_top;
break;
case XmCR_TO_BOTTOM:
bar->dragging = Qnil;
part = scroll_bar_to_bottom;
break;
case XmCR_DRAG:
{
int slider_size;
BLOCK_INPUT;
XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
UNBLOCK_INPUT;
whole = XM_SB_MAX - slider_size;
portion = min (cs->value, whole);
part = scroll_bar_handle;
bar->dragging = make_number (cs->value);
}
break;
case XmCR_VALUE_CHANGED:
break;
};
if (part >= 0)
{
window_being_scrolled = bar->window;
last_scroll_bar_part = part;
x_send_scroll_bar_event (bar->window, part, portion, whole);
}
}
#else
#ifdef USE_GTK
static void
xg_scroll_callback (widget, data)
GtkRange *widget;
gpointer data;
{
struct scroll_bar *bar = (struct scroll_bar *) data;
gdouble previous;
gdouble position;
gdouble *p;
int diff;
int part = -1, whole = 0, portion = 0;
GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_range_get_adjustment (widget));
position = gtk_adjustment_get_value (adj);
p = g_object_get_data (G_OBJECT (widget), XG_LAST_SB_DATA);
if (! p)
{
p = (gdouble*) xmalloc (sizeof (gdouble));
*p = XG_SB_MIN;
g_object_set_data (G_OBJECT (widget), XG_LAST_SB_DATA, p);
}
previous = *p;
*p = position;
if (xg_ignore_gtk_scrollbar) return;
diff = (int) (position - previous);
if (diff == (int) adj->step_increment)
{
part = scroll_bar_down_arrow;
bar->dragging = Qnil;
}
else if (-diff == (int) adj->step_increment)
{
part = scroll_bar_up_arrow;
bar->dragging = Qnil;
}
else if (diff == (int) adj->page_increment)
{
part = scroll_bar_below_handle;
bar->dragging = Qnil;
}
else if (-diff == (int) adj->page_increment)
{
part = scroll_bar_above_handle;
bar->dragging = Qnil;
}
else
{
part = scroll_bar_handle;
whole = adj->upper - adj->page_size;
portion = min ((int)position, whole);
bar->dragging = make_number ((int)portion);
}
if (part >= 0)
{
window_being_scrolled = bar->window;
last_scroll_bar_part = part;
x_send_scroll_bar_event (bar->window, part, portion, whole);
}
}
#else
static void
xaw_jump_callback (widget, client_data, call_data)
Widget widget;
XtPointer client_data, call_data;
{
struct scroll_bar *bar = (struct scroll_bar *) client_data;
float top = *(float *) call_data;
float shown;
int whole, portion, height;
int part;
BLOCK_INPUT;
XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
UNBLOCK_INPUT;
whole = 10000000;
portion = shown < 1 ? top * whole : 0;
if (shown < 1 && (abs (top + shown - 1) < 1.0/height))
part = scroll_bar_down_arrow;
else
part = scroll_bar_handle;
window_being_scrolled = bar->window;
bar->dragging = make_number (portion);
last_scroll_bar_part = part;
x_send_scroll_bar_event (bar->window, part, portion, whole);
}
static void
xaw_scroll_callback (widget, client_data, call_data)
Widget widget;
XtPointer client_data, call_data;
{
struct scroll_bar *bar = (struct scroll_bar *) client_data;
int position = (long) call_data;
Dimension height;
int part;
BLOCK_INPUT;
XtVaGetValues (widget, XtNheight, &height, NULL);
UNBLOCK_INPUT;
if (abs (position) >= height)
part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
else if (xaw3d_arrow_scroll && abs (position) <= max (5, height / 20))
part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
else
part = scroll_bar_move_ratio;
window_being_scrolled = bar->window;
bar->dragging = Qnil;
last_scroll_bar_part = part;
x_send_scroll_bar_event (bar->window, part, position, height);
}
#endif
#endif
#define SCROLL_BAR_NAME "verticalScrollBar"
#ifdef USE_GTK
static void
x_create_toolkit_scroll_bar (f, bar)
struct frame *f;
struct scroll_bar *bar;
{
char *scroll_bar_name = SCROLL_BAR_NAME;
BLOCK_INPUT;
xg_create_scroll_bar (f, bar, G_CALLBACK (xg_scroll_callback),
scroll_bar_name);
UNBLOCK_INPUT;
}
#else
static void
x_create_toolkit_scroll_bar (f, bar)
struct frame *f;
struct scroll_bar *bar;
{
Window xwindow;
Widget widget;
Arg av[20];
int ac = 0;
char *scroll_bar_name = SCROLL_BAR_NAME;
unsigned long pixel;
BLOCK_INPUT;
#ifdef USE_MOTIF
XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
XtSetArg (av[ac], XmNminimum, 0); ++ac;
XtSetArg (av[ac], XmNmaximum, XM_SB_MAX); ++ac;
XtSetArg (av[ac], XmNorientation, XmVERTICAL); ++ac;
XtSetArg (av[ac], XmNprocessingDirection, XmMAX_ON_BOTTOM), ++ac;
XtSetArg (av[ac], XmNincrement, 1); ++ac;
XtSetArg (av[ac], XmNpageIncrement, 1); ++ac;
pixel = f->output_data.x->scroll_bar_foreground_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XmNforeground, pixel);
++ac;
}
pixel = f->output_data.x->scroll_bar_background_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XmNbackground, pixel);
++ac;
}
widget = XmCreateScrollBar (f->output_data.x->edit_widget,
scroll_bar_name, av, ac);
XtAddCallback (widget, XmNdecrementCallback, xm_scroll_callback,
(XtPointer) bar);
XtAddCallback (widget, XmNdragCallback, xm_scroll_callback,
(XtPointer) bar);
XtAddCallback (widget, XmNincrementCallback, xm_scroll_callback,
(XtPointer) bar);
XtAddCallback (widget, XmNpageDecrementCallback, xm_scroll_callback,
(XtPointer) bar);
XtAddCallback (widget, XmNpageIncrementCallback, xm_scroll_callback,
(XtPointer) bar);
XtAddCallback (widget, XmNtoBottomCallback, xm_scroll_callback,
(XtPointer) bar);
XtAddCallback (widget, XmNtoTopCallback, xm_scroll_callback,
(XtPointer) bar);
XtRealizeWidget (widget);
XDefineCursor (XtDisplay (widget), XtWindow (widget),
f->output_data.x->nontext_cursor);
#else
XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
XtSetArg (av[ac], XtNorientation, XtorientVertical); ++ac;
pixel = f->output_data.x->scroll_bar_foreground_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XtNforeground, pixel);
++ac;
}
pixel = f->output_data.x->scroll_bar_background_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XtNbackground, pixel);
++ac;
}
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 (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;
}
#ifdef XtNbeNiceToColormap
if (f->output_data.x->scroll_bar_top_shadow_pixel == -1
|| f->output_data.x->scroll_bar_bottom_shadow_pixel == -1)
{
XtSetArg (av[ac], XtNbeNiceToColormap, True);
++ac;
}
else
{
XtSetArg (av[ac], XtNbeNiceToColormap, False);
++ac;
pixel = f->output_data.x->scroll_bar_top_shadow_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XtNtopShadowPixel, pixel);
++ac;
}
pixel = f->output_data.x->scroll_bar_bottom_shadow_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XtNbottomShadowPixel, pixel);
++ac;
}
}
#endif
widget = XtCreateWidget (scroll_bar_name, scrollbarWidgetClass,
f->output_data.x->edit_widget, av, ac);
{
char *initial = "";
char *val = initial;
XtVaGetValues (widget, XtNscrollVCursor, (XtPointer) &val,
#ifdef XtNarrowScrollbars
XtNarrowScrollbars, (XtPointer) &xaw3d_arrow_scroll,
#endif
XtNpickTop, (XtPointer) &xaw3d_pick_top, NULL);
if (xaw3d_arrow_scroll || val == initial)
{
xaw3d_arrow_scroll = True;
XtVaSetValues (widget, XtNcursorName, "top_left_arrow", NULL);
}
}
XtAddCallback (widget, XtNjumpProc, xaw_jump_callback, (XtPointer) bar);
XtAddCallback (widget, XtNscrollProc, xaw_scroll_callback,
(XtPointer) bar);
XtRealizeWidget (widget);
#endif
if (action_hook_id == 0)
action_hook_id = XtAppAddActionHook (Xt_app_con, xt_action_hook, 0);
SET_SCROLL_BAR_X_WIDGET (bar, widget);
xwindow = XtWindow (widget);
SET_SCROLL_BAR_X_WINDOW (bar, xwindow);
UNBLOCK_INPUT;
}
#endif
#ifdef USE_GTK
static void
x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
struct scroll_bar *bar;
int portion, position, whole;
{
xg_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
}
#else
static void
x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
struct scroll_bar *bar;
int portion, position, whole;
{
struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
Widget widget = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
float top, shown;
BLOCK_INPUT;
#ifdef USE_MOTIF
portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
whole += portion;
if (whole <= 0)
top = 0, shown = 1;
else
{
top = (float) position / whole;
shown = (float) portion / whole;
}
if (NILP (bar->dragging))
{
int size, value;
size = shown * XM_SB_MAX;
size = min (size, XM_SB_MAX);
size = max (size, 1);
value = top * XM_SB_MAX;
value = min (value, XM_SB_MAX - size);
XmScrollBarSetValues (widget, value, size, 0, 0, False);
}
#else
if (whole == 0)
top = 0, shown = 1;
else
{
top = (float) position / whole;
shown = (float) portion / whole;
}
{
float old_top, old_shown;
Dimension height;
XtVaGetValues (widget,
XtNtopOfThumb, &old_top,
XtNshown, &old_shown,
XtNheight, &height,
NULL);
if (NILP (bar->dragging) || last_scroll_bar_part == scroll_bar_down_arrow)
top = max (0, min (1, top));
else
top = old_top;
shown = max (0, min (1 - top - (2.0 / height), shown));
if (top != old_top || shown != old_shown)
{
if (NILP (bar->dragging))
XawScrollbarSetThumb (widget, top, shown);
else
{
if (!xaw3d_pick_top)
shown = min (shown, old_shown);
XawScrollbarSetThumb (widget, top, shown);
}
}
}
#endif
UNBLOCK_INPUT;
}
#endif
#endif
static struct scroll_bar *
x_scroll_bar_create (w, top, left, width, height)
struct window *w;
int top, left, width, height;
{
struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar
= XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
BLOCK_INPUT;
#ifdef USE_TOOLKIT_SCROLL_BARS
x_create_toolkit_scroll_bar (f, bar);
#else
{
XSetWindowAttributes a;
unsigned long mask;
Window window;
a.background_pixel = f->output_data.x->scroll_bar_background_pixel;
if (a.background_pixel == -1)
a.background_pixel = f->output_data.x->background_pixel;
a.event_mask = (ButtonPressMask | ButtonReleaseMask
| ButtonMotionMask | PointerMotionHintMask
| ExposureMask);
a.cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
mask = (CWBackPixel | CWEventMask | CWCursor);
if (width > 0 && height > 0)
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left, top, width,
window_box_height (w), False);
window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
top,
width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
height,
0,
CopyFromParent,
CopyFromParent,
CopyFromParent,
mask, &a);
SET_SCROLL_BAR_X_WINDOW (bar, window);
}
#endif
XSETWINDOW (bar->window, w);
XSETINT (bar->top, top);
XSETINT (bar->left, left);
XSETINT (bar->width, width);
XSETINT (bar->height, height);
XSETINT (bar->start, 0);
XSETINT (bar->end, 0);
bar->dragging = Qnil;
bar->next = FRAME_SCROLL_BARS (f);
bar->prev = Qnil;
XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
if (!NILP (bar->next))
XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
#ifdef USE_TOOLKIT_SCROLL_BARS
{
#ifdef USE_GTK
xg_update_scrollbar_pos (f,
SCROLL_BAR_X_WINDOW (bar),
top,
left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
max (height, 1));
xg_show_scroll_bar (SCROLL_BAR_X_WINDOW (bar));
#else
Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
XtConfigureWidget (scroll_bar,
left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
top,
width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
max (height, 1), 0);
XtMapWidget (scroll_bar);
#endif
}
#else
XMapRaised (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
#endif
UNBLOCK_INPUT;
return bar;
}
#ifndef USE_TOOLKIT_SCROLL_BARS
static void
x_scroll_bar_set_handle (bar, start, end, rebuild)
struct scroll_bar *bar;
int start, end;
int rebuild;
{
int dragging = ! NILP (bar->dragging);
Window w = SCROLL_BAR_X_WINDOW (bar);
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
GC gc = f->output_data.x->normal_gc;
if (! rebuild
&& start == XINT (bar->start)
&& end == XINT (bar->end))
return;
BLOCK_INPUT;
{
int inside_width = VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f, XINT (bar->width));
int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
{
int length = end - start;
if (start < 0)
start = 0;
else if (start > top_range)
start = top_range;
end = start + length;
if (end < start)
end = start;
else if (end > top_range && ! dragging)
end = top_range;
}
XSETINT (bar->start, start);
XSETINT (bar->end, end);
if (end > top_range)
end = top_range;
end += VERTICAL_SCROLL_BAR_MIN_HANDLE;
if (0 < start)
x_clear_area (FRAME_X_DISPLAY (f), w,
VERTICAL_SCROLL_BAR_LEFT_BORDER,
VERTICAL_SCROLL_BAR_TOP_BORDER,
inside_width, start,
False);
if (f->output_data.x->scroll_bar_foreground_pixel != -1)
XSetForeground (FRAME_X_DISPLAY (f), gc,
f->output_data.x->scroll_bar_foreground_pixel);
XFillRectangle (FRAME_X_DISPLAY (f), w, gc,
VERTICAL_SCROLL_BAR_LEFT_BORDER,
VERTICAL_SCROLL_BAR_TOP_BORDER + start,
inside_width, end - start);
if (f->output_data.x->scroll_bar_foreground_pixel != -1)
XSetForeground (FRAME_X_DISPLAY (f), gc,
f->output_data.x->foreground_pixel);
if (end < inside_height)
x_clear_area (FRAME_X_DISPLAY (f), w,
VERTICAL_SCROLL_BAR_LEFT_BORDER,
VERTICAL_SCROLL_BAR_TOP_BORDER + end,
inside_width, inside_height - end,
False);
}
UNBLOCK_INPUT;
}
#endif
static void
x_scroll_bar_remove (bar)
struct scroll_bar *bar;
{
struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
BLOCK_INPUT;
#ifdef USE_TOOLKIT_SCROLL_BARS
#ifdef USE_GTK
xg_remove_scroll_bar (f, SCROLL_BAR_X_WINDOW (bar));
#else
XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar));
#endif
#else
XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
#endif
XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
UNBLOCK_INPUT;
}
static void
XTset_vertical_scroll_bar (w, portion, whole, position)
struct window *w;
int portion, whole, position;
{
struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar;
int top, height, left, sb_left, width, sb_width;
int window_y, window_height;
window_box (w, -1, 0, &window_y, 0, &window_height);
top = window_y;
width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
height = window_height;
left = WINDOW_SCROLL_BAR_AREA_X (w);
if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
else
sb_width = width;
#ifdef USE_TOOLKIT_SCROLL_BARS
if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
sb_left = (left +
(WINDOW_RIGHTMOST_P (w)
? width - sb_width - (width - sb_width) / 2
: 0));
else
sb_left = (left +
(WINDOW_LEFTMOST_P (w)
? (width - sb_width) / 2
: width - sb_width));
#else
if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
sb_left = left + width - sb_width;
else
sb_left = left;
#endif
if (NILP (w->vertical_scroll_bar))
{
if (width > 0 && height > 0)
{
BLOCK_INPUT;
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left, top, width, height, False);
UNBLOCK_INPUT;
}
bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
}
else
{
unsigned int mask = 0;
bar = XSCROLL_BAR (w->vertical_scroll_bar);
BLOCK_INPUT;
if (sb_left != XINT (bar->left))
mask |= CWX;
if (top != XINT (bar->top))
mask |= CWY;
if (sb_width != XINT (bar->width))
mask |= CWWidth;
if (height != XINT (bar->height))
mask |= CWHeight;
#ifdef USE_TOOLKIT_SCROLL_BARS
if (mask)
{
if (width > 0 && height > 0)
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left, top, width, height, False);
#ifdef USE_GTK
xg_update_scrollbar_pos (f,
SCROLL_BAR_X_WINDOW (bar),
top,
sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM *2,
max (height, 1));
#else
XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar),
sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
top,
sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
max (height, 1), 0);
#endif
}
#else
if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
{
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
height, False);
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM,
top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
height, False);
}
{
int area_width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
int rest = area_width - sb_width;
if (rest > 0 && height > 0)
{
if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left + area_width - rest, top,
rest, height, False);
else
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left, top, rest, height, False);
}
}
if (mask)
{
XWindowChanges wc;
wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM;
wc.y = top;
wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2;
wc.height = height;
XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
mask, &wc);
}
#endif
XSETINT (bar->left, sb_left);
XSETINT (bar->top, top);
XSETINT (bar->width, sb_width);
XSETINT (bar->height, height);
UNBLOCK_INPUT;
}
#ifdef USE_TOOLKIT_SCROLL_BARS
x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
#else
if (NILP (bar->dragging))
{
int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height);
if (whole == 0)
x_scroll_bar_set_handle (bar, 0, top_range, 0);
else
{
int start = ((double) position * top_range) / whole;
int end = ((double) (position + portion) * top_range) / whole;
x_scroll_bar_set_handle (bar, start, end, 0);
}
}
#endif
XSETVECTOR (w->vertical_scroll_bar, bar);
}
static void
XTcondemn_scroll_bars (frame)
FRAME_PTR frame;
{
while (! NILP (FRAME_SCROLL_BARS (frame)))
{
Lisp_Object bar;
bar = FRAME_SCROLL_BARS (frame);
FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
XSCROLL_BAR (bar)->prev = Qnil;
if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
}
}
static void
XTredeem_scroll_bar (window)
struct window *window;
{
struct scroll_bar *bar;
struct frame *f;
if (NILP (window->vertical_scroll_bar))
abort ();
bar = XSCROLL_BAR (window->vertical_scroll_bar);
f = XFRAME (WINDOW_FRAME (window));
if (NILP (bar->prev))
{
if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
return;
else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
window->vertical_scroll_bar))
FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
else
abort ();
}
else
XSCROLL_BAR (bar->prev)->next = bar->next;
if (! NILP (bar->next))
XSCROLL_BAR (bar->next)->prev = bar->prev;
bar->next = FRAME_SCROLL_BARS (f);
bar->prev = Qnil;
XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
if (! NILP (bar->next))
XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
}
static void
XTjudge_scroll_bars (f)
FRAME_PTR f;
{
Lisp_Object bar, next;
bar = FRAME_CONDEMNED_SCROLL_BARS (f);
FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
for (; ! NILP (bar); bar = next)
{
struct scroll_bar *b = XSCROLL_BAR (bar);
x_scroll_bar_remove (b);
next = b->next;
b->next = b->prev = Qnil;
}
}
#ifndef USE_TOOLKIT_SCROLL_BARS
static void
x_scroll_bar_expose (bar, event)
struct scroll_bar *bar;
XEvent *event;
{
Window w = SCROLL_BAR_X_WINDOW (bar);
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
GC gc = f->output_data.x->normal_gc;
int width_trim = VERTICAL_SCROLL_BAR_WIDTH_TRIM;
BLOCK_INPUT;
x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
if (f->output_data.x->scroll_bar_foreground_pixel != -1)
XSetForeground (FRAME_X_DISPLAY (f), gc,
f->output_data.x->scroll_bar_foreground_pixel);
XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,
0, 0,
XINT (bar->width) - 1 - width_trim - width_trim,
XINT (bar->height) - 1);
if (f->output_data.x->scroll_bar_foreground_pixel != -1)
XSetForeground (FRAME_X_DISPLAY (f), gc,
f->output_data.x->foreground_pixel);
UNBLOCK_INPUT;
}
#endif
static void
x_scroll_bar_handle_click (bar, event, emacs_event)
struct scroll_bar *bar;
XEvent *event;
struct input_event *emacs_event;
{
if (! GC_WINDOWP (bar->window))
abort ();
emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
emacs_event->code = event->xbutton.button - Button1;
emacs_event->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
(XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
event->xbutton.state)
| (event->type == ButtonRelease
? up_modifier
: down_modifier));
emacs_event->frame_or_window = bar->window;
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, XINT (bar->height));
#endif
int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
if (y < 0) y = 0;
if (y > top_range) y = top_range;
if (y < XINT (bar->start))
emacs_event->part = scroll_bar_above_handle;
else if (y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
emacs_event->part = scroll_bar_handle;
else
emacs_event->part = scroll_bar_below_handle;
#if 0
if (event->type == ButtonPress
&& emacs_event->part == scroll_bar_handle)
XSETINT (bar->dragging, y - XINT (bar->start));
#endif
#ifndef USE_TOOLKIT_SCROLL_BARS
if (event->type == ButtonRelease
&& ! NILP (bar->dragging))
{
int new_start = y - XINT (bar->dragging);
int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
x_scroll_bar_set_handle (bar, new_start, new_end, 0);
bar->dragging = Qnil;
}
#endif
#if 0
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);
}
}
#ifndef USE_TOOLKIT_SCROLL_BARS
static void
x_scroll_bar_note_movement (bar, event)
struct scroll_bar *bar;
XEvent *event;
{
FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
last_mouse_movement_time = event->xmotion.time;
f->mouse_moved = 1;
XSETVECTOR (last_mouse_scroll_bar, bar);
if (! GC_NILP (bar->dragging))
{
int new_start = event->xmotion.y - XINT (bar->dragging);
if (new_start != XINT (bar->start))
{
int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
x_scroll_bar_set_handle (bar, new_start, new_end, 0);
}
}
}
#endif
static void
x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
FRAME_PTR *fp;
Lisp_Object *bar_window;
enum scroll_bar_part *part;
Lisp_Object *x, *y;
unsigned long *time;
{
struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
Window w = SCROLL_BAR_X_WINDOW (bar);
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
int win_x, win_y;
Window dummy_window;
int dummy_coord;
unsigned int dummy_mask;
BLOCK_INPUT;
if (! XQueryPointer (FRAME_X_DISPLAY (f), w,
&dummy_window, &dummy_window,
&dummy_coord, &dummy_coord,
&win_x, &win_y,
&dummy_mask))
;
else
{
#if 0
int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
#endif
int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
if (! NILP (bar->dragging))
win_y -= XINT (bar->dragging);
if (win_y < 0)
win_y = 0;
if (win_y > top_range)
win_y = top_range;
*fp = f;
*bar_window = bar->window;
if (! NILP (bar->dragging))
*part = scroll_bar_handle;
else if (win_y < XINT (bar->start))
*part = scroll_bar_above_handle;
else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
*part = scroll_bar_handle;
else
*part = scroll_bar_below_handle;
XSETINT (*x, win_y);
XSETINT (*y, top_range);
f->mouse_moved = 0;
last_mouse_scroll_bar = Qnil;
}
*time = last_mouse_movement_time;
UNBLOCK_INPUT;
}
void
x_scroll_bar_clear (f)
FRAME_PTR f;
{
#ifndef USE_TOOLKIT_SCROLL_BARS
Lisp_Object bar;
if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
bar = XSCROLL_BAR (bar)->next)
XClearArea (FRAME_X_DISPLAY (f),
SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
0, 0, 0, 0, True);
#endif
}
#if 0
static Time enter_timestamp;
#endif
static XComposeStatus compose_status;
static int temp_index;
static short temp_buffer[100];
#define STORE_KEYSYM_FOR_DEBUG(keysym) \
if (temp_index == sizeof temp_buffer / sizeof (short)) \
temp_index = 0; \
temp_buffer[temp_index++] = (keysym)
struct x_display_info *XTread_socket_fake_io_error;
static struct x_display_info *next_noop_dpyinfo;
#define SET_SAVED_MENU_EVENT(size) \
do \
{ \
if (f->output_data.x->saved_menu_event == 0) \
f->output_data.x->saved_menu_event \
= (XEvent *) xmalloc (sizeof (XEvent)); \
bcopy (&event, f->output_data.x->saved_menu_event, size); \
inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
XSETFRAME (inev.ie.frame_or_window, f); \
} \
while (0)
#define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
#define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
enum
{
X_EVENT_NORMAL,
X_EVENT_GOTO_OUT,
X_EVENT_DROP
};
#ifdef HAVE_X_I18N
static int
x_filter_event (dpyinfo, event)
struct x_display_info *dpyinfo;
XEvent *event;
{
struct frame *f1 = x_any_window_to_frame (dpyinfo,
event->xclient.window);
return XFilterEvent (event, f1 ? FRAME_X_WINDOW (f1) : None);
}
#endif
#ifdef USE_GTK
static int current_count;
static int current_finish;
static struct input_event *current_hold_quit;
static GdkFilterReturn
event_handler_gdk (gxev, ev, data)
GdkXEvent *gxev;
GdkEvent *ev;
gpointer data;
{
XEvent *xev = (XEvent *) gxev;
if (current_count >= 0)
{
struct x_display_info *dpyinfo;
dpyinfo = x_display_info_for_display (xev->xany.display);
#ifdef HAVE_X_I18N
if (xev->type == KeyPress || xev->type == KeyRelease)
if (dpyinfo && x_filter_event (dpyinfo, xev))
return GDK_FILTER_REMOVE;
#endif
if (! dpyinfo)
current_finish = X_EVENT_NORMAL;
else
{
current_count +=
handle_one_xevent (dpyinfo, xev, ¤t_finish,
current_hold_quit);
}
}
else
current_finish = x_dispatch_event (xev, xev->xany.display);
if (current_finish == X_EVENT_GOTO_OUT || current_finish == X_EVENT_DROP)
return GDK_FILTER_REMOVE;
return GDK_FILTER_CONTINUE;
}
#endif
static int
handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
struct x_display_info *dpyinfo;
XEvent *eventp;
int *finish;
struct input_event *hold_quit;
{
union {
struct input_event ie;
struct selection_input_event sie;
} inev;
int count = 0;
int do_help = 0;
int nbytes = 0;
struct frame *f;
struct coding_system coding;
XEvent event = *eventp;
*finish = X_EVENT_NORMAL;
EVENT_INIT (inev.ie);
inev.ie.kind = NO_EVENT;
inev.ie.arg = Qnil;
switch (event.type)
{
case ClientMessage:
{
if (event.xclient.message_type
== dpyinfo->Xatom_wm_protocols
&& event.xclient.format == 32)
{
if (event.xclient.data.l[0]
== dpyinfo->Xatom_wm_take_focus)
{
f = x_any_window_to_frame (dpyinfo, event.xclient.window);
#ifdef HAVE_X_I18N
if (f && FRAME_XIC (f))
XSetICFocus (FRAME_XIC (f));
#endif
#if 0
if (f)
{
Display *d = event.xclient.display;
x_catch_errors (d);
XSetInputFocus (d, event.xclient.window,
RevertToParent,
event.xclient.data.l[1]);
XSync (d, False);
x_uncatch_errors ();
}
#endif
goto done;
}
if (event.xclient.data.l[0]
== dpyinfo->Xatom_wm_save_yourself)
{
#ifdef HAVE_X_SM
if (! x_session_have_connection ())
#endif
{
f = x_top_window_to_frame (dpyinfo,
event.xclient.window);
if (f == SELECTED_FRAME ())
XSetCommand (FRAME_X_DISPLAY (f),
event.xclient.window,
initial_argv, initial_argc);
else if (f)
XSetCommand (FRAME_X_DISPLAY (f),
event.xclient.window,
0, 0);
}
goto done;
}
if (event.xclient.data.l[0]
== dpyinfo->Xatom_wm_delete_window)
{
f = x_any_window_to_frame (dpyinfo,
event.xclient.window);
if (!f)
goto OTHER;
inev.ie.kind = DELETE_WINDOW_EVENT;
XSETFRAME (inev.ie.frame_or_window, f);
goto done;
}
goto done;
}
if (event.xclient.message_type
== dpyinfo->Xatom_wm_configure_denied)
{
goto done;
}
if (event.xclient.message_type
== dpyinfo->Xatom_wm_window_moved)
{
int new_x, new_y;
f = x_window_to_frame (dpyinfo, event.xclient.window);
new_x = event.xclient.data.s[0];
new_y = event.xclient.data.s[1];
if (f)
{
f->left_pos = new_x;
f->top_pos = new_y;
}
goto done;
}
#ifdef HACK_EDITRES
if (event.xclient.message_type
== dpyinfo->Xatom_editres)
{
f = x_any_window_to_frame (dpyinfo, event.xclient.window);
if (f)
_XEditResCheckMessages (f->output_data.x->widget, NULL,
&event, NULL);
goto done;
}
#endif
if ((event.xclient.message_type
== dpyinfo->Xatom_DONE)
|| (event.xclient.message_type
== dpyinfo->Xatom_PAGE))
{
Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
f = x_window_to_frame (dpyinfo, event.xclient.window);
if (!f)
goto OTHER;
x_kill_gs_process (pixmap, f);
expose_frame (f, 0, 0, 0, 0);
goto done;
}
#ifdef USE_TOOLKIT_SCROLL_BARS
if (event.xclient.message_type
== dpyinfo->Xatom_Scrollbar)
{
x_scroll_bar_to_input_event (&event, &inev.ie);
*finish = X_EVENT_GOTO_OUT;
goto done;
}
#endif
f = x_any_window_to_frame (dpyinfo, event.xclient.window);
if (!f)
goto OTHER;
if (x_handle_dnd_message (f, &event.xclient, dpyinfo, &inev.ie))
*finish = X_EVENT_DROP;
}
break;
case SelectionNotify:
last_user_time = event.xselection.time;
#ifdef USE_X_TOOLKIT
if (! x_window_to_frame (dpyinfo, event.xselection.requestor))
goto OTHER;
#endif
x_handle_selection_notify (&event.xselection);
break;
case SelectionClear:
last_user_time = event.xselectionclear.time;
#ifdef USE_X_TOOLKIT
if (! x_window_to_frame (dpyinfo, event.xselectionclear.window))
goto OTHER;
#endif
{
XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
inev.ie.kind = SELECTION_CLEAR_EVENT;
SELECTION_EVENT_DISPLAY (&inev.sie) = eventp->display;
SELECTION_EVENT_SELECTION (&inev.sie) = eventp->selection;
SELECTION_EVENT_TIME (&inev.sie) = eventp->time;
inev.ie.frame_or_window = Qnil;
}
break;
case SelectionRequest:
last_user_time = event.xselectionrequest.time;
#ifdef USE_X_TOOLKIT
if (!x_window_to_frame (dpyinfo, event.xselectionrequest.owner))
goto OTHER;
#endif
{
XSelectionRequestEvent *eventp
= (XSelectionRequestEvent *) &event;
inev.ie.kind = SELECTION_REQUEST_EVENT;
SELECTION_EVENT_DISPLAY (&inev.sie) = eventp->display;
SELECTION_EVENT_REQUESTOR (&inev.sie) = eventp->requestor;
SELECTION_EVENT_SELECTION (&inev.sie) = eventp->selection;
SELECTION_EVENT_TARGET (&inev.sie) = eventp->target;
SELECTION_EVENT_PROPERTY (&inev.sie) = eventp->property;
SELECTION_EVENT_TIME (&inev.sie) = eventp->time;
inev.ie.frame_or_window = Qnil;
}
break;
case PropertyNotify:
last_user_time = event.xproperty.time;
#if 0
#if defined USE_X_TOOLKIT
if (!x_any_window_to_frame (dpyinfo, event.xproperty.window))
goto OTHER;
#endif
#endif
x_handle_property_notify (&event.xproperty);
goto OTHER;
case ReparentNotify:
f = x_top_window_to_frame (dpyinfo, event.xreparent.window);
if (f)
{
int x, y;
f->output_data.x->parent_desc = event.xreparent.parent;
x_real_positions (f, &x, &y);
f->left_pos = x;
f->top_pos = y;
FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_UNKNOWN;
FRAME_X_DISPLAY_INFO (f)->net_supported_window = 0;
}
goto OTHER;
case Expose:
f = x_window_to_frame (dpyinfo, event.xexpose.window);
if (f)
{
x_check_fullscreen (f);
#ifdef USE_GTK
x_clear_area (event.xexpose.display,
event.xexpose.window,
event.xexpose.x, event.xexpose.y,
event.xexpose.width, event.xexpose.height,
FALSE);
#endif
if (f->async_visible == 0)
{
f->async_visible = 1;
f->async_iconified = 0;
f->output_data.x->has_been_visible = 1;
SET_FRAME_GARBAGED (f);
}
else
expose_frame (f,
event.xexpose.x, event.xexpose.y,
event.xexpose.width, event.xexpose.height);
}
else
{
#ifndef USE_TOOLKIT_SCROLL_BARS
struct scroll_bar *bar;
#endif
#if defined USE_LUCID
{
Widget widget
= x_window_to_menu_bar (event.xexpose.window);
if (widget)
xlwmenu_redisplay (widget);
}
#endif
#ifdef USE_TOOLKIT_SCROLL_BARS
goto OTHER;
#else
bar = x_window_to_scroll_bar (event.xexpose.display,
event.xexpose.window);
if (bar)
x_scroll_bar_expose (bar, &event);
#ifdef USE_X_TOOLKIT
else
goto OTHER;
#endif
#endif
}
break;
case GraphicsExpose:
f = x_window_to_frame (dpyinfo, event.xgraphicsexpose.drawable);
if (f)
{
expose_frame (f,
event.xgraphicsexpose.x, event.xgraphicsexpose.y,
event.xgraphicsexpose.width,
event.xgraphicsexpose.height);
}
#ifdef USE_X_TOOLKIT
else
goto OTHER;
#endif
break;
case NoExpose:
break;
case UnmapNotify:
if (event.xmap.window == tip_window)
{
tip_window = 0;
redo_mouse_highlight ();
}
f = x_top_window_to_frame (dpyinfo, event.xunmap.window);
if (f)
{
f->async_visible = 0;
if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
{
f->async_iconified = 1;
inev.ie.kind = ICONIFY_EVENT;
XSETFRAME (inev.ie.frame_or_window, f);
}
}
goto OTHER;
case MapNotify:
if (event.xmap.window == tip_window)
goto OTHER;
f = x_top_window_to_frame (dpyinfo, event.xmap.window);
if (f)
{
if (! f->async_iconified)
SET_FRAME_GARBAGED (f);
f->async_visible = 1;
f->async_iconified = 0;
f->output_data.x->has_been_visible = 1;
if (f->iconified)
{
inev.ie.kind = DEICONIFY_EVENT;
XSETFRAME (inev.ie.frame_or_window, f);
}
else if (! NILP (Vframe_list)
&& ! NILP (XCDR (Vframe_list)))
record_asynch_buffer_change ();
}
goto OTHER;
case KeyPress:
last_user_time = event.xkey.time;
ignore_next_mouse_click_timeout = 0;
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
if (popup_activated ())
goto OTHER;
#endif
f = x_any_window_to_frame (dpyinfo, event.xkey.window);
if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
&& (f == 0
|| !EQ (f->tool_bar_window, dpyinfo->mouse_face_window)))
{
clear_mouse_face (dpyinfo);
dpyinfo->mouse_face_hidden = 1;
}
#if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
if (f == 0)
{
Widget widget = XtWindowToWidget (dpyinfo->display,
event.xkey.window);
if (widget && XmIsScrollBar (widget))
{
widget = XtParent (widget);
f = x_any_window_to_frame (dpyinfo, XtWindow (widget));
}
}
#endif
if (f != 0)
{
KeySym keysym, orig_keysym;
unsigned char copy_buffer[513];
unsigned char *copy_bufptr = copy_buffer;
int copy_bufsiz = sizeof (copy_buffer);
int modifiers;
Lisp_Object coding_system = Qlatin_1;
Lisp_Object c;
#ifdef USE_GTK
*finish = X_EVENT_DROP;
#endif
event.xkey.state
|= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
extra_keyboard_modifiers);
modifiers = event.xkey.state;
event.xkey.state &= ~ControlMask;
event.xkey.state &= ~(dpyinfo->meta_mod_mask
| dpyinfo->super_mod_mask
| dpyinfo->hyper_mod_mask
| dpyinfo->alt_mod_mask);
if (modifiers & dpyinfo->meta_mod_mask)
bzero (&compose_status, sizeof (compose_status));
#ifdef HAVE_X_I18N
if (FRAME_XIC (f))
{
Status status_return;
coding_system = Vlocale_coding_system;
nbytes = XmbLookupString (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 = XmbLookupString (FRAME_XIC (f),
&event.xkey, copy_bufptr,
copy_bufsiz, &keysym,
&status_return);
}
#if 0 && defined X_HAVE_UTF8_STRING
else if (status_return == XLookupKeySym)
{
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)
{
keysym = NoSymbol;
modifiers = 0;
}
else if (status_return != XLookupKeySym
&& status_return != XLookupBoth)
abort ();
}
else
nbytes = XLookupString (&event.xkey, copy_bufptr,
copy_bufsiz, &keysym,
&compose_status);
#else
nbytes = XLookupString (&event.xkey, copy_bufptr,
copy_bufsiz, &keysym,
&compose_status);
#endif
if (compose_status.chars_matched > 0 && nbytes == 0)
break;
bzero (&compose_status, sizeof (compose_status));
orig_keysym = keysym;
XSETFRAME (inev.ie.frame_or_window, f);
inev.ie.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f), modifiers);
inev.ie.timestamp = event.xkey.time;
if (keysym >= 32 && keysym < 128)
{
inev.ie.kind = ASCII_KEYSTROKE_EVENT;
inev.ie.code = keysym;
goto done_keysym;
}
if ((keysym >= 0x01000000 && keysym <= 0x010033ff)
|| (keysym >= 0x0100e000 && keysym <= 0x0100ffff))
{
int code = keysym & 0xFFFF, charset_id, c1, c2;
if (code < 0x80)
{
inev.ie.kind = ASCII_KEYSTROKE_EVENT;
inev.ie.code = code;
}
else if (code < 0x100)
{
if (code < 0xA0)
charset_id = CHARSET_8_BIT_CONTROL;
else
charset_id = charset_latin_iso8859_1;
inev.ie.kind = MULTIBYTE_CHAR_KEYSTROKE_EVENT;
inev.ie.code = MAKE_CHAR (charset_id, code, 0);
}
else
{
if (code < 0x2500)
charset_id = charset_mule_unicode_0100_24ff,
code -= 0x100;
else if (code < 0xE000)
charset_id = charset_mule_unicode_2500_33ff,
code -= 0x2500;
else
charset_id = charset_mule_unicode_e000_ffff,
code -= 0xE000;
c1 = (code / 96) + 32, c2 = (code % 96) + 32;
inev.ie.kind = MULTIBYTE_CHAR_KEYSTROKE_EVENT;
inev.ie.code = MAKE_CHAR (charset_id, c1, c2);
}
goto done_keysym;
}
if (HASH_TABLE_P (Vx_keysym_table)
&& (NATNUMP (c = Fgethash (make_number (keysym),
Vx_keysym_table,
Qnil))))
{
inev.ie.kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT);
inev.ie.code = XFASTINT (c);
goto done_keysym;
}
if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
|| keysym == XK_Delete
#ifdef XK_ISO_Left_Tab
|| (keysym >= XK_ISO_Left_Tab
&& keysym <= XK_ISO_Enter)
#endif
|| IsCursorKey (keysym)
|| IsMiscFunctionKey (keysym)
#ifdef HPUX
|| ((unsigned) (keysym) >= XK_Select
&& (unsigned)(keysym) < XK_KP_Space)
#endif
#ifdef XK_dead_circumflex
|| orig_keysym == XK_dead_circumflex
#endif
#ifdef XK_dead_grave
|| orig_keysym == XK_dead_grave
#endif
#ifdef XK_dead_tilde
|| orig_keysym == XK_dead_tilde
#endif
#ifdef XK_dead_diaeresis
|| orig_keysym == XK_dead_diaeresis
#endif
#ifdef XK_dead_macron
|| orig_keysym == XK_dead_macron
#endif
#ifdef XK_dead_degree
|| orig_keysym == XK_dead_degree
#endif
#ifdef XK_dead_acute
|| orig_keysym == XK_dead_acute
#endif
#ifdef XK_dead_cedilla
|| orig_keysym == XK_dead_cedilla
#endif
#ifdef XK_dead_breve
|| orig_keysym == XK_dead_breve
#endif
#ifdef XK_dead_ogonek
|| orig_keysym == XK_dead_ogonek
#endif
#ifdef XK_dead_caron
|| orig_keysym == XK_dead_caron
#endif
#ifdef XK_dead_doubleacute
|| orig_keysym == XK_dead_doubleacute
#endif
#ifdef XK_dead_abovedot
|| orig_keysym == XK_dead_abovedot
#endif
|| IsKeypadKey (keysym)
|| IsFunctionKey (keysym)
|| (orig_keysym & (1 << 28))
|| (keysym != NoSymbol && nbytes == 0))
&& ! (IsModifierKey (orig_keysym)
#ifndef HAVE_X11R5
#ifdef XK_Mode_switch
|| ((unsigned)(orig_keysym) == XK_Mode_switch)
#endif
#ifdef XK_Num_Lock
|| ((unsigned)(orig_keysym) == XK_Num_Lock)
#endif
#endif
#if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
|| ((unsigned)(orig_keysym)
>= XK_ISO_Lock
&& (unsigned)(orig_keysym)
<= XK_ISO_Last_Group_Lock)
#endif
))
{
STORE_KEYSYM_FOR_DEBUG (keysym);
inev.ie.kind = NON_ASCII_KEYSTROKE_EVENT;
inev.ie.code = keysym;
goto done_keysym;
}
{
register int i;
register int c;
int nchars, len;
setup_coding_system (coding_system, &coding);
coding.src_multibyte = 0;
coding.dst_multibyte = 1;
coding.composing = COMPOSITION_DISABLED;
for (i = 0; i < nbytes; i++)
{
STORE_KEYSYM_FOR_DEBUG (copy_bufptr[i]);
}
{
int require;
unsigned char *p;
require = decoding_buffer_size (&coding, nbytes);
p = (unsigned char *) alloca (require);
coding.mode |= CODING_MODE_LAST_BLOCK;
coding.composing = COMPOSITION_DISABLED;
decode_coding (&coding, copy_bufptr, p, nbytes, require);
nbytes = coding.produced;
nchars = coding.produced_char;
copy_bufptr = p;
}
for (i = 0; i < nbytes; i += len)
{
if (nchars == nbytes)
c = copy_bufptr[i], len = 1;
else
c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
nbytes - i, len);
inev.ie.kind = (SINGLE_BYTE_CHAR_P (c)
? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT);
inev.ie.code = c;
kbd_buffer_store_event_hold (&inev.ie, hold_quit);
}
count += nbytes;
inev.ie.kind = NO_EVENT;
if (keysym == NoSymbol)
break;
}
}
done_keysym:
#ifdef HAVE_X_I18N
break;
#else
goto OTHER;
#endif
case KeyRelease:
last_user_time = event.xkey.time;
#ifdef HAVE_X_I18N
break;
#else
goto OTHER;
#endif
case EnterNotify:
last_user_time = event.xcrossing.time;
x_detect_focus_change (dpyinfo, &event, &inev.ie);
f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
if (f && x_mouse_click_focus_ignore_position)
ignore_next_mouse_click_timeout = event.xmotion.time + 200;
#if 0
if (event.xcrossing.focus)
{
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
if (f && !f->output_data.x->hourglass_p)
note_mouse_movement (f, &event.xmotion);
#ifdef USE_GTK
if (!f && last_mouse_glyph_frame)
note_mouse_movement (last_mouse_glyph_frame, &event);
#endif
goto OTHER;
case FocusIn:
x_detect_focus_change (dpyinfo, &event, &inev.ie);
goto OTHER;
case LeaveNotify:
last_user_time = event.xcrossing.time;
x_detect_focus_change (dpyinfo, &event, &inev.ie);
f = x_top_window_to_frame (dpyinfo, event.xcrossing.window);
if (f)
{
if (f == dpyinfo->mouse_face_mouse_frame)
{
clear_mouse_face (dpyinfo);
dpyinfo->mouse_face_mouse_frame = 0;
}
if (any_help_event_p)
do_help = -1;
}
#ifdef USE_GTK
else if (last_mouse_glyph_frame)
note_mouse_movement (last_mouse_glyph_frame, &event);
#endif
goto OTHER;
case FocusOut:
x_detect_focus_change (dpyinfo, &event, &inev.ie);
goto OTHER;
case MotionNotify:
{
last_user_time = event.xmotion.time;
previous_help_echo_string = help_echo_string;
help_echo_string = Qnil;
if (dpyinfo->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
f = last_mouse_frame;
else
f = x_window_to_frame (dpyinfo, event.xmotion.window);
if (dpyinfo->mouse_face_hidden)
{
dpyinfo->mouse_face_hidden = 0;
clear_mouse_face (dpyinfo);
}
if (f)
{
if (!NILP (Vmouse_autoselect_window))
{
Lisp_Object window;
window = window_from_coordinates (f,
event.xmotion.x, event.xmotion.y,
0, 0, 0, 0);
if (WINDOWP (window)
&& !EQ (window, last_window)
&& !EQ (window, selected_window))
{
inev.ie.kind = SELECT_WINDOW_EVENT;
inev.ie.frame_or_window = window;
}
last_window=window;
}
if (!note_mouse_movement (f, &event.xmotion))
help_echo_string = previous_help_echo_string;
}
else
{
#ifndef USE_TOOLKIT_SCROLL_BARS
struct scroll_bar *bar
= x_window_to_scroll_bar (event.xmotion.display,
event.xmotion.window);
if (bar)
x_scroll_bar_note_movement (bar, &event);
#endif
clear_mouse_face (dpyinfo);
}
if (!NILP (help_echo_string)
|| !NILP (previous_help_echo_string))
do_help = 1;
goto OTHER;
}
case ConfigureNotify:
f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
if (f)
{
#ifndef USE_X_TOOLKIT
#ifdef USE_GTK
xg_resize_widgets (f, event.xconfigure.width,
event.xconfigure.height);
#else
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;
if (columns != FRAME_COLS (f)
|| rows != FRAME_LINES (f)
|| event.xconfigure.width != FRAME_PIXEL_WIDTH (f)
|| event.xconfigure.height != FRAME_PIXEL_HEIGHT (f))
{
change_frame_size (f, rows, columns, 0, 1, 0);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
}
#endif
#endif
FRAME_PIXEL_WIDTH (f) = event.xconfigure.width;
FRAME_PIXEL_HEIGHT (f) = event.xconfigure.height;
#ifdef USE_GTK
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
if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMStatusArea))
xic_set_statusarea (f);
#endif
if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
{
f->win_gravity = NorthWestGravity;
x_wm_set_size_hint (f, (long) 0, 0);
}
}
goto OTHER;
case ButtonRelease:
case ButtonPress:
{
int tool_bar_p = 0;
bzero (&compose_status, sizeof (compose_status));
last_mouse_glyph_frame = 0;
last_user_time = event.xbutton.time;
if (dpyinfo->grabbed
&& last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
f = last_mouse_frame;
else
f = x_window_to_frame (dpyinfo, event.xbutton.window);
if (f)
{
if (WINDOWP (f->tool_bar_window)
&& WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
{
Lisp_Object window;
int x = event.xbutton.x;
int y = event.xbutton.y;
window = window_from_coordinates (f, x, y, 0, 0, 0, 1);
tool_bar_p = EQ (window, f->tool_bar_window);
if (tool_bar_p && event.xbutton.button < 4)
{
if (event.xbutton.type == ButtonPress)
handle_tool_bar_click (f, x, y, 1, 0);
else
handle_tool_bar_click (f, x, y, 0,
x_x_to_emacs_modifiers (dpyinfo,
event.xbutton.state));
}
}
if (!tool_bar_p)
if (!dpyinfo->x_focus_frame
|| f == dpyinfo->x_focus_frame)
{
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
if (! popup_activated ())
#endif
{
if (ignore_next_mouse_click_timeout)
{
if (event.type == ButtonPress
&& (int)(event.xbutton.time - ignore_next_mouse_click_timeout) > 0)
{
ignore_next_mouse_click_timeout = 0;
construct_mouse_click (&inev.ie, &event.xbutton, f);
}
if (event.type == ButtonRelease)
ignore_next_mouse_click_timeout = 0;
}
else
construct_mouse_click (&inev.ie, &event.xbutton, f);
}
}
}
else
{
struct scroll_bar *bar
= x_window_to_scroll_bar (event.xbutton.display,
event.xbutton.window);
#ifdef USE_TOOLKIT_SCROLL_BARS
if (bar && event.xbutton.state & ControlMask)
{
x_scroll_bar_handle_click (bar, &event, &inev.ie);
*finish = X_EVENT_DROP;
}
#else
if (bar)
x_scroll_bar_handle_click (bar, &event, &inev.ie);
#endif
}
if (event.type == ButtonPress)
{
dpyinfo->grabbed |= (1 << event.xbutton.button);
last_mouse_frame = f;
if (!tool_bar_p)
last_tool_bar_item = -1;
}
else
dpyinfo->grabbed &= ~(1 << event.xbutton.button);
if (f != 0)
f->mouse_moved = 0;
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
if (
#ifdef USE_GTK
! popup_activated ()
&&
#endif
f && event.type == ButtonPress
&& event.xbutton.x >= 0
&& event.xbutton.x < FRAME_PIXEL_WIDTH (f)
&& event.xbutton.y >= 0
&& event.xbutton.y < f->output_data.x->menubar_height
&& event.xbutton.same_screen)
{
SET_SAVED_BUTTON_EVENT;
XSETFRAME (last_mouse_press_frame, f);
#ifdef USE_GTK
*finish = X_EVENT_DROP;
#endif
}
else if (event.type == ButtonPress)
{
last_mouse_press_frame = Qnil;
goto OTHER;
}
#ifdef USE_MOTIF
else if (event.type == ButtonRelease)
{
if (!NILP (last_mouse_press_frame))
{
f = XFRAME (last_mouse_press_frame);
if (f->output_data.x)
SET_SAVED_BUTTON_EVENT;
}
else
goto OTHER;
}
#endif
else
goto OTHER;
#endif
}
break;
case CirculateNotify:
goto OTHER;
case CirculateRequest:
goto OTHER;
case VisibilityNotify:
goto OTHER;
case MappingNotify:
switch (event.xmapping.request)
{
case MappingModifier:
x_find_modifier_meanings (dpyinfo);
case MappingKeyboard:
XRefreshKeyboardMapping (&event.xmapping);
}
goto OTHER;
default:
OTHER:
#ifdef USE_X_TOOLKIT
BLOCK_INPUT;
if (*finish != X_EVENT_DROP)
XtDispatchEvent (&event);
UNBLOCK_INPUT;
#endif
break;
}
done:
if (inev.ie.kind != NO_EVENT)
{
kbd_buffer_store_event_hold (&inev.ie, hold_quit);
count++;
}
if (do_help
&& !(hold_quit && hold_quit->kind != NO_EVENT))
{
Lisp_Object frame;
if (f)
XSETFRAME (frame, f);
else
frame = Qnil;
if (do_help > 0)
{
any_help_event_p = 1;
gen_help_event (help_echo_string, frame, help_echo_window,
help_echo_object, help_echo_pos);
}
else
{
help_echo_string = Qnil;
gen_help_event (Qnil, frame, Qnil, Qnil, 0);
}
count++;
}
*eventp = event;
return count;
}
int
x_dispatch_event (event, display)
XEvent *event;
Display *display;
{
struct x_display_info *dpyinfo;
int finish = X_EVENT_NORMAL;
dpyinfo = x_display_info_for_display (display);
if (dpyinfo)
handle_one_xevent (dpyinfo, event, &finish, 0);
return finish;
}
static int
XTread_socket (sd, expected, hold_quit)
register int sd;
int expected;
struct input_event *hold_quit;
{
int count = 0;
XEvent event;
int event_found = 0;
struct x_display_info *dpyinfo;
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
return -1;
}
interrupt_input_pending = 0;
BLOCK_INPUT;
input_signal_count++;
++handling_signal;
for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
{
#if 0
#ifdef FIOSNBIO
fcntl (dpyinfo->connection, F_SETFL, 0);
#endif
#endif
#if 0
#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
#endif
#endif
if (dpyinfo == XTread_socket_fake_io_error)
{
XTread_socket_fake_io_error = 0;
x_io_error_quitter (dpyinfo->display);
}
#ifdef HAVE_X_SM
{
struct input_event inev;
BLOCK_INPUT;
if (x_session_check_input (&inev))
{
kbd_buffer_store_event_hold (&inev, hold_quit);
count++;
}
UNBLOCK_INPUT;
}
#endif
#ifndef USE_GTK
while (XPending (dpyinfo->display))
{
int finish;
XNextEvent (dpyinfo->display, &event);
#ifdef HAVE_X_I18N
if (x_filter_event (dpyinfo, &event))
break;
#endif
event_found = 1;
count += handle_one_xevent (dpyinfo, &event, &finish, hold_quit);
if (finish == X_EVENT_GOTO_OUT)
goto out;
}
#endif
}
#ifdef USE_GTK
while (gtk_events_pending ())
{
current_count = count;
current_hold_quit = hold_quit;
gtk_main_iteration ();
count = current_count;
current_count = -1;
current_hold_quit = 0;
if (current_finish == X_EVENT_GOTO_OUT)
break;
}
#endif
out:;
if (! event_found)
{
x_noop_count++;
if (x_noop_count >= 100)
{
x_noop_count=0;
if (next_noop_dpyinfo == 0)
next_noop_dpyinfo = x_display_list;
XNoOp (next_noop_dpyinfo->display);
next_noop_dpyinfo = next_noop_dpyinfo->next;
}
}
if (pending_autoraise_frame)
{
x_raise_frame (pending_autoraise_frame);
pending_autoraise_frame = 0;
}
--handling_signal;
UNBLOCK_INPUT;
return count;
}
static void
x_clip_to_row (w, row, area, gc)
struct window *w;
struct glyph_row *row;
int area;
GC gc;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
XRectangle clip_rect;
int window_x, window_y, window_width;
window_box (w, area, &window_x, &window_y, &window_width, 0);
clip_rect.x = window_x;
clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, row->y));
clip_rect.y = max (clip_rect.y, window_y);
clip_rect.width = window_width;
clip_rect.height = row->visible_height;
XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, &clip_rect, 1, Unsorted);
}
static void
x_draw_hollow_cursor (w, row)
struct window *w;
struct glyph_row *row;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Display *dpy = FRAME_X_DISPLAY (f);
int x, y, wd, h;
XGCValues xgcv;
struct glyph *cursor_glyph;
GC gc;
cursor_glyph = get_phys_cursor_glyph (w);
if (cursor_glyph == NULL)
return;
get_phys_cursor_geometry (w, row, cursor_glyph, &x, &y, &h);
wd = w->phys_cursor_width;
xgcv.foreground = f->output_data.x->cursor_pixel;
if (dpyinfo->scratch_cursor_gc)
XChangeGC (dpy, dpyinfo->scratch_cursor_gc, GCForeground, &xgcv);
else
dpyinfo->scratch_cursor_gc = XCreateGC (dpy, FRAME_X_WINDOW (f),
GCForeground, &xgcv);
gc = dpyinfo->scratch_cursor_gc;
x_clip_to_row (w, row, TEXT_AREA, gc);
XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h - 1);
XSetClipMask (dpy, gc, None);
}
static void
x_draw_bar_cursor (w, row, width, kind)
struct window *w;
struct glyph_row *row;
int width;
enum text_cursor_kinds kind;
{
struct frame *f = XFRAME (w->frame);
struct glyph *cursor_glyph;
cursor_glyph = get_phys_cursor_glyph (w);
if (cursor_glyph == NULL)
return;
if (cursor_glyph->type == IMAGE_GLYPH)
{
struct glyph_row *row;
row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
}
else
{
Display *dpy = FRAME_X_DISPLAY (f);
Window window = FRAME_X_WINDOW (f);
GC gc = FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc;
unsigned long mask = GCForeground | GCBackground | GCGraphicsExposures;
struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
XGCValues xgcv;
if (face->background == f->output_data.x->cursor_pixel)
xgcv.background = xgcv.foreground = face->foreground;
else
xgcv.background = xgcv.foreground = f->output_data.x->cursor_pixel;
xgcv.graphics_exposures = 0;
if (gc)
XChangeGC (dpy, gc, mask, &xgcv);
else
{
gc = XCreateGC (dpy, window, mask, &xgcv);
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)
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
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);
XSetClipMask (dpy, gc, None);
}
}
static void
x_define_frame_cursor (f, cursor)
struct frame *f;
Cursor cursor;
{
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
}
static void
x_clear_frame_area (f, x, y, width, height)
struct frame *f;
int x, y, width, height;
{
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
x, y, width, height, False);
}
static void
x_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, active_p)
struct window *w;
struct glyph_row *glyph_row;
int x, y;
int cursor_type, cursor_width;
int on_p, active_p;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
if (on_p)
{
w->phys_cursor_type = cursor_type;
w->phys_cursor_on_p = 1;
if (glyph_row->exact_window_width_line_p
&& w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
{
glyph_row->cursor_in_fringe_p = 1;
draw_fringe_bitmap (w, glyph_row, 0);
}
else
switch (cursor_type)
{
case HOLLOW_BOX_CURSOR:
x_draw_hollow_cursor (w, glyph_row);
break;
case FILLED_BOX_CURSOR:
draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
break;
case BAR_CURSOR:
x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
break;
case HBAR_CURSOR:
x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
break;
case NO_CURSOR:
w->phys_cursor_width = 0;
break;
default:
abort ();
}
#ifdef HAVE_X_I18N
if (w == XWINDOW (f->selected_window))
if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
xic_set_preeditarea (w, x, y);
#endif
}
#ifndef XFlush
if (updating_frame != f)
XFlush (FRAME_X_DISPLAY (f));
#endif
}
int
x_bitmap_icon (f, file)
struct frame *f;
Lisp_Object file;
{
int bitmap_id;
if (FRAME_X_WINDOW (f) == 0)
return 1;
if (f->output_data.x->icon_bitmap > 0)
x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
f->output_data.x->icon_bitmap = 0;
if (STRINGP (file))
{
#ifdef USE_GTK
if (xg_set_icon (f, file))
return 0;
#endif
bitmap_id = x_create_bitmap_from_file (f, file);
x_create_bitmap_mask (f, bitmap_id);
}
else
{
if (FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
{
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))
return 0;
#else
rc = x_create_bitmap_from_xpm_data (f, gnu_xpm_bits);
if (rc != -1)
FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id = rc;
#endif
#endif
if (rc == -1)
{
rc = x_create_bitmap_from_data (f, gnu_xbm_bits,
gnu_xbm_width, gnu_xbm_height);
if (rc == -1)
return 1;
FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id = rc;
x_create_bitmap_mask (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
}
}
x_reference_bitmap (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
bitmap_id = FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id;
}
x_wm_set_icon_pixmap (f, bitmap_id);
f->output_data.x->icon_bitmap = bitmap_id;
return 0;
}
int
x_text_icon (f, icon_name)
struct frame *f;
char *icon_name;
{
if (FRAME_X_WINDOW (f) == 0)
return 1;
#ifdef HAVE_X11R4
{
XTextProperty text;
text.value = (unsigned char *) icon_name;
text.encoding = XA_STRING;
text.format = 8;
text.nitems = strlen (icon_name);
XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
}
#else
XSetIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), icon_name);
#endif
if (f->output_data.x->icon_bitmap > 0)
x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
f->output_data.x->icon_bitmap = 0;
x_wm_set_icon_pixmap (f, 0);
return 0;
}
#define X_ERROR_MESSAGE_SIZE 200
struct x_error_message_stack {
char string[X_ERROR_MESSAGE_SIZE];
Display *dpy;
struct x_error_message_stack *prev;
};
static struct x_error_message_stack *x_error_message;
static void
x_error_catcher (display, error)
Display *display;
XErrorEvent *error;
{
XGetErrorText (display, error->error_code,
x_error_message->string,
X_ERROR_MESSAGE_SIZE);
}
void x_check_errors ();
void
x_catch_errors (dpy)
Display *dpy;
{
struct x_error_message_stack *data = xmalloc (sizeof (*data));
XSync (dpy, False);
data->dpy = dpy;
data->string[0] = 0;
data->prev = x_error_message;
x_error_message = data;
}
void
x_uncatch_errors ()
{
struct x_error_message_stack *tmp;
BLOCK_INPUT;
if (x_display_info_for_display (x_error_message->dpy) != 0)
XSync (x_error_message->dpy, False);
tmp = x_error_message;
x_error_message = x_error_message->prev;
xfree (tmp);
UNBLOCK_INPUT;
}
void
x_check_errors (dpy, format)
Display *dpy;
char *format;
{
XSync (dpy, False);
if (x_error_message->string[0])
{
char string[X_ERROR_MESSAGE_SIZE];
bcopy (x_error_message->string, string, X_ERROR_MESSAGE_SIZE);
x_uncatch_errors ();
error (format, string);
}
}
int
x_had_errors_p (dpy)
Display *dpy;
{
XSync (dpy, False);
return x_error_message->string[0] != 0;
}
void
x_clear_errors (dpy)
Display *dpy;
{
x_error_message->string[0] = 0;
}
void
x_fully_uncatch_errors ()
{
while (x_error_message)
x_uncatch_errors ();
}
int
x_catching_errors ()
{
return x_error_message != 0;
}
#if 0
static unsigned int x_wire_count;
x_trace_wire ()
{
fprintf (stderr, "Lib call: %d\n", ++x_wire_count);
}
#endif
static SIGTYPE
x_connection_signal (signalnum)
int signalnum;
{
#ifdef USG
signal (signalnum, x_connection_signal);
#endif
}
static char *error_msg;
static void
x_fatal_error_signal ()
{
fprintf (stderr, "%s\n", error_msg);
exit (70);
}
static SIGTYPE
x_connection_closed (dpy, error_message)
Display *dpy;
char *error_message;
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
Lisp_Object frame, tail;
error_msg = (char *) alloca (strlen (error_message) + 1);
strcpy (error_msg, error_message);
handling_signal = 0;
x_catch_errors (dpy);
#ifdef USE_X_TOOLKIT
if (dpyinfo)
{
extern void (*fatal_error_signal_hook) P_ ((void));
fatal_error_signal_hook = x_fatal_error_signal;
XtCloseDisplay (dpy);
fatal_error_signal_hook = NULL;
}
#endif
#ifdef USE_GTK
if (dpyinfo)
xg_display_close (dpyinfo->display);
#endif
if (dpyinfo)
dpyinfo->display = 0;
FOR_EACH_FRAME (tail, frame)
{
Lisp_Object minibuf_frame;
minibuf_frame
= WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame))));
if (FRAME_X_P (XFRAME (frame))
&& FRAME_X_P (XFRAME (minibuf_frame))
&& ! EQ (frame, minibuf_frame)
&& FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame)) == dpyinfo)
Fdelete_frame (frame, Qt);
}
FOR_EACH_FRAME (tail, frame)
if (FRAME_X_P (XFRAME (frame))
&& FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
{
FRAME_KBOARD (XFRAME (frame))->Vdefault_minibuffer_frame = Qt;
Fdelete_frame (frame, Qt);
}
if (dpyinfo)
x_delete_display (dpyinfo);
x_uncatch_errors ();
if (x_display_list == 0)
{
fprintf (stderr, "%s\n", error_msg);
shut_down_emacs (0, 0, Qnil);
exit (70);
}
#ifdef SIGIO
sigunblock (sigmask (SIGIO));
#endif
sigunblock (sigmask (SIGALRM));
TOTALLY_UNBLOCK_INPUT;
clear_waiting_for_input ();
error ("%s", error_msg);
}
static void x_error_quitter P_ ((Display *, XErrorEvent *));
static int
x_error_handler (display, error)
Display *display;
XErrorEvent *error;
{
if (x_error_message)
x_error_catcher (display, error);
else
x_error_quitter (display, error);
return 0;
}
#if __GNUC__ >= 3
#define NO_INLINE __attribute__((noinline))
#else
#define NO_INLINE
#endif
#ifdef noinline
#undef noinline
#endif
static void NO_INLINE
x_error_quitter (display, error)
Display *display;
XErrorEvent *error;
{
char buf[256], buf1[356];
if (error->error_code == BadName)
return;
XGetErrorText (display, error->error_code, buf, sizeof (buf));
sprintf (buf1, "X protocol error: %s on protocol request %d",
buf, error->request_code);
x_connection_closed (display, buf1);
}
static int
x_io_error_quitter (display)
Display *display;
{
char buf[256];
sprintf (buf, "Connection lost to X server `%s'", DisplayString (display));
x_connection_closed (display, buf);
return 0;
}
Lisp_Object
x_new_font (f, fontname)
struct frame *f;
register char *fontname;
{
struct font_info *fontp
= FS_LOAD_FONT (f, 0, fontname, -1);
if (!fontp)
return Qnil;
FRAME_FONT (f) = (XFontStruct *) (fontp->font);
FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset;
FRAME_FONTSET (f) = -1;
FRAME_COLUMN_WIDTH (f) = fontp->average_width;
FRAME_SPACE_WIDTH (f) = fontp->space_width;
FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (FRAME_FONT (f));
compute_fringe_widths (f, 1);
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;
}
if (FRAME_X_WINDOW (f) != 0)
{
XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
FRAME_FONT (f)->fid);
XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc,
FRAME_FONT (f)->fid);
XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc,
FRAME_FONT (f)->fid);
if (NILP (tip_frame) || XFRAME (tip_frame) != f)
x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
}
return build_string (fontp->full_name);
}
Lisp_Object
x_new_fontset (f, fontsetname)
struct frame *f;
char *fontsetname;
{
int fontset = fs_query_fontset (build_string (fontsetname), 0);
Lisp_Object result;
if (fontset < 0)
return Qnil;
if (FRAME_FONTSET (f) == fontset)
return fontset_name (fontset);
result = x_new_font (f, (SDATA (fontset_ascii (fontset))));
if (!STRINGP (result))
return Qnil;
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 build_string (fontsetname);
}
#ifdef HAVE_X_I18N
#ifdef HAVE_X11R6
static void
xim_destroy_callback (xim, client_data, call_data)
XIM xim;
XPointer client_data;
XPointer call_data;
{
struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
Lisp_Object frame, tail;
BLOCK_INPUT;
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
if (FRAME_X_DISPLAY_INFO (f) == dpyinfo)
{
FRAME_XIC (f) = NULL;
xic_free_xfontset (f);
}
}
dpyinfo->xim = NULL;
XFree (dpyinfo->xim_styles);
UNBLOCK_INPUT;
}
#endif
#ifdef HAVE_X11R6
extern char *XSetIMValues P_ ((XIM, ...));
#endif
static void
xim_open_dpy (dpyinfo, resource_name)
struct x_display_info *dpyinfo;
char *resource_name;
{
XIM xim;
#ifdef HAVE_XIM
if (use_xim)
{
xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name,
EMACS_CLASS);
dpyinfo->xim = xim;
if (xim)
{
#ifdef HAVE_X11R6
XIMCallback destroy;
#endif
XGetIMValues (xim, XNQueryInputStyle, &dpyinfo->xim_styles, NULL);
#ifdef HAVE_X11R6
destroy.callback = xim_destroy_callback;
destroy.client_data = (XPointer)dpyinfo;
XSetIMValues (xim, XNDestroyCallback, &destroy, NULL);
#endif
}
}
else
#endif
dpyinfo->xim = NULL;
}
#ifdef HAVE_X11R6_XIM
struct xim_inst_t
{
struct x_display_info *dpyinfo;
char *resource_name;
};
static void
xim_instantiate_callback (display, client_data, call_data)
Display *display;
XPointer client_data;
XPointer call_data;
{
struct xim_inst_t *xim_inst = (struct xim_inst_t *) client_data;
struct x_display_info *dpyinfo = xim_inst->dpyinfo;
if (dpyinfo->xim)
return;
xim_open_dpy (dpyinfo, xim_inst->resource_name);
if (dpyinfo->xim && dpyinfo->reference_count > 0)
{
Lisp_Object tail, frame;
BLOCK_INPUT;
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
if (FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
if (FRAME_XIC (f) == NULL)
{
create_frame_xic (f);
if (FRAME_XIC_STYLE (f) & XIMStatusArea)
xic_set_statusarea (f);
if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
{
struct window *w = XWINDOW (f->selected_window);
xic_set_preeditarea (w, w->cursor.x, w->cursor.y);
}
}
}
UNBLOCK_INPUT;
}
}
#endif
static void
xim_initialize (dpyinfo, resource_name)
struct x_display_info *dpyinfo;
char *resource_name;
{
#ifdef HAVE_XIM
if (use_xim)
{
#ifdef HAVE_X11R6_XIM
struct xim_inst_t *xim_inst;
int len;
dpyinfo->xim = NULL;
xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
xim_inst->dpyinfo = dpyinfo;
len = strlen (resource_name);
xim_inst->resource_name = (char *) xmalloc (len + 1);
bcopy (resource_name, xim_inst->resource_name, len + 1);
XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
resource_name, EMACS_CLASS,
xim_instantiate_callback,
(XRegisterIMInstantiateCallback_arg6) xim_inst);
#else
dpyinfo->xim = NULL;
xim_open_dpy (dpyinfo, resource_name);
#endif
}
else
#endif
dpyinfo->xim = NULL;
}
static void
xim_close_dpy (dpyinfo)
struct x_display_info *dpyinfo;
{
#ifdef HAVE_XIM
if (use_xim)
{
#ifdef HAVE_X11R6_XIM
if (dpyinfo->display)
XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
NULL, EMACS_CLASS,
xim_instantiate_callback, NULL);
#endif
if (dpyinfo->display)
XCloseIM (dpyinfo->xim);
dpyinfo->xim = NULL;
XFree (dpyinfo->xim_styles);
}
#endif
}
#endif
void
x_calc_absolute_position (f)
struct frame *f;
{
int flags = f->size_hint_flags;
if (! ((flags & XNegative) || (flags & YNegative)))
return;
if (flags & XNegative)
f->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
- FRAME_PIXEL_WIDTH (f) + f->left_pos);
{
int height = FRAME_PIXEL_HEIGHT (f);
#if defined USE_X_TOOLKIT && defined USE_MOTIF
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);
}
f->size_hint_flags &= ~ (XNegative | YNegative);
}
void
x_set_offset (f, xoff, yoff, change_gravity)
struct frame *f;
register int xoff, yoff;
int change_gravity;
{
int modified_top, modified_left;
if (change_gravity != 0)
{
FRAME_X_OUTPUT (f)->left_before_move = f->left_pos;
FRAME_X_OUTPUT (f)->top_before_move = f->top_pos;
f->top_pos = yoff;
f->left_pos = xoff;
f->size_hint_flags &= ~ (XNegative | YNegative);
if (xoff < 0)
f->size_hint_flags |= XNegative;
if (yoff < 0)
f->size_hint_flags |= YNegative;
f->win_gravity = NorthWestGravity;
}
x_calc_absolute_position (f);
BLOCK_INPUT;
x_wm_set_size_hint (f, (long) 0, 0);
modified_left = f->left_pos;
modified_top = f->top_pos;
if (change_gravity != 0 && FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A)
{
modified_left += FRAME_X_OUTPUT (f)->move_offset_left;
modified_top += FRAME_X_OUTPUT (f)->move_offset_top;
}
XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
modified_left, modified_top);
x_sync_with_move (f, f->left_pos, f->top_pos,
FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN
? 1 : 0);
if (change_gravity != 0 &&
(FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN
|| (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A
&& (FRAME_X_OUTPUT (f)->move_offset_left == 0
&& FRAME_X_OUTPUT (f)->move_offset_top == 0))))
x_check_expected_move (f, modified_left, modified_top);
UNBLOCK_INPUT;
}
static int
wm_supports (f, atomname)
struct frame *f;
const char *atomname;
{
Atom actual_type;
unsigned long actual_size, bytes_remaining;
int i, rc, actual_format;
Atom prop_atom;
Window wmcheck_window;
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Window target_window = dpyinfo->root_window;
long max_len = 65536;
Display *dpy = FRAME_X_DISPLAY (f);
unsigned char *tmp_data = NULL;
Atom target_type = XA_WINDOW;
Atom want_atom;
BLOCK_INPUT;
prop_atom = XInternAtom (dpy, "_NET_SUPPORTING_WM_CHECK", False);
x_catch_errors (dpy);
rc = XGetWindowProperty (dpy, target_window,
prop_atom, 0, max_len, False, target_type,
&actual_type, &actual_format, &actual_size,
&bytes_remaining, &tmp_data);
if (rc != Success || actual_type != XA_WINDOW || x_had_errors_p (dpy))
{
if (tmp_data) XFree (tmp_data);
x_uncatch_errors ();
UNBLOCK_INPUT;
return 0;
}
wmcheck_window = *(Window *) tmp_data;
XFree (tmp_data);
XSelectInput (dpy, wmcheck_window, StructureNotifyMask);
x_sync (f);
if (x_had_errors_p (dpy))
{
x_uncatch_errors ();
UNBLOCK_INPUT;
return 0;
}
if (dpyinfo->net_supported_window != wmcheck_window)
{
if (dpyinfo->net_supported_atoms != NULL)
XFree (dpyinfo->net_supported_atoms);
dpyinfo->net_supported_atoms = NULL;
dpyinfo->nr_net_supported_atoms = 0;
dpyinfo->net_supported_window = 0;
target_type = XA_ATOM;
prop_atom = XInternAtom (dpy, "_NET_SUPPORTED", False);
tmp_data = NULL;
rc = XGetWindowProperty (dpy, target_window,
prop_atom, 0, max_len, False, target_type,
&actual_type, &actual_format, &actual_size,
&bytes_remaining, &tmp_data);
if (rc != Success || actual_type != XA_ATOM || x_had_errors_p (dpy))
{
if (tmp_data) XFree (tmp_data);
x_uncatch_errors ();
UNBLOCK_INPUT;
return 0;
}
dpyinfo->net_supported_atoms = (Atom *)tmp_data;
dpyinfo->nr_net_supported_atoms = actual_size;
dpyinfo->net_supported_window = wmcheck_window;
}
rc = 0;
want_atom = XInternAtom (dpy, atomname, False);
for (i = 0; rc == 0 && i < dpyinfo->nr_net_supported_atoms; ++i)
rc = dpyinfo->net_supported_atoms[i] == want_atom;
x_uncatch_errors ();
UNBLOCK_INPUT;
return rc;
}
static int
do_ewmh_fullscreen (f)
struct frame *f;
{
int have_net_atom = wm_supports (f, "_NET_WM_STATE");
if (!have_net_atom)
have_net_atom = wm_supports (f, "_NET_WM_STATE_FULLSCREEN");
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);
switch (f->want_fullscreen)
{
case FULLSCREEN_BOTH:
what = fs;
break;
case FULLSCREEN_WIDTH:
what = fw;
break;
case FULLSCREEN_HEIGHT:
what = 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),
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),
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),
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),
Fcons
(make_unibyte_string (what,
strlen (what)),
Qnil)));
}
return have_net_atom;
}
static void
XTfullscreen_hook (f)
FRAME_PTR f;
{
if (f->async_visible)
{
BLOCK_INPUT;
do_ewmh_fullscreen (f);
x_sync (f);
UNBLOCK_INPUT;
}
}
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;
x_real_positions (f, &f->left_pos, &f->top_pos);
x_fullscreen_adjust (f, &width, &height, &ign, &ign);
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);
f->want_fullscreen |= FULLSCREEN_WAIT;
}
}
}
static void
x_check_expected_move (f, expected_left, expected_top)
struct frame *f;
int expected_left;
int expected_top;
{
int current_left = 0, current_top = 0;
x_real_positions (f, ¤t_left, ¤t_top);
if (current_left != expected_left || current_top != expected_top)
{
int adjusted_left;
int adjusted_top;
FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_A;
FRAME_X_OUTPUT (f)->move_offset_left = expected_left - current_left;
FRAME_X_OUTPUT (f)->move_offset_top = expected_top - current_top;
adjusted_left = expected_left + FRAME_X_OUTPUT (f)->move_offset_left;
adjusted_top = expected_top + FRAME_X_OUTPUT (f)->move_offset_top;
XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
adjusted_left, adjusted_top);
x_sync_with_move (f, expected_left, expected_top, 0);
}
else
FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_B;
}
static void
x_sync_with_move (f, left, top, fuzzy)
struct frame *f;
int left, top, fuzzy;
{
int count = 0;
while (count++ < 50)
{
int current_left = 0, current_top = 0;
XSync (FRAME_X_DISPLAY (f), False);
x_real_positions (f, ¤t_left, ¤t_top);
if (fuzzy)
{
if (abs (current_left - left) <= 10 && abs (current_top - top) <= 40)
return;
}
else if (current_left == left && current_top == top)
return;
}
wait_reading_process_output (0, 500000, 0, 0, Qnil, NULL, 0);
}
static void
x_set_window_size_1 (f, change_gravity, cols, rows)
struct frame *f;
int change_gravity;
int cols, rows;
{
int pixelwidth, pixelheight;
check_frame_size (f, &rows, &cols);
f->scroll_bar_actual_width
= (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
? 0
: FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
? FRAME_CONFIG_SCROLL_BAR_WIDTH (f)
: (FRAME_CONFIG_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f)));
compute_fringe_widths (f, 0);
pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
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),
pixelwidth, pixelheight);
change_frame_size (f, rows, cols, 0, 1, 0);
FRAME_PIXEL_WIDTH (f) = pixelwidth;
FRAME_PIXEL_HEIGHT (f) = pixelheight;
SET_FRAME_GARBAGED (f);
XFlush (FRAME_X_DISPLAY (f));
}
void
x_set_window_size (f, change_gravity, cols, rows)
struct frame *f;
int change_gravity;
int cols, rows;
{
BLOCK_INPUT;
#ifdef USE_GTK
if (FRAME_GTK_WIDGET (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)
{
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
x_set_window_size_1 (f, change_gravity, cols, rows);
#endif
mark_window_cursors_off (XWINDOW (f->root_window));
cancel_mouse_face (f);
UNBLOCK_INPUT;
}
void
x_set_mouse_position (f, x, y)
struct frame *f;
int x, y;
{
int pix_x, pix_y;
pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
if (pix_x < 0) pix_x = 0;
if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
if (pix_y < 0) pix_y = 0;
if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
BLOCK_INPUT;
XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
0, 0, 0, 0, pix_x, pix_y);
UNBLOCK_INPUT;
}
void
x_set_mouse_pixel_position (f, pix_x, pix_y)
struct frame *f;
int pix_x, pix_y;
{
BLOCK_INPUT;
XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
0, 0, 0, 0, pix_x, pix_y);
UNBLOCK_INPUT;
}
void
x_focus_on_frame (f)
struct frame *f;
{
#if 0
x_raise_frame (f);
#endif
#if 0
XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
RevertToPointerRoot, CurrentTime);
#endif
}
void
x_unfocus_frame (f)
struct frame *f;
{
#if 0
if (FRAME_X_DISPLAY_INFO (f)->x_focus_frame == f)
XSetInputFocus (FRAME_X_DISPLAY (f), PointerRoot,
RevertToPointerRoot, CurrentTime);
#endif
}
void
x_raise_frame (f)
struct frame *f;
{
BLOCK_INPUT;
if (f->async_visible)
XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
void
x_lower_frame (f)
struct frame *f;
{
if (f->async_visible)
{
BLOCK_INPUT;
XLowerWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
}
static void
XTframe_raise_lower (f, raise_flag)
FRAME_PTR f;
int raise_flag;
{
if (raise_flag)
{
#if 0
const char *atom = "_NET_ACTIVE_WINDOW";
if (f->async_visible && wm_supports (f, atom))
{
Lisp_Object frame;
XSETFRAME (frame, f);
Fx_send_client_event (frame, make_number (0), frame,
make_unibyte_string (atom, strlen (atom)),
make_number (32),
Fcons (make_number (1),
Fcons (make_number (last_user_time),
Qnil)));
}
else
#endif
x_raise_frame (f);
}
else
x_lower_frame (f);
}
void
x_make_frame_visible (f)
struct frame *f;
{
Lisp_Object type;
int original_top, original_left;
int retry_count = 2;
retry:
BLOCK_INPUT;
type = x_icon_type (f);
if (!NILP (type))
x_bitmap_icon (f, type);
if (! FRAME_VISIBLE_P (f))
{
if (! FRAME_ICONIFIED_P (f)
&& ! f->output_data.x->asked_for_visible)
x_set_offset (f, f->left_pos, f->top_pos, 0);
f->output_data.x->asked_for_visible = 1;
if (! EQ (Vx_no_window_manager, Qt))
x_wm_set_window_state (f, NormalState);
#ifdef USE_X_TOOLKIT
XtMapWidget (f->output_data.x->widget);
#else
#ifdef USE_GTK
gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
#else
XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
#endif
#if 0
if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
}
XFlush (FRAME_X_DISPLAY (f));
{
Lisp_Object frame;
int count;
int previously_visible = f->output_data.x->has_been_visible;
original_left = f->left_pos;
original_top = f->top_pos;
UNBLOCK_INPUT;
if (! FRAME_VISIBLE_P (f) && ! FRAME_ICONIFIED_P (f)
&& f->win_gravity == NorthWestGravity
&& previously_visible)
{
Drawable rootw;
int x, y;
unsigned int width, height, border, depth;
BLOCK_INPUT;
XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
&rootw, &x, &y, &width, &height, &border, &depth);
if (original_left != x || original_top != y)
XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
original_left, original_top);
UNBLOCK_INPUT;
}
XSETFRAME (frame, f);
for (count = input_signal_count + 10;
input_signal_count < count && !FRAME_VISIBLE_P (f);)
{
x_sync (f);
if (input_polling_used ())
{
extern void poll_for_input_1 P_ ((void));
int old_poll_suppress_count = poll_suppress_count;
poll_suppress_count = 1;
poll_for_input_1 ();
poll_suppress_count = old_poll_suppress_count;
}
FRAME_SAMPLE_VISIBILITY (f);
}
if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
goto retry;
}
}
void
x_make_frame_invisible (f)
struct frame *f;
{
Window window;
window = FRAME_OUTER_WINDOW (f);
if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
#if 0
if (! f->async_visible && ! f->async_iconified)
return;
#endif
BLOCK_INPUT;
x_wm_set_size_hint (f, (long) 0, 1);
#ifdef USE_GTK
if (FRAME_GTK_OUTER_WIDGET (f))
gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f));
else
#endif
{
#ifdef HAVE_X11R4
if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
DefaultScreen (FRAME_X_DISPLAY (f))))
{
UNBLOCK_INPUT_RESIGNAL;
error ("Can't notify window manager of window withdrawal");
}
#else
if (! EQ (Vx_no_window_manager, Qt))
{
XEvent unmap;
unmap.xunmap.type = UnmapNotify;
unmap.xunmap.window = window;
unmap.xunmap.event = DefaultRootWindow (FRAME_X_DISPLAY (f));
unmap.xunmap.from_configure = False;
if (! XSendEvent (FRAME_X_DISPLAY (f),
DefaultRootWindow (FRAME_X_DISPLAY (f)),
False,
SubstructureRedirectMaskSubstructureNotifyMask,
&unmap))
{
UNBLOCK_INPUT_RESIGNAL;
error ("Can't notify window manager of withdrawal");
}
}
XUnmapWindow (FRAME_X_DISPLAY (f), window);
#endif
}
f->visible = 0;
FRAME_ICONIFIED_P (f) = 0;
f->async_visible = 0;
f->async_iconified = 0;
x_sync (f);
UNBLOCK_INPUT;
}
void
x_iconify_frame (f)
struct frame *f;
{
int result;
Lisp_Object type;
if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
if (f->async_iconified)
return;
BLOCK_INPUT;
FRAME_SAMPLE_VISIBILITY (f);
type = x_icon_type (f);
if (!NILP (type))
x_bitmap_icon (f, type);
#ifdef USE_GTK
if (FRAME_GTK_OUTER_WIDGET (f))
{
if (! FRAME_VISIBLE_P (f))
gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
f->iconified = 1;
f->visible = 1;
f->async_iconified = 1;
f->async_visible = 0;
UNBLOCK_INPUT;
return;
}
#endif
#ifdef USE_X_TOOLKIT
if (! FRAME_VISIBLE_P (f))
{
if (! EQ (Vx_no_window_manager, Qt))
x_wm_set_window_state (f, IconicState);
XtMapWidget (f->output_data.x->widget);
f->iconified = 1;
f->visible = 1;
f->async_iconified = 1;
f->async_visible = 0;
UNBLOCK_INPUT;
return;
}
result = XIconifyWindow (FRAME_X_DISPLAY (f),
XtWindow (f->output_data.x->widget),
DefaultScreen (FRAME_X_DISPLAY (f)));
UNBLOCK_INPUT;
if (!result)
error ("Can't notify window manager of iconification");
f->async_iconified = 1;
f->async_visible = 0;
BLOCK_INPUT;
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
#else
if (! FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P (f))
x_set_offset (f, f->left_pos, f->top_pos, 0);
{
XEvent message;
message.xclient.window = FRAME_X_WINDOW (f);
message.xclient.type = ClientMessage;
message.xclient.message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_change_state;
message.xclient.format = 32;
message.xclient.data.l[0] = IconicState;
if (! XSendEvent (FRAME_X_DISPLAY (f),
DefaultRootWindow (FRAME_X_DISPLAY (f)),
False,
SubstructureRedirectMask | SubstructureNotifyMask,
&message))
{
UNBLOCK_INPUT_RESIGNAL;
error ("Can't notify window manager of iconification");
}
}
x_wm_set_window_state (f, IconicState);
if (!FRAME_VISIBLE_P (f))
{
XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
}
f->async_iconified = 1;
f->async_visible = 0;
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
#endif
}
void
x_free_frame_resources (f)
struct frame *f;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Lisp_Object bar;
struct scroll_bar *b;
BLOCK_INPUT;
if (dpyinfo->display)
{
if (f->output_data.x->icon_desc)
XDestroyWindow (FRAME_X_DISPLAY (f), f->output_data.x->icon_desc);
#ifdef USE_X_TOOLKIT
for (bar = FRAME_SCROLL_BARS (f); !NILP (bar); bar = b->next)
{
b = XSCROLL_BAR (bar);
x_scroll_bar_remove (b);
}
#endif
#ifdef HAVE_X_I18N
if (FRAME_XIC (f))
free_frame_xic (f);
#endif
#ifdef USE_X_TOOLKIT
if (f->output_data.x->widget)
{
XtDestroyWidget (f->output_data.x->widget);
f->output_data.x->widget = NULL;
}
else if (FRAME_X_WINDOW (f))
XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
free_frame_menubar (f);
#else
#ifdef USE_GTK
if (FRAME_GTK_OUTER_WIDGET (f))
{
gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f));
FRAME_X_WINDOW (f) = 0;
FRAME_GTK_OUTER_WIDGET (f) = 0;
}
#endif
if (FRAME_X_WINDOW (f))
XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
unload_color (f, f->output_data.x->foreground_pixel);
unload_color (f, f->output_data.x->background_pixel);
unload_color (f, f->output_data.x->cursor_pixel);
unload_color (f, f->output_data.x->cursor_foreground_pixel);
unload_color (f, f->output_data.x->border_pixel);
unload_color (f, f->output_data.x->mouse_pixel);
if (f->output_data.x->scroll_bar_background_pixel != -1)
unload_color (f, f->output_data.x->scroll_bar_background_pixel);
if (f->output_data.x->scroll_bar_foreground_pixel != -1)
unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
#ifdef USE_TOOLKIT_SCROLL_BARS
if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
#endif
if (f->output_data.x->white_relief.allocated_p)
unload_color (f, f->output_data.x->white_relief.pixel);
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);
f->output_data.x = NULL;
if (f == dpyinfo->x_focus_frame)
dpyinfo->x_focus_frame = 0;
if (f == dpyinfo->x_focus_event_frame)
dpyinfo->x_focus_event_frame = 0;
if (f == dpyinfo->x_highlight_frame)
dpyinfo->x_highlight_frame = 0;
if (f == dpyinfo->mouse_face_mouse_frame)
{
dpyinfo->mouse_face_beg_row
= dpyinfo->mouse_face_beg_col = -1;
dpyinfo->mouse_face_end_row
= dpyinfo->mouse_face_end_col = -1;
dpyinfo->mouse_face_window = Qnil;
dpyinfo->mouse_face_deferred_gc = 0;
dpyinfo->mouse_face_mouse_frame = 0;
}
UNBLOCK_INPUT;
}
void
x_destroy_window (f)
struct frame *f;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (dpyinfo->display != 0)
x_free_frame_resources (f);
dpyinfo->reference_count--;
}
#ifndef USE_GTK
void
x_wm_set_size_hint (f, flags, user_position)
struct frame *f;
long flags;
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);
size_hints.flags = PResizeInc | PMinSize ;
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
size_hints.height = FRAME_PIXEL_HEIGHT (f);
size_hints.width = FRAME_PIXEL_WIDTH (f);
#endif
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);
#ifndef USE_X_TOOLKIT
{
int base_width, base_height;
int min_rows = 0, min_cols = 0;
base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0);
check_frame_size (f, &min_rows, &min_cols);
#ifdef HAVE_X11R4
size_hints.flags |= PBaseSize;
size_hints.base_width = base_width;
size_hints.base_height = base_height;
size_hints.min_width = base_width + min_cols * size_hints.width_inc;
size_hints.min_height = base_height + min_rows * size_hints.height_inc;
#else
size_hints.min_width = base_width;
size_hints.min_height = base_height;
#endif
}
if (flags)
{
size_hints.flags |= flags;
goto no_read;
}
#endif
{
XSizeHints hints;
long supplied_return;
int value;
#ifdef HAVE_X11R4
value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
&supplied_return);
#else
value = XGetNormalHints (FRAME_X_DISPLAY (f), window, &hints);
#endif
#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
{
if (value == 0)
hints.flags = 0;
if (hints.flags & PSize)
size_hints.flags |= PSize;
if (hints.flags & PPosition)
size_hints.flags |= PPosition;
if (hints.flags & USPosition)
size_hints.flags |= USPosition;
if (hints.flags & USSize)
size_hints.flags |= USSize;
}
}
#ifndef USE_X_TOOLKIT
no_read:
#endif
#ifdef PWinGravity
size_hints.win_gravity = f->win_gravity;
size_hints.flags |= PWinGravity;
if (user_position)
{
size_hints.flags &= ~ PPosition;
size_hints.flags |= USPosition;
}
#endif
#ifdef HAVE_X11R4
XSetWMNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
#else
XSetNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
#endif
}
#endif
void
x_wm_set_window_state (f, state)
struct frame *f;
int state;
{
#ifdef USE_X_TOOLKIT
Arg al[1];
XtSetArg (al[0], XtNinitialState, state);
XtSetValues (f->output_data.x->widget, al, 1);
#else
Window window = FRAME_X_WINDOW (f);
f->output_data.x->wm_hints.flags |= StateHint;
f->output_data.x->wm_hints.initial_state = state;
XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
#endif
}
void
x_wm_set_icon_pixmap (f, pixmap_id)
struct frame *f;
int pixmap_id;
{
Pixmap icon_pixmap, icon_mask;
#ifndef USE_X_TOOLKIT
Window window = FRAME_OUTER_WINDOW (f);
#endif
if (pixmap_id > 0)
{
icon_pixmap = x_bitmap_pixmap (f, pixmap_id);
f->output_data.x->wm_hints.icon_pixmap = icon_pixmap;
icon_mask = x_bitmap_mask (f, pixmap_id);
f->output_data.x->wm_hints.icon_mask = icon_mask;
}
else
{
#if 0
f->output_data.x->wm_hints.icon_pixmap = None;
f->output_data.x->wm_hints.icon_mask = None;
#else
return;
#endif
}
#ifdef USE_GTK
{
xg_set_frame_icon (f, icon_pixmap, icon_mask);
return;
}
#elif defined (USE_X_TOOLKIT)
{
Arg al[1];
XtSetArg (al[0], XtNiconPixmap, icon_pixmap);
XtSetValues (f->output_data.x->widget, al, 1);
XtSetArg (al[0], XtNiconMask, icon_mask);
XtSetValues (f->output_data.x->widget, al, 1);
}
#else
f->output_data.x->wm_hints.flags |= (IconPixmapHint | IconMaskHint);
XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
#endif
}
void
x_wm_set_icon_position (f, icon_x, icon_y)
struct frame *f;
int icon_x, icon_y;
{
Window window = FRAME_OUTER_WINDOW (f);
f->output_data.x->wm_hints.flags |= IconPositionHint;
f->output_data.x->wm_hints.icon_x = icon_x;
f->output_data.x->wm_hints.icon_y = icon_y;
XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
}
struct font_info *
x_get_font_info (f, font_idx)
FRAME_PTR f;
int font_idx;
{
return (FRAME_X_FONT_TABLE (f) + font_idx);
}
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)
try_XLoadQueryFont = 1;
for (; CONSP (patterns); patterns = XCDR (patterns))
{
int num_fonts;
char **names = NULL;
pattern = XCAR (patterns);
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);
goto label_cached;
}
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))
{
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 (len == 0)
try_XLoadQueryFont = 0;
else
{
num_fonts = 1;
names = (char **) alloca (sizeof (char *));
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)
{
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))
{
names = NULL;
x_clear_errors (dpy);
}
}
x_uncatch_errors ();
UNBLOCK_INPUT;
if (names)
{
int i;
for (i = 0; i < num_fonts; i++)
{
int width = 0;
char *p = names[i];
int average_width = -1, resx = 0, dashes = 0;
while (*p)
if (*p++ == '-')
{
dashes++;
if (dashes == 7)
width = atoi (p);
else if (dashes == 9)
resx = atoi (p);
else if (dashes == 12)
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))
list = Fcons (Fcons (tem, make_number (width)), list);
else
list = Fcons (Fcons (tem, Qnil), list);
}
}
}
if (!try_XLoadQueryFont)
{
BLOCK_INPUT;
XFreeFontNames (names);
UNBLOCK_INPUT;
}
}
XSETCDR (dpyinfo->name_list_element,
Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element)));
label_cached:
if (NILP (list)) continue;
newlist = second_best = Qnil;
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)))
{
XFontStruct *thisinfo;
BLOCK_INPUT;
x_catch_errors (dpy);
thisinfo = XLoadQueryFont (dpy,
SDATA (XCAR (tem)));
if (x_had_errors_p (dpy))
{
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
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
static void
x_check_font (f, font)
struct frame *f;
XFontStruct *font;
{
int i;
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
xassert (font != NULL);
for (i = 0; i < dpyinfo->n_fonts; i++)
if (dpyinfo->font_table[i].name
&& font == dpyinfo->font_table[i].font)
break;
xassert (i < dpyinfo->n_fonts);
}
#endif
static INLINE void
x_font_min_bounds (font, w, h)
XFontStruct *font;
int *w, *h;
{
*h = FONT_HEIGHT (font);
*w = font->min_bounds.width;
if (*w <= 0)
*w = font->max_bounds.width;
}
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);
}
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;
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);
}
{
char *full_name;
XFontStruct *font;
struct font_info *fontp;
unsigned long value;
int i;
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)))
{
font = NULL;
x_clear_errors (FRAME_X_DISPLAY (f));
}
x_uncatch_errors ();
UNBLOCK_INPUT;
if (!font)
return NULL;
for (i = 0; i < dpyinfo->n_fonts; ++i)
if (dpyinfo->font_table[i].name == NULL)
break;
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;
BLOCK_INPUT;
bzero (fontp, sizeof (*fontp));
fontp->font = font;
fontp->font_idx = i;
fontp->name = (char *) xmalloc (strlen (fontname) + 1);
bcopy (fontname, fontp->name, strlen (fontname) + 1);
if (font->min_bounds.width == font->max_bounds.width)
{
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);
}
}
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;
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))
{
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)));
}
}
fontp->encoding[1]
= (font->max_byte1 == 0
? (font->min_char_or_byte2 < 0x80
? (font->max_char_or_byte2 < 0x80
? 0
: FONT_ENCODING_NOT_DECIDED)
: 1)
: (font->min_byte1 < 0x80
? (font->max_byte1 < 0x80
? (font->min_char_or_byte2 < 0x80
? (font->max_char_or_byte2 < 0x80
? 0
: FONT_ENCODING_NOT_DECIDED)
: 3)
: FONT_ENCODING_NOT_DECIDED)
: (font->min_char_or_byte2 < 0x80
? (font->max_char_or_byte2 < 0x80
? 2
: FONT_ENCODING_NOT_DECIDED)
: 1)));
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);
fonts_changed_p |= x_compute_min_glyph_bounds (f);
UNBLOCK_INPUT;
return fontp;
}
}
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;
}
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;
}
}
#ifdef USE_X_TOOLKIT
static XrmOptionDescRec emacs_options[] = {
{"-geometry", ".geometry", XrmoptionSepArg, NULL},
{"-iconic", ".iconic", XrmoptionNoArg, (XtPointer) "yes"},
{"-internal-border-width", "*EmacsScreen.internalBorderWidth",
XrmoptionSepArg, NULL},
{"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg, NULL},
{"-T", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
{"-wn", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
{"-title", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
{"-iconname", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
{"-in", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
{"-mc", "*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
{"-cr", "*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
};
static int x_timeout_atimer_activated_flag;
#endif
static int x_initialized;
#ifdef HAVE_X_SM
static int x_session_initialized;
#endif
#ifdef MULTI_KBOARD
static int
same_x_server (name1, name2)
const char *name1, *name2;
{
int seen_colon = 0;
const unsigned char *system_name = SDATA (Vsystem_name);
int system_name_length = strlen (system_name);
int length_until_period = 0;
while (system_name[length_until_period] != 0
&& system_name[length_until_period] != '.')
length_until_period++;
if (! strncmp (name1, "unix:", 5))
name1 += 4;
if (! strncmp (name2, "unix:", 5))
name2 += 4;
if (! strncmp (name1, system_name, system_name_length)
&& name1[system_name_length] == ':')
name1 += system_name_length;
if (! strncmp (name2, system_name, system_name_length)
&& name2[system_name_length] == ':')
name2 += system_name_length;
if (! strncmp (name1, system_name, length_until_period)
&& name1[length_until_period] == ':')
name1 += length_until_period;
if (! strncmp (name2, system_name, length_until_period)
&& name2[length_until_period] == ':')
name2 += length_until_period;
for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
{
if (*name1 == ':')
seen_colon++;
if (seen_colon && *name1 == '.')
return 1;
}
return (seen_colon
&& (*name1 == '.' || *name1 == '\0')
&& (*name2 == '.' || *name2 == '\0'));
}
#endif
static void
get_bits_and_offset (mask, bits, offset)
unsigned long mask;
int *bits;
int *offset;
{
int nr = 0;
int off = 0;
while (!(mask & 1))
{
off++;
mask >>= 1;
}
while (mask & 1)
{
nr++;
mask >>= 1;
}
*offset = off;
*bits = nr;
}
int
x_display_ok (display)
const char * display;
{
int dpy_ok = 1;
Display *dpy;
dpy = XOpenDisplay (display);
if (dpy)
XCloseDisplay (dpy);
else
dpy_ok = 0;
return dpy_ok;
}
struct x_display_info *
x_term_init (display_name, xrm_option, resource_name)
Lisp_Object display_name;
char *xrm_option;
char *resource_name;
{
int connection;
Display *dpy;
struct x_display_info *dpyinfo;
XrmDatabase xrdb;
BLOCK_INPUT;
if (!x_initialized)
{
x_initialize ();
++x_initialized;
}
#ifdef USE_GTK
{
#define NUM_ARGV 10
int argc;
char *argv[NUM_ARGV];
char **argv2 = argv;
GdkAtom atom;
if (x_initialized++ > 1)
{
if (xg_display_open (SDATA (display_name), &dpy) < 0)
error ("Sorry, this version of GTK can only handle one display");
}
else
{
for (argc = 0; argc < NUM_ARGV; ++argc)
argv[argc] = 0;
argc = 0;
argv[argc++] = initial_argv[0];
if (! NILP (display_name))
{
argv[argc++] = "--display";
argv[argc++] = SDATA (display_name);
}
argv[argc++] = "--name";
argv[argc++] = resource_name;
#ifdef HAVE_X11R5
XSetLocaleModifiers ("");
#endif
gtk_init (&argc, &argv2);
fixup_locale ();
xg_initialize ();
dpy = GDK_DISPLAY ();
gdk_window_add_filter (NULL, event_handler_gdk, NULL);
{
char *file = "~/.emacs.d/gtkrc";
Lisp_Object s, abs_file;
s = make_string (file, strlen (file));
abs_file = Fexpand_file_name (s, Qnil);
if (! NILP (abs_file) && !NILP (Ffile_readable_p (abs_file)))
gtk_rc_parse (SDATA (abs_file));
}
XSetErrorHandler (x_error_handler);
XSetIOErrorHandler (x_io_error_quitter);
}
}
#else
#ifdef USE_X_TOOLKIT
#ifdef HAVE_X11XTR6
XtSetLanguageProc (NULL, NULL, NULL);
#endif
{
int argc = 0;
char *argv[3];
argv[0] = "";
argc = 1;
if (xrm_option)
{
argv[argc++] = "-xrm";
argv[argc++] = xrm_option;
}
turn_on_atimers (0);
dpy = XtOpenDisplay (Xt_app_con, SDATA (display_name),
resource_name, EMACS_CLASS,
emacs_options, XtNumber (emacs_options),
&argc, argv);
turn_on_atimers (1);
#ifdef HAVE_X11XTR6
fixup_locale ();
#endif
}
#else
#ifdef HAVE_X11R5
XSetLocaleModifiers ("");
#endif
dpy = XOpenDisplay (SDATA (display_name));
#endif
#endif
if (dpy == 0)
{
UNBLOCK_INPUT;
return 0;
}
dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
bzero (dpyinfo, sizeof *dpyinfo);
#ifdef MULTI_KBOARD
{
struct x_display_info *share;
Lisp_Object tail;
for (share = x_display_list, tail = x_display_name_list; share;
share = share->next, tail = XCDR (tail))
if (same_x_server (SDATA (XCAR (XCAR (tail))),
SDATA (display_name)))
break;
if (share)
dpyinfo->kboard = share->kboard;
else
{
dpyinfo->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
init_kboard (dpyinfo->kboard);
if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
{
char *vendor = ServerVendor (dpy);
UNBLOCK_INPUT;
dpyinfo->kboard->Vsystem_key_alist
= call1 (Qvendor_specific_keysyms,
build_string (vendor ? vendor : ""));
BLOCK_INPUT;
}
dpyinfo->kboard->next_kboard = all_kboards;
all_kboards = dpyinfo->kboard;
if (current_kboard == initial_kboard)
current_kboard = dpyinfo->kboard;
}
dpyinfo->kboard->reference_count++;
}
#endif
dpyinfo->next = x_display_list;
x_display_list = dpyinfo;
x_display_name_list = Fcons (Fcons (display_name, Qnil),
x_display_name_list);
dpyinfo->name_list_element = XCAR (x_display_name_list);
dpyinfo->display = dpy;
#if 0
XSetAfterFunction (x_current_display, x_trace_wire);
#endif
dpyinfo->x_id_name
= (char *) xmalloc (SBYTES (Vinvocation_name)
+ SBYTES (Vsystem_name)
+ 2);
sprintf (dpyinfo->x_id_name, "%s@%s",
SDATA (Vinvocation_name), SDATA (Vsystem_name));
x_find_modifier_meanings (dpyinfo);
#ifdef USE_GTK
dpyinfo->xg_cursor = xg_create_default_cursor (dpyinfo->display);
#endif
dpyinfo->vertical_scroll_bar_cursor
= XCreateFontCursor (dpyinfo->display, XC_sb_v_double_arrow);
xrdb = x_load_resources (dpyinfo->display, xrm_option,
resource_name, EMACS_CLASS);
#ifdef HAVE_XRMSETDATABASE
XrmSetDatabase (dpyinfo->display, xrdb);
#else
dpyinfo->display->db = xrdb;
#endif
dpyinfo->xrdb = xrdb;
dpyinfo->screen = ScreenOfDisplay (dpyinfo->display,
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;
dpyinfo->bitmaps = 0;
dpyinfo->bitmaps_size = 0;
dpyinfo->bitmaps_last = 0;
dpyinfo->scratch_cursor_gc = 0;
dpyinfo->mouse_face_mouse_frame = 0;
dpyinfo->mouse_face_deferred_gc = 0;
dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
dpyinfo->mouse_face_window = Qnil;
dpyinfo->mouse_face_overlay = Qnil;
dpyinfo->mouse_face_mouse_x = dpyinfo->mouse_face_mouse_y = 0;
dpyinfo->mouse_face_defer = 0;
dpyinfo->mouse_face_hidden = 0;
dpyinfo->x_focus_frame = 0;
dpyinfo->x_focus_event_frame = 0;
dpyinfo->x_highlight_frame = 0;
dpyinfo->image_cache = make_image_cache ();
dpyinfo->wm_type = X_WMTYPE_UNKNOWN;
dpyinfo->red_bits = dpyinfo->blue_bits = dpyinfo->green_bits = 0;
dpyinfo->red_offset = dpyinfo->blue_offset = dpyinfo->green_offset = 0;
if (dpyinfo->visual->class == TrueColor)
{
get_bits_and_offset (dpyinfo->visual->red_mask,
&dpyinfo->red_bits, &dpyinfo->red_offset);
get_bits_and_offset (dpyinfo->visual->blue_mask,
&dpyinfo->blue_bits, &dpyinfo->blue_offset);
get_bits_and_offset (dpyinfo->visual->green_mask,
&dpyinfo->green_bits, &dpyinfo->green_offset);
}
if (dpyinfo->visual == DefaultVisualOfScreen (dpyinfo->screen))
{
if (dpyinfo->visual->class == PseudoColor)
{
Lisp_Object value;
value = display_x_get_resource (dpyinfo,
build_string ("privateColormap"),
build_string ("PrivateColormap"),
Qnil, Qnil);
if (STRINGP (value)
&& (!strcmp (SDATA (value), "true")
|| !strcmp (SDATA (value), "on")))
dpyinfo->cmap = XCopyColormapAndFree (dpyinfo->display, dpyinfo->cmap);
}
}
else
dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
dpyinfo->visual, AllocNone);
{
int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
double pixels = DisplayHeight (dpyinfo->display, screen_number);
double mm = DisplayHeightMM (dpyinfo->display, screen_number);
dpyinfo->resy = (mm < 1) ? 100 : pixels * 25.4 / mm;
pixels = DisplayWidth (dpyinfo->display, screen_number);
mm = DisplayWidthMM (dpyinfo->display, screen_number);
dpyinfo->resx = (mm < 1) ? 100 : pixels * 25.4 / mm;
}
dpyinfo->Xatom_wm_protocols
= XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
dpyinfo->Xatom_wm_take_focus
= XInternAtom (dpyinfo->display, "WM_TAKE_FOCUS", False);
dpyinfo->Xatom_wm_save_yourself
= XInternAtom (dpyinfo->display, "WM_SAVE_YOURSELF", False);
dpyinfo->Xatom_wm_delete_window
= XInternAtom (dpyinfo->display, "WM_DELETE_WINDOW", False);
dpyinfo->Xatom_wm_change_state
= XInternAtom (dpyinfo->display, "WM_CHANGE_STATE", False);
dpyinfo->Xatom_wm_configure_denied
= XInternAtom (dpyinfo->display, "WM_CONFIGURE_DENIED", False);
dpyinfo->Xatom_wm_window_moved
= XInternAtom (dpyinfo->display, "WM_MOVED", False);
dpyinfo->Xatom_wm_client_leader
= XInternAtom (dpyinfo->display, "WM_CLIENT_LEADER", False);
dpyinfo->Xatom_editres
= XInternAtom (dpyinfo->display, "Editres", False);
dpyinfo->Xatom_CLIPBOARD
= XInternAtom (dpyinfo->display, "CLIPBOARD", False);
dpyinfo->Xatom_TIMESTAMP
= XInternAtom (dpyinfo->display, "TIMESTAMP", False);
dpyinfo->Xatom_TEXT
= XInternAtom (dpyinfo->display, "TEXT", False);
dpyinfo->Xatom_COMPOUND_TEXT
= XInternAtom (dpyinfo->display, "COMPOUND_TEXT", False);
dpyinfo->Xatom_UTF8_STRING
= XInternAtom (dpyinfo->display, "UTF8_STRING", False);
dpyinfo->Xatom_DELETE
= XInternAtom (dpyinfo->display, "DELETE", False);
dpyinfo->Xatom_MULTIPLE
= XInternAtom (dpyinfo->display, "MULTIPLE", False);
dpyinfo->Xatom_INCR
= XInternAtom (dpyinfo->display, "INCR", False);
dpyinfo->Xatom_EMACS_TMP
= XInternAtom (dpyinfo->display, "_EMACS_TMP_", False);
dpyinfo->Xatom_TARGETS
= XInternAtom (dpyinfo->display, "TARGETS", False);
dpyinfo->Xatom_NULL
= XInternAtom (dpyinfo->display, "NULL", False);
dpyinfo->Xatom_ATOM_PAIR
= XInternAtom (dpyinfo->display, "ATOM_PAIR", False);
dpyinfo->Xatom_PIXEL_SIZE
= XInternAtom (dpyinfo->display, "PIXEL_SIZE", False);
dpyinfo->Xatom_AVERAGE_WIDTH
= XInternAtom (dpyinfo->display, "AVERAGE_WIDTH", False);
dpyinfo->Xatom_MULE_BASELINE_OFFSET
= XInternAtom (dpyinfo->display, "_MULE_BASELINE_OFFSET", False);
dpyinfo->Xatom_MULE_RELATIVE_COMPOSE
= XInternAtom (dpyinfo->display, "_MULE_RELATIVE_COMPOSE", False);
dpyinfo->Xatom_MULE_DEFAULT_ASCENT
= XInternAtom (dpyinfo->display, "_MULE_DEFAULT_ASCENT", False);
dpyinfo->Xatom_PAGE = XInternAtom (dpyinfo->display, "PAGE", False);
dpyinfo->Xatom_DONE = XInternAtom (dpyinfo->display, "DONE", False);
dpyinfo->Xatom_Scrollbar = XInternAtom (dpyinfo->display, "SCROLLBAR",
False);
dpyinfo->cut_buffers_initialized = 0;
dpyinfo->x_dnd_atoms_size = 8;
dpyinfo->x_dnd_atoms_length = 0;
dpyinfo->x_dnd_atoms = xmalloc (sizeof (*dpyinfo->x_dnd_atoms)
* dpyinfo->x_dnd_atoms_size);
dpyinfo->net_supported_atoms = NULL;
dpyinfo->nr_net_supported_atoms = 0;
dpyinfo->net_supported_window = 0;
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;
dpyinfo->gray
= XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
gray_bitmap_bits,
gray_bitmap_width, gray_bitmap_height,
(unsigned long) 1, (unsigned long) 0, 1);
}
#ifdef HAVE_X_I18N
xim_initialize (dpyinfo, resource_name);
#endif
#ifdef subprocesses
if (connection != 0)
add_keyboard_wait_descriptor (connection);
#endif
#ifndef F_SETOWN_BUG
#ifdef F_SETOWN
#ifdef F_SETOWN_SOCK_NEG
fcntl (connection, F_SETOWN, -getpid ());
#else
fcntl (connection, F_SETOWN, getpid ());
#endif
#endif
#endif
#ifdef SIGIO
if (interrupt_input)
init_sigio (connection);
#endif
#ifdef USE_LUCID
#ifdef HAVE_X11R5
{
Display *dpy = dpyinfo->display;
XrmValue d, fr, to;
Font font;
d.addr = (XPointer)&dpy;
d.size = sizeof (Display *);
fr.addr = XtDefaultFont;
fr.size = sizeof (XtDefaultFont);
to.size = sizeof (Font *);
to.addr = (XPointer)&font;
x_catch_errors (dpy);
if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
abort ();
if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
x_uncatch_errors ();
}
#endif
#endif
{
Lisp_Object value;
value = display_x_get_resource (dpyinfo,
build_string ("synchronous"),
build_string ("Synchronous"),
Qnil, Qnil);
if (STRINGP (value)
&& (!strcmp (SDATA (value), "true")
|| !strcmp (SDATA (value), "on")))
XSynchronize (dpyinfo->display, True);
}
{
Lisp_Object value;
value = display_x_get_resource (dpyinfo,
build_string ("useXIM"),
build_string ("UseXIM"),
Qnil, Qnil);
#ifdef USE_XIM
if (STRINGP (value)
&& (!strcmp (XSTRING (value)->data, "false")
|| !strcmp (XSTRING (value)->data, "off")))
use_xim = 0;
#else
if (STRINGP (value)
&& (!strcmp (XSTRING (value)->data, "true")
|| !strcmp (XSTRING (value)->data, "on")))
use_xim = 1;
#endif
}
#ifdef HAVE_X_SM
if (!x_session_initialized++)
x_session_initialize (dpyinfo);
#endif
UNBLOCK_INPUT;
return dpyinfo;
}
void
x_delete_display (dpyinfo)
struct x_display_info *dpyinfo;
{
int i;
delete_keyboard_wait_descriptor (dpyinfo->connection);
if (! NILP (x_display_name_list)
&& EQ (XCAR (x_display_name_list), dpyinfo->name_list_element))
x_display_name_list = XCDR (x_display_name_list);
else
{
Lisp_Object tail;
tail = x_display_name_list;
while (CONSP (tail) && CONSP (XCDR (tail)))
{
if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
{
XSETCDR (tail, XCDR (XCDR (tail)));
break;
}
tail = XCDR (tail);
}
}
if (next_noop_dpyinfo == dpyinfo)
next_noop_dpyinfo = dpyinfo->next;
if (x_display_list == dpyinfo)
x_display_list = dpyinfo->next;
else
{
struct x_display_info *tail;
for (tail = x_display_list; tail; tail = tail->next)
if (tail->next == dpyinfo)
tail->next = tail->next->next;
}
#ifndef USE_X_TOOLKIT
#ifndef AIX
XrmDestroyDatabase (dpyinfo->xrdb);
#endif
#endif
#ifdef MULTI_KBOARD
if (--dpyinfo->kboard->reference_count == 0)
delete_kboard (dpyinfo->kboard);
#endif
#ifdef HAVE_X_I18N
if (dpyinfo->xim)
xim_close_dpy (dpyinfo);
#endif
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);
}
if (dpyinfo->x_id_name)
xfree (dpyinfo->x_id_name);
if (dpyinfo->color_cells)
xfree (dpyinfo->color_cells);
xfree (dpyinfo);
}
#ifdef USE_X_TOOLKIT
static void
x_process_timeouts (timer)
struct atimer *timer;
{
BLOCK_INPUT;
x_timeout_atimer_activated_flag = 0;
if (toolkit_scroll_bar_interaction || popup_activated ())
{
while (XtAppPending (Xt_app_con) & XtIMTimer)
XtAppProcessEvent (Xt_app_con, XtIMTimer);
x_activate_timeout_atimer ();
}
UNBLOCK_INPUT;
}
void
x_activate_timeout_atimer ()
{
BLOCK_INPUT;
if (!x_timeout_atimer_activated_flag)
{
EMACS_TIME interval;
EMACS_SET_SECS_USECS (interval, 0, 100000);
start_atimer (ATIMER_RELATIVE, interval, x_process_timeouts, 0);
x_timeout_atimer_activated_flag = 1;
}
UNBLOCK_INPUT;
}
#endif
extern frame_parm_handler x_frame_parm_handlers[];
static struct redisplay_interface x_redisplay_interface =
{
x_frame_parm_handlers,
x_produce_glyphs,
x_write_glyphs,
x_insert_glyphs,
x_clear_end_of_line,
x_scroll_run,
x_after_update_window_line,
x_update_window_begin,
x_update_window_end,
x_cursor_to,
x_flush,
#ifdef XFlush
x_flush,
#else
0,
#endif
x_clear_window_mouse_face,
x_get_glyph_overhangs,
x_fix_overlapping_area,
x_draw_fringe_bitmap,
0,
0,
x_per_char_metric,
x_encode_char,
x_compute_glyph_string_overhangs,
x_draw_glyph_string,
x_define_frame_cursor,
x_clear_frame_area,
x_draw_window_cursor,
x_draw_vertical_window_border,
x_shift_glyphs_for_insert
};
void
x_initialize ()
{
rif = &x_redisplay_interface;
clear_frame_hook = x_clear_frame;
ins_del_lines_hook = x_ins_del_lines;
delete_glyphs_hook = x_delete_glyphs;
ring_bell_hook = XTring_bell;
reset_terminal_modes_hook = XTreset_terminal_modes;
set_terminal_modes_hook = XTset_terminal_modes;
update_begin_hook = x_update_begin;
update_end_hook = x_update_end;
set_terminal_window_hook = XTset_terminal_window;
read_socket_hook = XTread_socket;
frame_up_to_date_hook = XTframe_up_to_date;
mouse_position_hook = XTmouse_position;
frame_rehighlight_hook = XTframe_rehighlight;
frame_raise_lower_hook = XTframe_raise_lower;
set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
condemn_scroll_bars_hook = XTcondemn_scroll_bars;
redeem_scroll_bar_hook = XTredeem_scroll_bar;
judge_scroll_bars_hook = XTjudge_scroll_bars;
fullscreen_hook = XTfullscreen_hook;
scroll_region_ok = 1;
char_ins_del_ok = 1;
line_ins_del_ok = 1;
fast_clear_end_of_line = 1;
memory_below_frame = 0;
baud_rate = 19200;
x_noop_count = 0;
last_tool_bar_item = -1;
any_help_event_p = 0;
ignore_next_mouse_click_timeout = 0;
#ifdef HAVE_X_SM
x_session_initialized = 0;
#endif
#ifdef USE_GTK
current_count = -1;
#endif
Fset_input_mode (Qt, Qnil, Qt, Qnil);
#ifdef USE_X_TOOLKIT
XtToolkitInitialize ();
Xt_app_con = XtCreateApplicationContext ();
XtAppSetTypeConverter (Xt_app_con,
XtRString, XtRPixel, cvt_string_to_pixel,
cvt_string_to_pixel_args,
XtNumber (cvt_string_to_pixel_args),
XtCacheByDisplay, cvt_pixel_dtor);
XtAppSetFallbackResources (Xt_app_con, Xt_default_resources);
#endif
#ifdef USE_TOOLKIT_SCROLL_BARS
#ifndef USE_GTK
xaw3d_arrow_scroll = False;
xaw3d_pick_top = True;
#endif
#endif
XSetErrorHandler (x_error_handler);
XSetIOErrorHandler (x_io_error_quitter);
#ifdef SIGWINCH
signal (SIGWINCH, SIG_DFL);
#endif
signal (SIGPIPE, x_connection_signal);
}
void
syms_of_xterm ()
{
x_error_message = NULL;
staticpro (&x_display_name_list);
x_display_name_list = Qnil;
staticpro (&last_mouse_scroll_bar);
last_mouse_scroll_bar = Qnil;
staticpro (&Qvendor_specific_keysyms);
Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
staticpro (&Qutf_8);
Qutf_8 = intern ("utf-8");
staticpro (&Qlatin_1);
Qlatin_1 = intern ("latin-1");
staticpro (&last_mouse_press_frame);
last_mouse_press_frame = Qnil;
DEFVAR_BOOL ("x-use-underline-position-properties",
&x_use_underline_position_properties,
doc: );
x_use_underline_position_properties = 1;
DEFVAR_BOOL ("x-underline-at-descent-line",
&x_underline_at_descent_line,
doc: );
x_underline_at_descent_line = 0;
DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
&x_mouse_click_focus_ignore_position,
doc: );
x_mouse_click_focus_ignore_position = 0;
DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
doc: );
#ifdef USE_TOOLKIT_SCROLL_BARS
#ifdef USE_MOTIF
Vx_toolkit_scroll_bars = intern ("motif");
#elif defined HAVE_XAW3D
Vx_toolkit_scroll_bars = intern ("xaw3d");
#elif USE_GTK
Vx_toolkit_scroll_bars = intern ("gtk");
#else
Vx_toolkit_scroll_bars = intern ("xaw");
#endif
#else
Vx_toolkit_scroll_bars = Qnil;
#endif
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;
Qmodifier_value = intern ("modifier-value");
Qalt = intern ("alt");
Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
Qhyper = intern ("hyper");
Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
Qmeta = intern ("meta");
Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
Qsuper = intern ("super");
Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym,
doc: );
Vx_alt_keysym = Qnil;
DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym,
doc: );
Vx_hyper_keysym = Qnil;
DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym,
doc: );
Vx_meta_keysym = Qnil;
DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym,
doc: );
Vx_super_keysym = Qnil;
DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table,
doc: );
Vx_keysym_table = make_hash_table (Qeql, make_number (900),
make_float (DEFAULT_REHASH_SIZE),
make_float (DEFAULT_REHASH_THRESHOLD),
Qnil, Qnil, Qnil);
}
#endif