#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"
#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_X_TOOLKIT
extern void free_frame_menubar P_ ((struct frame *));
extern struct frame *x_menubar_window_to_frame P_ ((struct x_display_info *,
int));
#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>
#define ARROW_SCROLLBAR
#include <X11/Xaw3d/ScrollbarP.h>
#else
#include <X11/Xaw/Simple.h>
#include <X11/Xaw/Scrollbar.h>
#endif
#ifndef XtNpickTop
#define XtNpickTop "pickTop"
#endif
#endif
#endif
#endif
#ifndef USE_X_TOOLKIT
#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
#ifndef min
#define min(a,b) ((a) < (b) ? (a) : (b))
#endif
#ifndef max
#define max(a,b) ((a) > (b) ? (a) : (b))
#endif
#define abs(x) ((x) < 0 ? -(x) : (x))
#define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
enum bitmap_type
{
NO_BITMAP,
LEFT_TRUNCATION_BITMAP,
RIGHT_TRUNCATION_BITMAP,
OVERLAY_ARROW_BITMAP,
CONTINUED_LINE_BITMAP,
CONTINUATION_LINE_BITMAP,
ZV_LINE_BITMAP
};
#define zv_width 8
#define zv_height 8
static unsigned char zv_bits[] = {
0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
#define left_width 8
#define left_height 8
static unsigned char left_bits[] = {
0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
#define right_width 8
#define right_height 8
static unsigned char right_bits[] = {
0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
#define continued_width 8
#define continued_height 8
static unsigned char continued_bits[] = {
0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
#define continuation_width 8
#define continuation_height 8
static unsigned char continuation_bits[] = {
0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
#if 0
#define ov_width 8
#define ov_height 8
static unsigned char ov_bits[] = {
0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
#else
#define ov_width 8
#define ov_height 8
static unsigned char ov_bits[] = {
0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
#endif
extern Lisp_Object Qhelp_echo;
Lisp_Object Vx_toolkit_scroll_bars;
static Lisp_Object help_echo;
static Lisp_Object help_echo_window;
static Lisp_Object help_echo_object;
static int help_echo_pos;
static Lisp_Object previous_help_echo;
static int any_help_event_p;
int x_stretch_cursor_p;
int x_use_underline_position_properties;
struct x_display_info *x_display_list;
Lisp_Object x_display_name_list;
extern struct frame *updating_frame;
extern int waiting_for_input;
struct frame *pending_autoraise_frame;
#ifdef USE_X_TOOLKIT
XtAppContext Xt_app_con;
static String Xt_default_resources[] = {0};
#endif
struct cursor_pos output_cursor;
static int toolkit_scroll_bar_interaction;
FRAME_PTR last_mouse_frame;
static XRectangle last_mouse_glyph;
static Lisp_Object last_mouse_press_frame;
static Lisp_Object last_mouse_scroll_bar;
static Time last_mouse_movement_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 Qface, Qmouse_face;
extern int errno;
extern int extra_keyboard_modifiers;
static Lisp_Object Qvendor_specific_keysyms;
extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
extern Lisp_Object x_icon_type P_ ((struct frame *));
enum draw_glyphs_face
{
DRAW_NORMAL_TEXT,
DRAW_INVERSE_VIDEO,
DRAW_CURSOR,
DRAW_MOUSE_FACE,
DRAW_IMAGE_RAISED,
DRAW_IMAGE_SUNKEN
};
static int cursor_in_mouse_face_p P_ ((struct window *));
static int clear_mouse_face P_ ((struct x_display_info *));
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 void frame_to_window_pixel_xy P_ ((struct window *, int *, int *));
void x_delete_display P_ ((struct x_display_info *));
static unsigned int x_x_to_emacs_modifiers P_ ((struct x_display_info *,
unsigned));
static int fast_find_position P_ ((struct window *, int, int *, int *,
int *, int *, Lisp_Object));
static int fast_find_string_pos P_ ((struct window *, int, Lisp_Object,
int *, int *, int *, int *, int));
static void set_output_cursor P_ ((struct cursor_pos *));
static struct glyph *x_y_to_hpos_vpos P_ ((struct window *, int, int,
int *, int *, int *, int));
static void note_mode_line_highlight P_ ((struct window *, int, int));
static void note_mouse_highlight P_ ((struct frame *, int, int));
static void note_tool_bar_highlight P_ ((struct frame *f, int, int));
static void x_handle_tool_bar_click P_ ((struct frame *, XButtonEvent *));
static void show_mouse_face P_ ((struct x_display_info *,
enum draw_glyphs_face));
static int x_io_error_quitter P_ ((Display *));
int x_catch_errors P_ ((Display *));
void x_uncatch_errors P_ ((Display *, int));
void x_lower_frame P_ ((struct frame *));
void x_scroll_bar_clear P_ ((struct frame *));
int x_had_errors_p P_ ((Display *));
void x_wm_set_size_hint P_ ((struct frame *, long, int));
void x_raise_frame P_ ((struct frame *));
void x_set_window_size P_ ((struct frame *, int, int, int));
void x_wm_set_window_state P_ ((struct frame *, int));
void x_wm_set_icon_pixmap P_ ((struct frame *, int));
void x_initialize P_ ((void));
static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
static int x_compute_min_glyph_bounds P_ ((struct frame *));
static void x_draw_phys_cursor_glyph P_ ((struct window *,
struct glyph_row *,
enum draw_glyphs_face));
static void x_update_end P_ ((struct frame *));
static void XTframe_up_to_date P_ ((struct frame *));
static void XTreassert_line_highlight P_ ((int, int));
static void x_change_line_highlight P_ ((int, int, int, int));
static void XTset_terminal_modes P_ ((void));
static void XTreset_terminal_modes P_ ((void));
static void XTcursor_to P_ ((int, int, int, int));
static void x_write_glyphs P_ ((struct glyph *, int));
static void x_clear_end_of_line P_ ((int));
static void x_clear_frame P_ ((void));
static void x_clear_cursor P_ ((struct window *));
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 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));
static int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
XRectangle *));
static void expose_frame P_ ((struct frame *, int, int, int, int));
static int expose_window_tree P_ ((struct window *, XRectangle *));
static int expose_window P_ ((struct window *, XRectangle *));
static void expose_area P_ ((struct window *, struct glyph_row *,
XRectangle *, enum glyph_row_area));
static int expose_line P_ ((struct window *, struct glyph_row *,
XRectangle *));
static void x_update_cursor_in_window_tree P_ ((struct window *, int));
static void x_update_window_cursor P_ ((struct window *, int));
static void x_erase_phys_cursor P_ ((struct window *));
void x_display_and_set_cursor P_ ((struct window *, int, int, int, int, int));
static void x_draw_bitmap P_ ((struct window *, struct glyph_row *,
enum bitmap_type));
static void x_clip_to_row P_ ((struct window *, struct glyph_row *,
GC, int));
static int x_phys_cursor_in_rect_p P_ ((struct window *, XRectangle *));
static void x_draw_row_bitmaps P_ ((struct window *, struct glyph_row *));
static void notice_overwritten_cursor P_ ((struct window *, int, int));
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_draw_vertical_border P_ ((struct window *));
static void x_after_update_window_line P_ ((struct glyph_row *));
static INLINE void take_vertical_position_into_account P_ ((struct it *));
static void x_produce_stretch_glyph P_ ((struct it *));
static struct scroll_bar *x_window_to_scroll_bar P_ ((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_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_border (w)
struct window *w;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
if (!WINDOW_RIGHTMOST_P (w)
&& !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
{
int x0, x1, y0, y1;
window_box_edges (w, -1, &x0, &y0, &x1, &y1);
x1 += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f);
y1 -= 1;
XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc, x1, y0, x1, 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)
x_display_and_set_cursor (w, 1, output_cursor.hpos,
output_cursor.vpos,
output_cursor.x, output_cursor.y);
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;
BLOCK_INPUT;
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
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)
{
BLOCK_INPUT;
x_draw_row_bitmaps (w, desired_row);
UNBLOCK_INPUT;
}
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),
f->output_data.x->pixel_width - width,
y, width, height, False);
UNBLOCK_INPUT;
}
}
static void
x_draw_bitmap (w, row, which)
struct window *w;
struct glyph_row *row;
enum bitmap_type which;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
Display *display = FRAME_X_DISPLAY (f);
Window window = FRAME_X_WINDOW (f);
int x, y, wd, h, dy;
unsigned char *bits;
Pixmap pixmap;
GC gc = f->output_data.x->normal_gc;
struct face *face;
int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
x_clip_to_row (w, row, gc, 1);
switch (which)
{
case LEFT_TRUNCATION_BITMAP:
wd = left_width;
h = left_height;
bits = left_bits;
x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
- wd
- (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
break;
case OVERLAY_ARROW_BITMAP:
wd = left_width;
h = left_height;
bits = ov_bits;
x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
- wd
- (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
break;
case RIGHT_TRUNCATION_BITMAP:
wd = right_width;
h = right_height;
bits = right_bits;
x = window_box_right (w, -1);
x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
break;
case CONTINUED_LINE_BITMAP:
wd = right_width;
h = right_height;
bits = continued_bits;
x = window_box_right (w, -1);
x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
break;
case CONTINUATION_LINE_BITMAP:
wd = continuation_width;
h = continuation_height;
bits = continuation_bits;
x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
- wd
- (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
break;
case ZV_LINE_BITMAP:
wd = zv_width;
h = zv_height;
bits = zv_bits;
x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
- wd
- (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
break;
default:
abort ();
}
y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
dy = (row->height - h) / 2;
face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
pixmap = XCreatePixmapFromBitmapData (display, window, bits, wd, h,
face->foreground,
face->background, depth);
XCopyArea (display, pixmap, window, gc, 0, 0, wd, h, x, y + dy);
XFreePixmap (display, pixmap);
XSetClipMask (display, gc, None);
}
static void
x_draw_row_bitmaps (w, row)
struct window *w;
struct glyph_row *row;
{
struct frame *f = XFRAME (w->frame);
enum bitmap_type bitmap;
struct face *face;
int header_line_height = -1;
xassert (interrupt_input_blocked);
if (row->visible_height <= 0)
return;
face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
PREPARE_FACE_FOR_DISPLAY (f, face);
if (row->overlay_arrow_p)
bitmap = OVERLAY_ARROW_BITMAP;
else if (row->truncated_on_left_p)
bitmap = LEFT_TRUNCATION_BITMAP;
else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
bitmap = CONTINUATION_LINE_BITMAP;
else if (row->indicate_empty_line_p)
bitmap = ZV_LINE_BITMAP;
else
bitmap = NO_BITMAP;
if (bitmap == NO_BITMAP
|| FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
|| row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
{
int border = ((XFASTINT (w->left) > 0
&& !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
? 1 : 0);
int left = window_box_left (w, -1);
if (header_line_height < 0)
header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
if (face->stipple)
XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
else
XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
face->gc,
(left
- FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
+ border),
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
row->y)),
FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - border,
row->visible_height);
if (!face->stipple)
XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
}
if (bitmap != NO_BITMAP)
x_draw_bitmap (w, row, bitmap);
if (row->truncated_on_right_p)
bitmap = RIGHT_TRUNCATION_BITMAP;
else if (row->continued_p)
bitmap = CONTINUED_LINE_BITMAP;
else
bitmap = NO_BITMAP;
if (bitmap == NO_BITMAP
|| FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f)
|| row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
{
int right = window_box_right (w, -1);
if (header_line_height < 0)
header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
if (face->stipple)
XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
else
XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
face->gc,
right,
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
row->y)),
FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f),
row->visible_height);
if (!face->stipple)
XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
}
if (bitmap != NO_BITMAP)
x_draw_bitmap (w, row, bitmap);
}
static void
XTreassert_line_highlight (new, vpos)
int new, vpos;
{
abort ();
}
static void
x_change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
int new_highlight, vpos, y, first_unused_hpos;
{
abort ();
}
static void
XTset_terminal_modes ()
{
}
static void
XTreset_terminal_modes ()
{
}
static void
set_output_cursor (cursor)
struct cursor_pos *cursor;
{
output_cursor.hpos = cursor->hpos;
output_cursor.vpos = cursor->vpos;
output_cursor.x = cursor->x;
output_cursor.y = cursor->y;
}
static void
XTcursor_to (vpos, hpos, y, x)
int vpos, hpos, y, x;
{
struct window *w;
if (updated_window)
w = updated_window;
else
w = XWINDOW (selected_window);
output_cursor.hpos = hpos;
output_cursor.vpos = vpos;
output_cursor.x = x;
output_cursor.y = y;
if (updated_window == NULL)
{
BLOCK_INPUT;
x_display_cursor (w, 1, hpos, vpos, x, y);
XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
UNBLOCK_INPUT;
}
}
static struct face *x_get_glyph_face_and_encoding P_ ((struct frame *,
struct glyph *,
XChar2b *,
int *));
static struct face *x_get_char_face_and_encoding P_ ((struct frame *, int,
int, XChar2b *, int));
static XCharStruct *x_per_char_metric P_ ((XFontStruct *, XChar2b *));
static void x_encode_char P_ ((int, XChar2b *, struct font_info *));
static void x_append_glyph P_ ((struct it *));
static void x_append_composite_glyph P_ ((struct it *));
static void x_append_stretch_glyph P_ ((struct it *it, Lisp_Object,
int, int, double));
static void x_produce_glyphs P_ ((struct it *));
static void x_produce_image_glyph P_ ((struct it *it));
static INLINE XCharStruct *
x_per_char_metric (font, char2b)
XFontStruct *font;
XChar2b *char2b;
{
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 INLINE void
x_encode_char (c, char2b, font_info)
int c;
XChar2b *char2b;
struct font_info *font_info;
{
int charset = CHAR_CHARSET (c);
XFontStruct *font = font_info->font;
if (font_info->font_encoder)
{
struct ccl_program *ccl = font_info->font_encoder;
if (CHARSET_DIMENSION (charset) == 1)
{
ccl->reg[0] = charset;
ccl->reg[1] = char2b->byte2;
}
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;
}
}
static INLINE struct face *
x_get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p)
struct frame *f;
int c, face_id;
XChar2b *char2b;
int multibyte_p;
{
struct face *face = FACE_FROM_ID (f, face_id);
if (!multibyte_p)
{
char2b->byte1 = 0;
char2b->byte2 = c;
face_id = FACE_FOR_CHAR (f, face, c);
face = FACE_FROM_ID (f, face_id);
}
else if (c < 128 && face_id < BASIC_FACE_ID_SENTINEL)
{
char2b->byte1 = 0;
char2b->byte2 = c;
}
else
{
int c1, c2, charset;
SPLIT_CHAR (c, charset, c1, c2);
if (c2 > 0)
char2b->byte1 = c1, char2b->byte2 = c2;
else
char2b->byte1 = 0, char2b->byte2 = c1;
if (face->font != NULL)
{
struct font_info *font_info
= FONT_INFO_FROM_ID (f, face->font_info_id);
if (font_info)
x_encode_char (c, char2b, font_info);
}
}
xassert (face != NULL);
PREPARE_FACE_FOR_DISPLAY (f, face);
return face;
}
static INLINE struct face *
x_get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
struct frame *f;
struct glyph *glyph;
XChar2b *char2b;
int *two_byte_p;
{
struct face *face;
xassert (glyph->type == CHAR_GLYPH);
face = FACE_FROM_ID (f, glyph->face_id);
if (two_byte_p)
*two_byte_p = 0;
if (!glyph->multibyte_p)
{
char2b->byte1 = 0;
char2b->byte2 = glyph->u.ch;
}
else if (glyph->u.ch < 128
&& glyph->face_id < BASIC_FACE_ID_SENTINEL)
{
char2b->byte1 = 0;
char2b->byte2 = glyph->u.ch;
}
else
{
int c1, c2, charset;
SPLIT_CHAR (glyph->u.ch, charset, c1, c2);
if (c2 > 0)
char2b->byte1 = c1, char2b->byte2 = c2;
else
char2b->byte1 = 0, char2b->byte2 = c1;
if (charset != CHARSET_ASCII)
{
struct font_info *font_info
= FONT_INFO_FROM_ID (f, face->font_info_id);
if (font_info)
{
x_encode_char (glyph->u.ch, char2b, font_info);
if (two_byte_p)
*two_byte_p
= ((XFontStruct *) (font_info->font))->max_byte1 > 0;
}
}
}
xassert (face != NULL);
PREPARE_FACE_FOR_DISPLAY (f, face);
return face;
}
static INLINE void
x_append_glyph (it)
struct it *it;
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
xassert (it->glyph_row);
xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
glyph->pixel_width = it->pixel_width;
glyph->voffset = it->voffset;
glyph->type = CHAR_GLYPH;
glyph->multibyte_p = it->multibyte_p;
glyph->left_box_line_p = it->start_of_box_run_p;
glyph->right_box_line_p = it->end_of_box_run_p;
glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
|| it->phys_descent > it->descent);
glyph->padding_p = 0;
glyph->glyph_not_available_p = it->glyph_not_available_p;
glyph->face_id = it->face_id;
glyph->u.ch = it->char_to_display;
++it->glyph_row->used[area];
}
}
static INLINE void
x_append_composite_glyph (it)
struct it *it;
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
xassert (it->glyph_row);
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
glyph->pixel_width = it->pixel_width;
glyph->voffset = it->voffset;
glyph->type = COMPOSITE_GLYPH;
glyph->multibyte_p = it->multibyte_p;
glyph->left_box_line_p = it->start_of_box_run_p;
glyph->right_box_line_p = it->end_of_box_run_p;
glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
|| it->phys_descent > it->descent);
glyph->padding_p = 0;
glyph->glyph_not_available_p = 0;
glyph->face_id = it->face_id;
glyph->u.cmp_id = it->cmp_id;
++it->glyph_row->used[area];
}
}
static INLINE void
take_vertical_position_into_account (it)
struct it *it;
{
if (it->voffset)
{
if (it->voffset < 0)
it->ascent += abs (it->voffset);
else
it->descent += it->voffset;
}
}
static void
x_produce_image_glyph (it)
struct it *it;
{
struct image *img;
struct face *face;
xassert (it->what == IT_IMAGE);
face = FACE_FROM_ID (it->f, it->face_id);
img = IMAGE_FROM_ID (it->f, it->image_id);
xassert (img);
PREPARE_FACE_FOR_DISPLAY (it->f, face);
prepare_image_for_display (it->f, img);
it->ascent = it->phys_ascent = image_ascent (img, face);
it->descent = it->phys_descent = img->height + 2 * img->vmargin - it->ascent;
it->pixel_width = img->width + 2 * img->hmargin;
it->nglyphs = 1;
if (face->box != FACE_NO_BOX)
{
if (face->box_line_width > 0)
{
it->ascent += face->box_line_width;
it->descent += face->box_line_width;
}
if (it->start_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
if (it->end_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
}
take_vertical_position_into_account (it);
if (it->glyph_row)
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
glyph->pixel_width = it->pixel_width;
glyph->voffset = it->voffset;
glyph->type = IMAGE_GLYPH;
glyph->multibyte_p = it->multibyte_p;
glyph->left_box_line_p = it->start_of_box_run_p;
glyph->right_box_line_p = it->end_of_box_run_p;
glyph->overlaps_vertically_p = 0;
glyph->padding_p = 0;
glyph->glyph_not_available_p = 0;
glyph->face_id = it->face_id;
glyph->u.img_id = img->id;
++it->glyph_row->used[area];
}
}
}
static void
x_append_stretch_glyph (it, object, width, height, ascent)
struct it *it;
Lisp_Object object;
int width, height;
double ascent;
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
xassert (ascent >= 0 && ascent <= 1);
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
glyph->charpos = CHARPOS (it->position);
glyph->object = object;
glyph->pixel_width = width;
glyph->voffset = it->voffset;
glyph->type = STRETCH_GLYPH;
glyph->multibyte_p = it->multibyte_p;
glyph->left_box_line_p = it->start_of_box_run_p;
glyph->right_box_line_p = it->end_of_box_run_p;
glyph->overlaps_vertically_p = 0;
glyph->padding_p = 0;
glyph->glyph_not_available_p = 0;
glyph->face_id = it->face_id;
glyph->u.stretch.ascent = height * ascent;
glyph->u.stretch.height = height;
++it->glyph_row->used[area];
}
}
#define NUMVAL(X) \
((INTEGERP (X) || FLOATP (X)) \
? XFLOATINT (X) \
: - 1)
static void
x_produce_stretch_glyph (it)
struct it *it;
{
#if GLYPH_DEBUG
extern Lisp_Object Qspace;
#endif
extern Lisp_Object QCwidth, QCheight, QCascent;
extern Lisp_Object QCrelative_width, QCrelative_height;
extern Lisp_Object QCalign_to;
Lisp_Object prop, plist;
double width = 0, height = 0, ascent = 0;
struct face *face = FACE_FROM_ID (it->f, it->face_id);
XFontStruct *font = face->font ? face->font : FRAME_FONT (it->f);
PREPARE_FACE_FOR_DISPLAY (it->f, face);
xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
plist = XCDR (it->object);
if (prop = Fplist_get (plist, QCwidth),
NUMVAL (prop) > 0)
width = NUMVAL (prop) * CANON_X_UNIT (it->f);
else if (prop = Fplist_get (plist, QCrelative_width),
NUMVAL (prop) > 0)
{
struct it it2;
unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
it2 = *it;
if (it->multibyte_p)
{
int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
- IT_BYTEPOS (*it));
it2.c = STRING_CHAR_AND_LENGTH (p, maxlen, it2.len);
}
else
it2.c = *p, it2.len = 1;
it2.glyph_row = NULL;
it2.what = IT_CHARACTER;
x_produce_glyphs (&it2);
width = NUMVAL (prop) * it2.pixel_width;
}
else if (prop = Fplist_get (plist, QCalign_to),
NUMVAL (prop) > 0)
width = NUMVAL (prop) * CANON_X_UNIT (it->f) - it->current_x;
else
width = CANON_X_UNIT (it->f);
if (prop = Fplist_get (plist, QCheight),
NUMVAL (prop) > 0)
height = NUMVAL (prop) * CANON_Y_UNIT (it->f);
else if (prop = Fplist_get (plist, QCrelative_height),
NUMVAL (prop) > 0)
height = FONT_HEIGHT (font) * NUMVAL (prop);
else
height = FONT_HEIGHT (font);
if (prop = Fplist_get (plist, QCascent),
NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
ascent = NUMVAL (prop) / 100.0;
else
ascent = (double) font->ascent / FONT_HEIGHT (font);
if (width <= 0)
width = 1;
if (height <= 0)
height = 1;
if (it->glyph_row)
{
Lisp_Object object = it->stack[it->sp - 1].string;
if (!STRINGP (object))
object = it->w->buffer;
x_append_stretch_glyph (it, object, width, height, ascent);
}
it->pixel_width = width;
it->ascent = it->phys_ascent = height * ascent;
it->descent = it->phys_descent = height - it->ascent;
it->nglyphs = 1;
if (face->box != FACE_NO_BOX)
{
if (face->box_line_width > 0)
{
it->ascent += face->box_line_width;
it->descent += face->box_line_width;
}
if (it->start_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
if (it->end_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
}
take_vertical_position_into_account (it);
}
#define VCENTER_BASELINE_OFFSET(FONT, F) \
((FONT)->descent \
+ (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
+ (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
- ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
static void
x_produce_glyphs (it)
struct it *it;
{
it->glyph_not_available_p = 0;
if (it->what == IT_CHARACTER)
{
XChar2b char2b;
XFontStruct *font;
struct face *face = FACE_FROM_ID (it->f, it->face_id);
XCharStruct *pcm;
int font_not_found_p;
struct font_info *font_info;
int boff;
int saved_multibyte_p = it->multibyte_p;
it->char_to_display = it->c;
if (!ASCII_BYTE_P (it->c))
{
if (unibyte_display_via_language_environment
&& SINGLE_BYTE_CHAR_P (it->c)
&& (it->c >= 0240
|| !NILP (Vnonascii_translation_table)))
{
it->char_to_display = unibyte_char_to_multibyte (it->c);
it->multibyte_p = 1;
it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
face = FACE_FROM_ID (it->f, it->face_id);
}
else if (!SINGLE_BYTE_CHAR_P (it->c)
&& !it->multibyte_p)
{
it->multibyte_p = 1;
it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
face = FACE_FROM_ID (it->f, it->face_id);
}
}
x_get_char_face_and_encoding (it->f, it->char_to_display,
it->face_id, &char2b,
it->multibyte_p);
font = face->font;
font_not_found_p = font == NULL;
if (font_not_found_p)
{
font = FRAME_FONT (it->f);
boff = it->f->output_data.x->baseline_offset;
font_info = NULL;
}
else
{
font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
boff = font_info->baseline_offset;
if (font_info->vertical_centering)
boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
}
if (it->char_to_display >= ' '
&& (!it->multibyte_p || it->char_to_display < 128))
{
int stretched_p;
it->nglyphs = 1;
pcm = x_per_char_metric (font, &char2b);
it->ascent = font->ascent + boff;
it->descent = font->descent - boff;
if (pcm)
{
it->phys_ascent = pcm->ascent + boff;
it->phys_descent = pcm->descent - boff;
it->pixel_width = pcm->width;
}
else
{
it->glyph_not_available_p = 1;
it->phys_ascent = font->ascent + boff;
it->phys_descent = font->descent - boff;
it->pixel_width = FONT_WIDTH (font);
}
stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
if (stretched_p)
it->pixel_width *= XFLOATINT (it->space_width);
if (face->box != FACE_NO_BOX)
{
int thick = face->box_line_width;
if (thick > 0)
{
it->ascent += thick;
it->descent += thick;
}
else
thick = -thick;
if (it->start_of_box_run_p)
it->pixel_width += thick;
if (it->end_of_box_run_p)
it->pixel_width += thick;
}
if (face->overline_p)
it->ascent += 2;
take_vertical_position_into_account (it);
if (it->glyph_row)
{
if (stretched_p)
{
double ascent = (double) font->ascent / FONT_HEIGHT (font);
x_append_stretch_glyph (it, it->object, it->pixel_width,
it->ascent + it->descent, ascent);
}
else
x_append_glyph (it);
if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
it->glyph_row->contains_overlapping_glyphs_p = 1;
}
}
else if (it->char_to_display == '\n')
{
it->pixel_width = 0;
it->nglyphs = 0;
it->ascent = it->phys_ascent = font->ascent + boff;
it->descent = it->phys_descent = font->descent - boff;
if (face->box != FACE_NO_BOX
&& face->box_line_width > 0)
{
it->ascent += face->box_line_width;
it->descent += face->box_line_width;
}
}
else if (it->char_to_display == '\t')
{
int tab_width = it->tab_width * CANON_X_UNIT (it->f);
int x = it->current_x + it->continuation_lines_width;
int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
if (next_tab_x - x < CANON_X_UNIT (it->f))
next_tab_x += tab_width;
it->pixel_width = next_tab_x - x;
it->nglyphs = 1;
it->ascent = it->phys_ascent = font->ascent + boff;
it->descent = it->phys_descent = font->descent - boff;
if (it->glyph_row)
{
double ascent = (double) it->ascent / (it->ascent + it->descent);
x_append_stretch_glyph (it, it->object, it->pixel_width,
it->ascent + it->descent, ascent);
}
}
else
{
pcm = x_per_char_metric (font, &char2b);
if (font_not_found_p || !pcm)
{
int charset = CHAR_CHARSET (it->char_to_display);
it->glyph_not_available_p = 1;
it->pixel_width = (FONT_WIDTH (FRAME_FONT (it->f))
* CHARSET_WIDTH (charset));
it->phys_ascent = font->ascent + boff;
it->phys_descent = font->descent - boff;
}
else
{
it->pixel_width = pcm->width;
it->phys_ascent = pcm->ascent + boff;
it->phys_descent = pcm->descent - boff;
if (it->glyph_row
&& (pcm->lbearing < 0
|| pcm->rbearing > pcm->width))
it->glyph_row->contains_overlapping_glyphs_p = 1;
}
it->nglyphs = 1;
it->ascent = font->ascent + boff;
it->descent = font->descent - boff;
if (face->box != FACE_NO_BOX)
{
int thick = face->box_line_width;
if (thick > 0)
{
it->ascent += thick;
it->descent += thick;
}
else
thick = - thick;
if (it->start_of_box_run_p)
it->pixel_width += thick;
if (it->end_of_box_run_p)
it->pixel_width += thick;
}
if (face->overline_p)
it->ascent += 2;
take_vertical_position_into_account (it);
if (it->glyph_row)
x_append_glyph (it);
}
it->multibyte_p = saved_multibyte_p;
}
else if (it->what == IT_COMPOSITION)
{
XChar2b char2b;
XFontStruct *font;
struct face *face = FACE_FROM_ID (it->f, it->face_id);
XCharStruct *pcm;
int font_not_found_p;
struct font_info *font_info;
int boff;
struct composition *cmp = composition_table[it->cmp_id];
it->char_to_display = it->c;
if (unibyte_display_via_language_environment
&& SINGLE_BYTE_CHAR_P (it->c)
&& (it->c >= 0240
|| (it->c >= 0200
&& !NILP (Vnonascii_translation_table))))
{
it->char_to_display = unibyte_char_to_multibyte (it->c);
}
it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
face = FACE_FROM_ID (it->f, it->face_id);
x_get_char_face_and_encoding (it->f, it->char_to_display,
it->face_id, &char2b, it->multibyte_p);
font = face->font;
font_not_found_p = font == NULL;
if (font_not_found_p)
{
font = FRAME_FONT (it->f);
boff = it->f->output_data.x->baseline_offset;
font_info = NULL;
}
else
{
font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
boff = font_info->baseline_offset;
if (font_info->vertical_centering)
boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
}
it->nglyphs = 1;
if (cmp->font != (void *) font)
{
int font_ascent = font->ascent + boff;
int font_descent = font->descent - boff;
int leftmost, rightmost, lowest, highest;
int i, width, ascent, descent;
cmp->font = (void *) font;
if (font_info
&& (pcm = x_per_char_metric (font, &char2b)))
{
width = pcm->width;
ascent = pcm->ascent;
descent = pcm->descent;
}
else
{
width = FONT_WIDTH (font);
ascent = font->ascent;
descent = font->descent;
}
rightmost = width;
lowest = - descent + boff;
highest = ascent + boff;
leftmost = 0;
if (font_info
&& font_info->default_ascent
&& CHAR_TABLE_P (Vuse_default_ascent)
&& !NILP (Faref (Vuse_default_ascent,
make_number (it->char_to_display))))
highest = font_info->default_ascent + boff;
cmp->offsets[0] = 0;
cmp->offsets[1] = boff;
for (i = 1; i < cmp->glyph_len; i++)
{
int left, right, btm, top;
int ch = COMPOSITION_GLYPH (cmp, i);
int face_id = FACE_FOR_CHAR (it->f, face, ch);
face = FACE_FROM_ID (it->f, face_id);
x_get_char_face_and_encoding (it->f, ch, face->id, &char2b,
it->multibyte_p);
font = face->font;
if (font == NULL)
{
font = FRAME_FONT (it->f);
boff = it->f->output_data.x->baseline_offset;
font_info = NULL;
}
else
{
font_info
= FONT_INFO_FROM_ID (it->f, face->font_info_id);
boff = font_info->baseline_offset;
if (font_info->vertical_centering)
boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
}
if (font_info
&& (pcm = x_per_char_metric (font, &char2b)))
{
width = pcm->width;
ascent = pcm->ascent;
descent = pcm->descent;
}
else
{
width = FONT_WIDTH (font);
ascent = 1;
descent = 0;
}
if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
{
left = (leftmost + rightmost - width) / 2;
btm = - descent + boff;
if (font_info && font_info->relative_compose
&& (! CHAR_TABLE_P (Vignore_relative_composition)
|| NILP (Faref (Vignore_relative_composition,
make_number (ch)))))
{
if (- descent >= font_info->relative_compose)
btm = highest + 1;
else if (ascent <= 0)
btm = lowest - 1 - ascent - descent;
}
}
else
{
int rule = COMPOSITION_RULE (cmp, i);
int gref, nref, grefx, grefy, nrefx, nrefy;
COMPOSITION_DECODE_RULE (rule, gref, nref);
grefx = gref % 3, nrefx = nref % 3;
grefy = gref / 3, nrefy = nref / 3;
left = (leftmost
+ grefx * (rightmost - leftmost) / 2
- nrefx * width / 2);
btm = ((grefy == 0 ? highest
: grefy == 1 ? 0
: grefy == 2 ? lowest
: (highest + lowest) / 2)
- (nrefy == 0 ? ascent + descent
: nrefy == 1 ? descent - boff
: nrefy == 2 ? 0
: (ascent + descent) / 2));
}
cmp->offsets[i * 2] = left;
cmp->offsets[i * 2 + 1] = btm + descent;
right = left + width;
top = btm + descent + ascent;
if (left < leftmost)
leftmost = left;
if (right > rightmost)
rightmost = right;
if (top > highest)
highest = top;
if (btm < lowest)
lowest = btm;
}
if (leftmost < 0)
{
for (i = 0; i < cmp->glyph_len; i++)
cmp->offsets[i * 2] -= leftmost;
rightmost -= leftmost;
}
cmp->pixel_width = rightmost;
cmp->ascent = highest;
cmp->descent = - lowest;
if (cmp->ascent < font_ascent)
cmp->ascent = font_ascent;
if (cmp->descent < font_descent)
cmp->descent = font_descent;
}
it->pixel_width = cmp->pixel_width;
it->ascent = it->phys_ascent = cmp->ascent;
it->descent = it->phys_descent = cmp->descent;
if (face->box != FACE_NO_BOX)
{
int thick = face->box_line_width;
if (thick > 0)
{
it->ascent += thick;
it->descent += thick;
}
else
thick = - thick;
if (it->start_of_box_run_p)
it->pixel_width += thick;
if (it->end_of_box_run_p)
it->pixel_width += thick;
}
if (face->overline_p)
it->ascent += 2;
take_vertical_position_into_account (it);
if (it->glyph_row)
x_append_composite_glyph (it);
}
else if (it->what == IT_IMAGE)
x_produce_image_glyph (it);
else if (it->what == IT_STRETCH)
x_produce_stretch_glyph (it);
xassert (it->ascent >= 0 && it->descent >= 0);
if (it->area == TEXT_AREA)
it->current_x += it->pixel_width;
it->descent += it->extra_line_spacing;
it->max_ascent = max (it->max_ascent, it->ascent);
it->max_descent = max (it->max_descent, it->descent);
it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
}
int
x_estimate_mode_line_height (f, face_id)
struct frame *f;
enum face_id face_id;
{
int height = FONT_HEIGHT (FRAME_FONT (f));
if (FRAME_FACE_CACHE (f))
{
struct face *face = FACE_FROM_ID (f, face_id);
if (face)
{
if (face->font)
height = FONT_HEIGHT (face->font);
if (face->box_line_width > 0)
height += 2 * face->box_line_width;
}
}
return height;
}
struct glyph_string
{
int x;
int y, ybase;
int width;
int background_width;
int height;
int left_overhang;
int right_overhang;
struct frame *f;
struct window *w;
Display *display;
Window window;
struct glyph_row *row;
enum glyph_row_area area;
XChar2b *char2b;
int nchars;
enum draw_glyphs_face hl;
struct face *face;
XFontStruct *font;
struct font_info *font_info;
struct composition *cmp;
int gidx;
unsigned extends_to_end_of_line_p : 1;
unsigned background_filled_p : 1;
unsigned two_byte_p : 1;
unsigned font_not_found_p : 1;
unsigned stippled_p : 1;
unsigned for_overlaps_p : 1;
GC gc;
struct glyph *first_glyph;
struct image *img;
struct glyph_string *next, *prev;
};
#if GLYPH_DEBUG
static void
x_dump_glyph_string (s)
struct glyph_string *s;
{
fprintf (stderr, "glyph string\n");
fprintf (stderr, " x, y, w, h = %d, %d, %d, %d\n",
s->x, s->y, s->width, s->height);
fprintf (stderr, " ybase = %d\n", s->ybase);
fprintf (stderr, " hl = %d\n", s->hl);
fprintf (stderr, " left overhang = %d, right = %d\n",
s->left_overhang, s->right_overhang);
fprintf (stderr, " nchars = %d\n", s->nchars);
fprintf (stderr, " extends to end of line = %d\n",
s->extends_to_end_of_line_p);
fprintf (stderr, " font height = %d\n", FONT_HEIGHT (s->font));
fprintf (stderr, " bg width = %d\n", s->background_width);
}
#endif
static void x_append_glyph_string_lists P_ ((struct glyph_string **,
struct glyph_string **,
struct glyph_string *,
struct glyph_string *));
static void x_prepend_glyph_string_lists P_ ((struct glyph_string **,
struct glyph_string **,
struct glyph_string *,
struct glyph_string *));
static void x_append_glyph_string P_ ((struct glyph_string **,
struct glyph_string **,
struct glyph_string *));
static int x_left_overwritten P_ ((struct glyph_string *));
static int x_left_overwriting P_ ((struct glyph_string *));
static int x_right_overwritten P_ ((struct glyph_string *));
static int x_right_overwriting P_ ((struct glyph_string *));
static int x_fill_glyph_string P_ ((struct glyph_string *, int, int, int,
int));
static void x_init_glyph_string P_ ((struct glyph_string *,
XChar2b *, struct window *,
struct glyph_row *,
enum glyph_row_area, int,
enum draw_glyphs_face));
static int x_draw_glyphs P_ ((struct window *, int , struct glyph_row *,
enum glyph_row_area, int, int,
enum draw_glyphs_face, int));
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 void x_get_glyph_overhangs P_ ((struct glyph *, struct frame *,
int *, int *));
static void x_compute_overhangs_and_x P_ ((struct glyph_string *, int, int));
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_fill_image_glyph_string P_ ((struct glyph_string *));
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, XRectangle *));
static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
int, int, int, XRectangle *));
static void x_fix_overlapping_area P_ ((struct window *, struct glyph_row *,
enum glyph_row_area));
static int x_fill_stretch_glyph_string P_ ((struct glyph_string *,
struct glyph_row *,
enum glyph_row_area, int, int));
#if GLYPH_DEBUG
static void x_check_font P_ ((struct frame *, XFontStruct *));
#endif
static INLINE void
x_append_glyph_string_lists (head, tail, h, t)
struct glyph_string **head, **tail;
struct glyph_string *h, *t;
{
if (h)
{
if (*head)
(*tail)->next = h;
else
*head = h;
h->prev = *tail;
*tail = t;
}
}
static INLINE void
x_prepend_glyph_string_lists (head, tail, h, t)
struct glyph_string **head, **tail;
struct glyph_string *h, *t;
{
if (h)
{
if (*head)
(*head)->prev = t;
else
*tail = t;
t->next = *head;
*head = h;
}
}
static INLINE void
x_append_glyph_string (head, tail, s)
struct glyph_string **head, **tail;
struct glyph_string *s;
{
s->next = s->prev = NULL;
x_append_glyph_string_lists (head, tail, s, s);
}
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 void
x_get_glyph_string_clip_rect (s, r)
struct glyph_string *s;
XRectangle *r;
{
if (s->row->full_width_p)
{
int canon_x = CANON_X_UNIT (s->f);
r->x = WINDOW_LEFT_MARGIN (s->w) * canon_x;
r->width = XFASTINT (s->w->width) * canon_x;
if (FRAME_HAS_VERTICAL_SCROLL_BARS (s->f))
{
int width = FRAME_SCROLL_BAR_WIDTH (s->f) * canon_x;
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s->f))
r->x -= width;
}
r->x += FRAME_INTERNAL_BORDER_WIDTH (s->f);
if (s->w->pseudo_window_p)
r->height = s->row->visible_height;
else
r->height = s->height;
}
else
{
r->x = WINDOW_AREA_TO_FRAME_PIXEL_X (s->w, s->area, 0);
r->width = window_box_width (s->w, s->area);
r->height = s->row->visible_height;
}
if (s->for_overlaps_p)
{
r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
r->height = window_text_bottom_y (s->w) - r->y;
}
else
{
if (!s->row->full_width_p
&& MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
else
r->y = max (0, s->row->y);
if (s->w == XWINDOW (s->f->tool_bar_window))
r->y -= s->f->output_data.x->internal_border_width;
}
r->y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r->y);
}
static INLINE void
x_set_glyph_string_clipping (s)
struct glyph_string *s;
{
XRectangle r;
x_get_glyph_string_clip_rect (s, &r);
XSetClipRectangles (s->display, s->gc, 0, 0, &r, 1, Unsorted);
}
static INLINE 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 void
x_compute_overhangs_and_x (s, x, backward_p)
struct glyph_string *s;
int x;
int backward_p;
{
if (backward_p)
{
while (s)
{
x_compute_glyph_string_overhangs (s);
x -= s->width;
s->x = x;
s = s->prev;
}
}
else
{
while (s)
{
x_compute_glyph_string_overhangs (s);
s->x = x;
x += s->width;
s = s->next;
}
}
}
static void
x_get_glyph_overhangs (glyph, f, left, right)
struct glyph *glyph;
struct frame *f;
int *left, *right;
{
*left = *right = 0;
if (glyph->type == CHAR_GLYPH)
{
XFontStruct *font;
struct face *face;
struct font_info *font_info;
XChar2b char2b;
XCharStruct *pcm;
face = x_get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
font = face->font;
font_info = FONT_INFO_FROM_ID (f, face->font_info_id);
if (font
&& (pcm = x_per_char_metric (font, &char2b)))
{
if (pcm->rbearing > pcm->width)
*right = pcm->rbearing - pcm->width;
if (pcm->lbearing < 0)
*left = -pcm->lbearing;
}
}
}
static int
x_left_overwritten (s)
struct glyph_string *s;
{
int k;
if (s->left_overhang)
{
int x = 0, i;
struct glyph *glyphs = s->row->glyphs[s->area];
int first = s->first_glyph - glyphs;
for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
x -= glyphs[i].pixel_width;
k = i + 1;
}
else
k = -1;
return k;
}
static int
x_left_overwriting (s)
struct glyph_string *s;
{
int i, k, x;
struct glyph *glyphs = s->row->glyphs[s->area];
int first = s->first_glyph - glyphs;
k = -1;
x = 0;
for (i = first - 1; i >= 0; --i)
{
int left, right;
x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
if (x + right > 0)
k = i;
x -= glyphs[i].pixel_width;
}
return k;
}
static int
x_right_overwritten (s)
struct glyph_string *s;
{
int k = -1;
if (s->right_overhang)
{
int x = 0, i;
struct glyph *glyphs = s->row->glyphs[s->area];
int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
int end = s->row->used[s->area];
for (i = first; i < end && s->right_overhang > x; ++i)
x += glyphs[i].pixel_width;
k = i;
}
return k;
}
static int
x_right_overwriting (s)
struct glyph_string *s;
{
int i, k, x;
int end = s->row->used[s->area];
struct glyph *glyphs = s->row->glyphs[s->area];
int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
k = -1;
x = 0;
for (i = first; i < end; ++i)
{
int left, right;
x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
if (x - left < 0)
k = i;
x += glyphs[i].pixel_width;
}
return k;
}
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_p
|| (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);
}
}
}
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);
}
}
#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
{
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, left_p, right_p, clip_rect)
struct frame *f;
int left_x, top_y, right_x, bottom_y, 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);
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);
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, 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 = window_box_right (s->w, s->area);
if (s->row->full_width_p
&& !s->w->pseudo_window_p)
{
last_x += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s->f);
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s->f))
last_x += FRAME_SCROLL_BAR_WIDTH (s->f) * CANON_X_UNIT (s->f);
}
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)));
x_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, left_p, right_p, &clip_rect);
}
}
static void
x_draw_image_foreground (s)
struct glyph_string *s;
{
int x;
int y = s->ybase - image_ascent (s->img, s->face);
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;
x += s->img->hmargin;
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);
x_get_glyph_string_clip_rect (s, &clip_rect);
image_rect.x = x;
image_rect.y = y;
image_rect.width = s->img->width;
image_rect.height = s->img->height;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
r.x - x, r.y - y, r.width, r.height, r.x, r.y);
}
else
{
unsigned long mask = GCClipXOrigin | GCClipYOrigin | GCFunction;
XGCValues xgcv;
XRectangle clip_rect, image_rect, r;
x_get_glyph_string_clip_rect (s, &clip_rect);
image_rect.x = x;
image_rect.y = y;
image_rect.width = s->img->width;
image_rect.height = s->img->height;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
r.x - x, r.y - y, r.width, r.height, r.x, r.y);
if (s->hl == DRAW_CURSOR)
XDrawRectangle (s->display, s->window, s->gc, x, y,
s->img->width - 1, s->img->height - 1);
}
}
else
XDrawRectangle (s->display, s->window, s->gc, x, y,
s->img->width - 1, s->img->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;
int y = s->ybase - image_ascent (s->img, s->face);
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;
x += s->img->hmargin;
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 : 3;
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->img->width + thick - 1;
y1 = y + s->img->height + thick - 1;
x_setup_relief_colors (s);
x_get_glyph_string_clip_rect (s, &r);
x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
}
static void
x_draw_image_foreground_1 (s, pixmap)
struct glyph_string *s;
Pixmap pixmap;
{
int x;
int y = s->ybase - s->y - image_ascent (s->img, s->face);
if (s->face->box != FACE_NO_BOX
&& s->first_glyph->left_box_line_p)
x = abs (s->face->box_line_width);
else
x = 0;
x += s->img->hmargin;
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;
xgcv.clip_y_origin = y;
xgcv.function = GXcopy;
XChangeGC (s->display, s->gc, mask, &xgcv);
XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
0, 0, s->img->width, s->img->height, x, y);
XSetClipMask (s->display, s->gc, None);
}
else
{
XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
0, 0, s->img->width, s->img->height, x, y);
if (s->hl == DRAW_CURSOR)
XDrawRectangle (s->display, pixmap, s->gc, x, y,
s->img->width - 1, s->img->height - 1);
}
}
else
XDrawRectangle (s->display, pixmap, s->gc, x, y,
s->img->width - 1, s->img->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 x, y;
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 - 2 * box_line_vwidth;
s->stippled_p = s->face->stipple != 0;
if (height > s->img->height
|| s->img->hmargin
|| s->img->vmargin
|| s->img->mask
|| s->img->pixmap == 0
|| s->width != s->background_width)
{
if (box_line_hwidth && s->first_glyph->left_box_line_p)
x = s->x + box_line_hwidth;
else
x = s->x;
y = s->y + box_line_vwidth;
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
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 = min (CANON_X_UNIT (s->f), s->background_width);
x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
if (width < s->background_width)
{
int x = s->x + width, y = s->y;
int w = s->background_width - width, h = s->height;
XRectangle r;
GC gc;
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;
x_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)
x_draw_glyph_string_bg_rect (s, s->x, s->y, s->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_p)
{
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_p
&& 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_p)
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_p || 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_p)
{
if (s->face->underline_p)
{
unsigned long tem, h;
int y;
if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
h = 1;
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;
else
y = s->y + s->height - h;
if (s->face->underline_defaulted_p)
XFillRectangle (s->display, s->window, s->gc,
s->x, y, s->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->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->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->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);
}
static int x_fill_composite_glyph_string P_ ((struct glyph_string *,
struct face **, int));
static int
x_fill_composite_glyph_string (s, faces, overlaps_p)
struct glyph_string *s;
struct face **faces;
int overlaps_p;
{
int i;
xassert (s);
s->for_overlaps_p = overlaps_p;
s->face = faces[s->gidx];
s->font = s->face->font;
s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
++s->nchars;
for (i = s->gidx + 1; i < s->cmp->glyph_len && faces[i] == s->face; ++i)
++s->nchars;
s->width = s->first_glyph->pixel_width;
if (s->font == NULL)
{
s->font_not_found_p = 1;
s->font = FRAME_FONT (s->f);
}
s->ybase += s->first_glyph->voffset;
xassert (s->face && s->face->gc);
s->two_byte_p = 1;
return s->gidx + s->nchars;
}
static int
x_fill_glyph_string (s, face_id, start, end, overlaps_p)
struct glyph_string *s;
int face_id;
int start, end, overlaps_p;
{
struct glyph *glyph, *last;
int voffset;
int glyph_not_available_p;
xassert (s->f == XFRAME (s->w->frame));
xassert (s->nchars == 0);
xassert (start >= 0 && end > start);
s->for_overlaps_p = overlaps_p,
glyph = s->row->glyphs[s->area] + start;
last = s->row->glyphs[s->area] + end;
voffset = glyph->voffset;
glyph_not_available_p = glyph->glyph_not_available_p;
while (glyph < last
&& glyph->type == CHAR_GLYPH
&& glyph->voffset == voffset
&& glyph->face_id == face_id
&& glyph->glyph_not_available_p == glyph_not_available_p)
{
int two_byte_p;
s->face = x_get_glyph_face_and_encoding (s->f, glyph,
s->char2b + s->nchars,
&two_byte_p);
s->two_byte_p = two_byte_p;
++s->nchars;
xassert (s->nchars <= end - start);
s->width += glyph->pixel_width;
++glyph;
}
s->font = s->face->font;
s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
if (s->font == NULL || glyph_not_available_p)
{
s->font_not_found_p = 1;
s->font = FRAME_FONT (s->f);
}
s->ybase += voffset;
xassert (s->face && s->face->gc);
return glyph - s->row->glyphs[s->area];
}
static void
x_fill_image_glyph_string (s)
struct glyph_string *s;
{
xassert (s->first_glyph->type == IMAGE_GLYPH);
s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
xassert (s->img);
s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
s->font = s->face->font;
s->width = s->first_glyph->pixel_width;
s->ybase += s->first_glyph->voffset;
}
static int
x_fill_stretch_glyph_string (s, row, area, start, end)
struct glyph_string *s;
struct glyph_row *row;
enum glyph_row_area area;
int start, end;
{
struct glyph *glyph, *last;
int voffset, face_id;
xassert (s->first_glyph->type == STRETCH_GLYPH);
glyph = s->row->glyphs[s->area] + start;
last = s->row->glyphs[s->area] + end;
face_id = glyph->face_id;
s->face = FACE_FROM_ID (s->f, face_id);
s->font = s->face->font;
s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
s->width = glyph->pixel_width;
voffset = glyph->voffset;
for (++glyph;
(glyph < last
&& glyph->type == STRETCH_GLYPH
&& glyph->voffset == voffset
&& glyph->face_id == face_id);
++glyph)
s->width += glyph->pixel_width;
s->ybase += voffset;
xassert (s->face);
return glyph - s->row->glyphs[s->area];
}
static void
x_init_glyph_string (s, char2b, w, row, area, start, hl)
struct glyph_string *s;
XChar2b *char2b;
struct window *w;
struct glyph_row *row;
enum glyph_row_area area;
int start;
enum draw_glyphs_face hl;
{
bzero (s, sizeof *s);
s->w = w;
s->f = XFRAME (w->frame);
s->display = FRAME_X_DISPLAY (s->f);
s->window = FRAME_X_WINDOW (s->f);
s->char2b = char2b;
s->hl = hl;
s->row = row;
s->area = area;
s->first_glyph = row->glyphs[area] + start;
s->height = row->height;
s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
if (s->w == XWINDOW (s->f->tool_bar_window))
s->y -= s->f->output_data.x->internal_border_width;
s->ybase = s->y + row->ascent;
}
static INLINE void
x_set_glyph_string_background_width (s, start, last_x)
struct glyph_string *s;
int start;
int last_x;
{
struct face *default_face = FACE_FROM_ID (s->f, DEFAULT_FACE_ID);
if (start == s->row->used[s->area]
&& s->area == TEXT_AREA
&& ((s->hl == DRAW_NORMAL_TEXT
&& (s->row->fill_line_p
|| s->face->background != default_face->background
|| s->face->stipple != default_face->stipple
|| s->row->mouse_face_p))
|| s->hl == DRAW_MOUSE_FACE
|| ((s->hl == DRAW_IMAGE_RAISED || s->hl == DRAW_IMAGE_SUNKEN)
&& s->row->fill_line_p)))
s->extends_to_end_of_line_p = 1;
if (s->extends_to_end_of_line_p)
s->background_width = last_x - s->x + 1;
else
s->background_width = s->width;
}
#define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
x_append_glyph_string (&HEAD, &TAIL, s); \
s->x = (X); \
} \
while (0)
#define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
x_fill_image_glyph_string (s); \
x_append_glyph_string (&HEAD, &TAIL, s); \
++START; \
s->x = (X); \
} \
while (0)
#define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
do \
{ \
int c, face_id; \
XChar2b *char2b; \
\
c = (ROW)->glyphs[AREA][START].u.ch; \
face_id = (ROW)->glyphs[AREA][START].face_id; \
\
s = (struct glyph_string *) alloca (sizeof *s); \
char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
x_append_glyph_string (&HEAD, &TAIL, s); \
s->x = (X); \
START = x_fill_glyph_string (s, face_id, START, END, \
OVERLAPS_P); \
} \
while (0)
#define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
do { \
int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
int face_id = (ROW)->glyphs[AREA][START].face_id; \
struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
struct composition *cmp = composition_table[cmp_id]; \
int glyph_len = cmp->glyph_len; \
XChar2b *char2b; \
struct face **faces; \
struct glyph_string *first_s = NULL; \
int n; \
\
base_face = base_face->ascii_face; \
char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
\
for (n = 0; n < glyph_len; n++) \
{ \
int c = COMPOSITION_GLYPH (cmp, n); \
int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
x_get_char_face_and_encoding (XFRAME (w->frame), c, \
this_face_id, char2b + n, 1); \
} \
\
\
for (n = 0; n < cmp->glyph_len;) \
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
x_append_glyph_string (&(HEAD), &(TAIL), s); \
s->cmp = cmp; \
s->gidx = n; \
s->x = (X); \
\
if (n == 0) \
first_s = s; \
\
n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
} \
\
++START; \
s = first_s; \
} while (0)
#define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
do \
{ \
HEAD = TAIL = NULL; \
while (START < END) \
{ \
struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
switch (first_glyph->type) \
{ \
case CHAR_GLYPH: \
BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
TAIL, HL, X, LAST_X, \
OVERLAPS_P); \
break; \
\
case COMPOSITE_GLYPH: \
BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
HEAD, TAIL, HL, X, LAST_X,\
OVERLAPS_P); \
break; \
\
case STRETCH_GLYPH: \
BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
HEAD, TAIL, HL, X, LAST_X); \
break; \
\
case IMAGE_GLYPH: \
BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
TAIL, HL, X, LAST_X); \
break; \
\
default: \
abort (); \
} \
\
x_set_glyph_string_background_width (s, START, LAST_X); \
(X) += s->width; \
} \
} \
while (0)
static int
x_draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
struct window *w;
int x;
struct glyph_row *row;
enum glyph_row_area area;
int start, end;
enum draw_glyphs_face hl;
int overlaps_p;
{
struct glyph_string *head, *tail;
struct glyph_string *s;
int last_x, area_width;
int x_reached;
int i, j;
end = min (end, row->used[area]);
start = max (0, start);
start = min (end, start);
if (row->full_width_p)
{
struct frame *f = XFRAME (w->frame);
int window_left_x = WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f);
x += window_left_x;
area_width = XFASTINT (w->width) * CANON_X_UNIT (f);
last_x = window_left_x + area_width;
if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
{
int width = FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
last_x += width;
else
x -= width;
}
x += FRAME_INTERNAL_BORDER_WIDTH (f);
last_x += FRAME_INTERNAL_BORDER_WIDTH (f);
}
else
{
x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, x);
area_width = window_box_width (w, area);
last_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, area_width);
}
i = start;
BUILD_GLYPH_STRINGS (w, row, area, i, end, head, tail, hl, x, last_x,
overlaps_p);
if (tail)
x_reached = tail->x + tail->background_width;
else
x_reached = x;
if (head && !overlaps_p && row->contains_overlapping_glyphs_p)
{
int dummy_x = 0;
struct glyph_string *h, *t;
for (s = head; s; s = s->next)
x_compute_glyph_string_overhangs (s);
i = x_left_overwritten (head);
if (i >= 0)
{
j = i;
BUILD_GLYPH_STRINGS (w, row, area, j, start, h, t,
DRAW_NORMAL_TEXT, dummy_x, last_x,
overlaps_p);
start = i;
x_compute_overhangs_and_x (t, head->x, 1);
x_prepend_glyph_string_lists (&head, &tail, h, t);
}
i = x_left_overwriting (head);
if (i >= 0)
{
BUILD_GLYPH_STRINGS (w, row, area, i, start, h, t,
DRAW_NORMAL_TEXT, dummy_x, last_x,
overlaps_p);
for (s = h; s; s = s->next)
s->background_filled_p = 1;
x_compute_overhangs_and_x (t, head->x, 1);
x_prepend_glyph_string_lists (&head, &tail, h, t);
}
i = x_right_overwritten (tail);
if (i >= 0)
{
BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
DRAW_NORMAL_TEXT, x, last_x,
overlaps_p);
x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
x_append_glyph_string_lists (&head, &tail, h, t);
}
i = x_right_overwriting (tail);
if (i >= 0)
{
BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
DRAW_NORMAL_TEXT, x, last_x,
overlaps_p);
for (s = h; s; s = s->next)
s->background_filled_p = 1;
x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
x_append_glyph_string_lists (&head, &tail, h, t);
}
}
for (s = head; s; s = s->next)
x_draw_glyph_string (s);
if (area == TEXT_AREA
&& !row->full_width_p
&& !overlaps_p)
{
int x0 = head ? head->x : x;
int x1 = tail ? tail->x + tail->background_width : x;
x0 = FRAME_TO_WINDOW_PIXEL_X (w, x0);
x1 = FRAME_TO_WINDOW_PIXEL_X (w, x1);
if (XFASTINT (w->left_margin_width) != 0)
{
int left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
x0 -= left_area_width;
x1 -= left_area_width;
}
notice_overwritten_cursor (w, x0, x1);
}
x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
if (!row->full_width_p)
{
if (area > LEFT_MARGIN_AREA && XFASTINT (w->left_margin_width) != 0)
x_reached -= window_box_width (w, LEFT_MARGIN_AREA);
if (area > TEXT_AREA)
x_reached -= window_box_width (w, TEXT_AREA);
}
return x_reached;
}
static void
x_fix_overlapping_area (w, row, area)
struct window *w;
struct glyph_row *row;
enum glyph_row_area area;
{
int i, x;
BLOCK_INPUT;
if (area == LEFT_MARGIN_AREA)
x = 0;
else if (area == TEXT_AREA)
x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
else
x = (window_box_width (w, LEFT_MARGIN_AREA)
+ window_box_width (w, TEXT_AREA));
for (i = 0; i < row->used[area];)
{
if (row->glyphs[area][i].overlaps_vertically_p)
{
int start = i, start_x = x;
do
{
x += row->glyphs[area][i].pixel_width;
++i;
}
while (i < row->used[area]
&& row->glyphs[area][i].overlaps_vertically_p);
x_draw_glyphs (w, start_x, row, area, start, i,
(row->inverse_p
? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
1);
}
else
{
x += row->glyphs[area][i].pixel_width;
++i;
}
}
UNBLOCK_INPUT;
}
static void
x_write_glyphs (start, len)
struct glyph *start;
int len;
{
int x, hpos;
xassert (updated_window && updated_row);
BLOCK_INPUT;
hpos = start - updated_row->glyphs[updated_area];
x = x_draw_glyphs (updated_window, output_cursor.x,
updated_row, updated_area,
hpos, hpos + len,
(updated_row->inverse_p
? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
0);
UNBLOCK_INPUT;
output_cursor.hpos += len;
output_cursor.x = x;
}
static void
x_insert_glyphs (start, len)
struct glyph *start;
register int len;
{
struct frame *f;
struct window *w;
int line_height, shift_by_width, shifted_region_width;
struct glyph_row *row;
struct glyph *glyph;
int frame_x, frame_y, hpos, real_start, real_end;
xassert (updated_window && updated_row);
BLOCK_INPUT;
w = updated_window;
f = XFRAME (WINDOW_FRAME (w));
row = updated_row;
line_height = row->height;
shift_by_width = 0;
for (glyph = start; glyph < start + len; ++glyph)
shift_by_width += glyph->pixel_width;
shifted_region_width = (window_box_width (w, updated_area)
- output_cursor.x
- shift_by_width);
frame_x = window_box_left (w, updated_area) + output_cursor.x;
frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc,
frame_x, frame_y,
shifted_region_width, line_height,
frame_x + shift_by_width, frame_y);
hpos = start - row->glyphs[updated_area];
x_draw_glyphs (w, output_cursor.x, row, updated_area, hpos, hpos + len,
DRAW_NORMAL_TEXT, 0);
output_cursor.hpos += len;
output_cursor.x += shift_by_width;
UNBLOCK_INPUT;
}
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_end_of_line (to_x)
int to_x;
{
struct frame *f;
struct window *w = updated_window;
int max_x, min_y, max_y;
int from_x, from_y, to_y;
xassert (updated_window && updated_row);
f = XFRAME (w->frame);
if (updated_row->full_width_p)
{
max_x = XFASTINT (w->width) * CANON_X_UNIT (f);
if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
&& !w->pseudo_window_p)
max_x += FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
}
else
max_x = window_box_width (w, updated_area);
max_y = window_text_bottom_y (w);
if (to_x == 0)
return;
else if (to_x < 0)
to_x = max_x;
else
to_x = min (to_x, max_x);
to_y = min (max_y, output_cursor.y + updated_row->height);
if (!updated_row->full_width_p)
notice_overwritten_cursor (w, output_cursor.x, -1);
from_x = output_cursor.x;
if (updated_row->full_width_p)
{
from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
}
else
{
from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
}
min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
if (to_x > from_x && to_y > from_y)
{
BLOCK_INPUT;
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
from_x, from_y, to_x - from_x, to_y - from_y,
False);
UNBLOCK_INPUT;
}
}
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 = CHAR_TO_PIXEL_HEIGHT (f, FRAME_HEIGHT (f));
int flash_height = FRAME_LINE_HEIGHT (f);
int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
int flash_right = 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) * CANON_Y_UNIT (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) * CANON_Y_UNIT (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);
width += FRAME_X_FLAGS_AREA_WIDTH (f);
x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
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
expose_frame (f, x, y, w, h)
struct frame *f;
int x, y, w, h;
{
XRectangle r;
int mouse_face_overwritten_p = 0;
TRACE ((stderr, "expose_frame "));
if (FRAME_GARBAGED_P (f))
{
TRACE ((stderr, " garbaged\n"));
return;
}
if (FRAME_FACE_CACHE (f) == NULL
|| FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
{
TRACE ((stderr, " no faces\n"));
return;
}
if (w == 0 || h == 0)
{
r.x = r.y = 0;
r.width = CANON_X_UNIT (f) * f->width;
r.height = CANON_Y_UNIT (f) * f->height;
}
else
{
r.x = x;
r.y = y;
r.width = w;
r.height = h;
}
TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
if (WINDOWP (f->tool_bar_window))
mouse_face_overwritten_p
|= expose_window (XWINDOW (f->tool_bar_window), &r);
#ifndef USE_X_TOOLKIT
if (WINDOWP (f->menu_bar_window))
mouse_face_overwritten_p
|= expose_window (XWINDOW (f->menu_bar_window), &r);
#endif
if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (f == dpyinfo->mouse_face_mouse_frame)
{
int x = dpyinfo->mouse_face_mouse_x;
int y = dpyinfo->mouse_face_mouse_y;
clear_mouse_face (dpyinfo);
note_mouse_highlight (f, x, y);
}
}
}
static int
expose_window_tree (w, r)
struct window *w;
XRectangle *r;
{
struct frame *f = XFRAME (w->frame);
int mouse_face_overwritten_p = 0;
while (w && !FRAME_GARBAGED_P (f))
{
if (!NILP (w->hchild))
mouse_face_overwritten_p
|= expose_window_tree (XWINDOW (w->hchild), r);
else if (!NILP (w->vchild))
mouse_face_overwritten_p
|= expose_window_tree (XWINDOW (w->vchild), r);
else
mouse_face_overwritten_p |= expose_window (w, r);
w = NILP (w->next) ? NULL : XWINDOW (w->next);
}
return mouse_face_overwritten_p;
}
static void
expose_area (w, row, r, area)
struct window *w;
struct glyph_row *row;
XRectangle *r;
enum glyph_row_area area;
{
struct glyph *first = row->glyphs[area];
struct glyph *end = row->glyphs[area] + row->used[area];
struct glyph *last;
int first_x, start_x, x;
if (area == TEXT_AREA && row->fill_line_p)
x_draw_glyphs (w, 0, row, area,
0, row->used[area],
row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
0);
else
{
if (area == LEFT_MARGIN_AREA)
start_x = 0;
else if (area == TEXT_AREA)
start_x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
else
start_x = (window_box_width (w, LEFT_MARGIN_AREA)
+ window_box_width (w, TEXT_AREA));
x = start_x;
while (first < end
&& x + first->pixel_width < r->x)
{
x += first->pixel_width;
++first;
}
last = first;
first_x = x;
while (last < end
&& x < r->x + r->width)
{
x += last->pixel_width;
++last;
}
if (last > first)
x_draw_glyphs (w, first_x - start_x, row, area,
first - row->glyphs[area],
last - row->glyphs[area],
row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
0);
}
}
static int
expose_line (w, row, r)
struct window *w;
struct glyph_row *row;
XRectangle *r;
{
xassert (row->enabled_p);
if (row->mode_line_p || w->pseudo_window_p)
x_draw_glyphs (w, 0, row, TEXT_AREA, 0, row->used[TEXT_AREA],
row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
0);
else
{
if (row->used[LEFT_MARGIN_AREA])
expose_area (w, row, r, LEFT_MARGIN_AREA);
if (row->used[TEXT_AREA])
expose_area (w, row, r, TEXT_AREA);
if (row->used[RIGHT_MARGIN_AREA])
expose_area (w, row, r, RIGHT_MARGIN_AREA);
x_draw_row_bitmaps (w, row);
}
return row->mouse_face_p;
}
static int
x_phys_cursor_in_rect_p (w, r)
struct window *w;
XRectangle *r;
{
XRectangle cr, result;
struct glyph *cursor_glyph;
cursor_glyph = get_phys_cursor_glyph (w);
if (cursor_glyph)
{
cr.x = w->phys_cursor.x;
cr.y = w->phys_cursor.y;
cr.width = cursor_glyph->pixel_width;
cr.height = w->phys_cursor_height;
return x_intersect_rectangles (&cr, r, &result);
}
else
return 0;
}
static int
expose_window (w, fr)
struct window *w;
XRectangle *fr;
{
struct frame *f = XFRAME (w->frame);
XRectangle wr, r;
int mouse_face_overwritten_p = 0;
if (w->current_matrix == NULL)
return 0;
if (w == updated_window)
{
SET_FRAME_GARBAGED (f);
return 0;
}
wr.x = XFASTINT (w->left) * CANON_X_UNIT (f);
wr.y = XFASTINT (w->top) * CANON_Y_UNIT (f);
wr.width = XFASTINT (w->width) * CANON_X_UNIT (f);
wr.height = XFASTINT (w->height) * CANON_Y_UNIT (f);
if (x_intersect_rectangles (fr, &wr, &r))
{
int yb = window_text_bottom_y (w);
struct glyph_row *row;
int cursor_cleared_p;
TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
r.x, r.y, r.width, r.height));
r.x = FRAME_TO_WINDOW_PIXEL_X (w, r.x);
r.y = FRAME_TO_WINDOW_PIXEL_Y (w, r.y);
if (!w->pseudo_window_p
&& x_phys_cursor_in_rect_p (w, &r))
{
x_clear_cursor (w);
cursor_cleared_p = 1;
}
else
cursor_cleared_p = 0;
for (row = w->current_matrix->rows;
row->enabled_p;
++row)
{
int y0 = row->y;
int y1 = MATRIX_ROW_BOTTOM_Y (row);
if ((y0 >= r.y && y0 < r.y + r.height)
|| (y1 > r.y && y1 < r.y + r.height)
|| (r.y >= y0 && r.y < y1)
|| (r.y + r.height > y0 && r.y + r.height < y1))
{
if (expose_line (w, row, &r))
mouse_face_overwritten_p = 1;
}
if (y1 >= yb)
break;
}
if (WINDOW_WANTS_MODELINE_P (w)
&& (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
row->enabled_p)
&& row->y < r.y + r.height)
{
if (expose_line (w, row, &r))
mouse_face_overwritten_p = 1;
}
if (!w->pseudo_window_p)
{
x_draw_vertical_border (w);
if (cursor_cleared_p)
x_update_window_cursor (w, 1);
}
}
return mouse_face_overwritten_p;
}
static int
x_intersect_rectangles (r1, r2, result)
XRectangle *r1, *r2, *result;
{
XRectangle *left, *right;
XRectangle *upper, *lower;
int intersection_p = 0;
if (r1->x < r2->x)
left = r1, right = r2;
else
left = r2, right = r1;
if (right->x <= left->x + left->width)
{
result->x = right->x;
result->width = (min (left->x + left->width, right->x + right->width)
- result->x);
if (r1->y < r2->y)
upper = r1, lower = r2;
else
upper = r2, lower = r1;
if (lower->y <= upper->y + upper->height)
{
result->y = lower->y;
result->height = (min (lower->y + lower->height,
upper->y + upper->height)
- result->y);
intersection_p = 1;
}
}
return intersection_p;
}
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);
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);
}
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;
for (row = 3; row < 8; row++)
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:
dpyinfo->meta_mod_mask |= (1 << row);
break;
case XK_Alt_L:
case XK_Alt_R:
dpyinfo->alt_mod_mask |= (1 << row);
break;
case XK_Hyper_L:
case XK_Hyper_R:
dpyinfo->hyper_mod_mask |= (1 << row);
break;
case XK_Super_L:
case XK_Super_R:
dpyinfo->super_mod_mask |= (1 << row);
break;
case XK_Shift_Lock:
if ((1 << row) == LockMask)
dpyinfo->shift_lock_mask = LockMask;
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);
}
static unsigned int
x_x_to_emacs_modifiers (dpyinfo, state)
struct x_display_info *dpyinfo;
unsigned int state;
{
return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
| ((state & ControlMask) ? ctrl_modifier : 0)
| ((state & dpyinfo->meta_mod_mask) ? meta_modifier : 0)
| ((state & dpyinfo->alt_mod_mask) ? alt_modifier : 0)
| ((state & dpyinfo->super_mod_mask) ? super_modifier : 0)
| ((state & dpyinfo->hyper_mod_mask) ? hyper_modifier : 0));
}
static unsigned int
x_emacs_to_x_modifiers (dpyinfo, state)
struct x_display_info *dpyinfo;
unsigned int state;
{
return ( ((state & alt_modifier) ? dpyinfo->alt_mod_mask : 0)
| ((state & super_modifier) ? dpyinfo->super_mod_mask : 0)
| ((state & hyper_modifier) ? dpyinfo->hyper_mod_mask : 0)
| ((state & shift_modifier) ? ShiftMask : 0)
| ((state & ctrl_modifier) ? ControlMask : 0)
| ((state & meta_modifier) ? dpyinfo->meta_mod_mask : 0));
}
char *
x_get_keysym_name (keysym)
KeySym keysym;
{
char *value;
BLOCK_INPUT;
value = XKeysymToString (keysym);
UNBLOCK_INPUT;
return value;
}
void
pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
FRAME_PTR f;
register int pix_x, pix_y;
register int *x, *y;
XRectangle *bounds;
int noclip;
{
if (pix_x < 0)
pix_x -= FONT_WIDTH ((f)->output_data.x->font) - 1;
if (pix_y < 0)
pix_y -= (f)->output_data.x->line_height - 1;
pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
if (bounds)
{
bounds->width = FONT_WIDTH (f->output_data.x->font);
bounds->height = f->output_data.x->line_height;
bounds->x = CHAR_TO_PIXEL_COL (f, pix_x);
bounds->y = CHAR_TO_PIXEL_ROW (f, pix_y);
}
if (!noclip)
{
if (pix_x < 0)
pix_x = 0;
else if (pix_x > FRAME_WINDOW_WIDTH (f))
pix_x = FRAME_WINDOW_WIDTH (f);
if (pix_y < 0)
pix_y = 0;
else if (pix_y > f->height)
pix_y = f->height;
}
*x = pix_x;
*y = pix_y;
}
int
glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
struct window *w;
int hpos, vpos;
int *frame_x, *frame_y;
{
int success_p;
xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
if (display_completed)
{
struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
struct glyph *glyph = row->glyphs[TEXT_AREA];
struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
*frame_y = row->y;
*frame_x = row->x;
while (glyph < end)
{
*frame_x += glyph->pixel_width;
++glyph;
}
success_p = 1;
}
else
{
*frame_y = *frame_x = 0;
success_p = 0;
}
*frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, *frame_y);
*frame_x = WINDOW_TO_FRAME_PIXEL_X (w, *frame_x);
return success_p;
}
static Lisp_Object
construct_mouse_click (result, event, f)
struct input_event *result;
XButtonEvent *event;
struct frame *f;
{
result->kind = mouse_click;
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 void
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 (event->window != FRAME_X_WINDOW (frame))
{
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
note_mouse_highlight (frame, -1, -1);
}
else if (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);
}
}
int disable_mouse_highlight;
static struct glyph *
x_y_to_hpos_vpos (w, x, y, hpos, vpos, area, buffer_only_p)
struct window *w;
int x, y;
int *hpos, *vpos, *area;
int buffer_only_p;
{
struct glyph *glyph, *end;
struct glyph_row *row = NULL;
int x0, i, left_area_width;
for (i = 0; i < w->current_matrix->nrows; ++i)
{
row = MATRIX_ROW (w->current_matrix, i);
if (!row->enabled_p)
return NULL;
if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
break;
}
*vpos = i;
*hpos = 0;
if (i == w->current_matrix->nrows)
return NULL;
if (w->pseudo_window_p)
{
*area = TEXT_AREA;
x0 = 0;
}
else
{
left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
if (x < left_area_width)
{
*area = LEFT_MARGIN_AREA;
x0 = 0;
}
else if (x < left_area_width + window_box_width (w, TEXT_AREA))
{
*area = TEXT_AREA;
x0 = row->x + left_area_width;
}
else
{
*area = RIGHT_MARGIN_AREA;
x0 = left_area_width + window_box_width (w, TEXT_AREA);
}
}
glyph = row->glyphs[*area];
end = glyph + row->used[*area];
while (glyph < end)
{
if (x < x0 + glyph->pixel_width)
{
if (w->pseudo_window_p)
break;
else if (!buffer_only_p || BUFFERP (glyph->object))
break;
}
x0 += glyph->pixel_width;
++glyph;
}
if (glyph == end)
return NULL;
*hpos = glyph - row->glyphs[*area];
return glyph;
}
static void
frame_to_window_pixel_xy (w, x, y)
struct window *w;
int *x, *y;
{
if (w->pseudo_window_p)
{
struct frame *f = XFRAME (w->frame);
*x -= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
*y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
}
else
{
*x = FRAME_TO_WINDOW_PIXEL_X (w, *x);
*y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
}
}
static void
note_mode_line_highlight (w, x, mode_line_p)
struct window *w;
int x, mode_line_p;
{
struct frame *f = XFRAME (w->frame);
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Cursor cursor = dpyinfo->vertical_scroll_bar_cursor;
struct glyph_row *row;
if (mode_line_p)
row = MATRIX_MODE_LINE_ROW (w->current_matrix);
else
row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
if (row->enabled_p)
{
struct glyph *glyph, *end;
Lisp_Object help, map;
int x0;
glyph = row->glyphs[TEXT_AREA];
end = glyph + row->used[TEXT_AREA];
x0 = - (FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f)
+ FRAME_X_LEFT_FLAGS_AREA_WIDTH (f));
while (glyph < end
&& x >= x0 + glyph->pixel_width)
{
x0 += glyph->pixel_width;
++glyph;
}
if (glyph < end
&& STRINGP (glyph->object)
&& XSTRING (glyph->object)->intervals
&& glyph->charpos >= 0
&& glyph->charpos < XSTRING (glyph->object)->size)
{
help = Fget_text_property (make_number (glyph->charpos),
Qhelp_echo, glyph->object);
if (!NILP (help))
{
help_echo = help;
XSETWINDOW (help_echo_window, w);
help_echo_object = glyph->object;
help_echo_pos = glyph->charpos;
}
map = Fget_text_property (make_number (glyph->charpos),
Qlocal_map, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.x->nontext_cursor;
else
{
map = Fget_text_property (make_number (glyph->charpos),
Qkeymap, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.x->nontext_cursor;
}
}
}
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
}
static void
note_mouse_highlight (f, x, y)
struct frame *f;
int x, y;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
int portion;
Lisp_Object window;
struct window *w;
Cursor cursor = None;
struct buffer *b;
#ifdef USE_X_TOOLKIT
if (popup_activated ())
return;
#endif
if (disable_mouse_highlight
|| !f->glyphs_initialized_p)
return;
dpyinfo->mouse_face_mouse_x = x;
dpyinfo->mouse_face_mouse_y = y;
dpyinfo->mouse_face_mouse_frame = f;
if (dpyinfo->mouse_face_defer)
return;
if (gc_in_progress)
{
dpyinfo->mouse_face_deferred_gc = 1;
return;
}
window = window_from_coordinates (f, x, y, &portion, 1);
if (! EQ (window, dpyinfo->mouse_face_window))
clear_mouse_face (dpyinfo);
if (!WINDOWP (window))
return;
w = XWINDOW (window);
frame_to_window_pixel_xy (w, &x, &y);
if (EQ (window, f->tool_bar_window))
{
note_tool_bar_highlight (f, x, y);
return;
}
if (portion == 1 || portion == 3)
{
note_mode_line_highlight (w, x, portion == 1);
return;
}
if (portion == 2)
cursor = f->output_data.x->horizontal_drag_cursor;
else
cursor = f->output_data.x->text_cursor;
b = XBUFFER (w->buffer);
if (
portion == 0
&& EQ (w->window_end_valid, w->buffer)
&& XFASTINT (w->last_modified) == BUF_MODIFF (b)
&& XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
{
int hpos, vpos, pos, i, area;
struct glyph *glyph;
Lisp_Object object;
Lisp_Object mouse_face = Qnil, overlay = Qnil, position;
Lisp_Object *overlay_vec = NULL;
int len, noverlays;
struct buffer *obuf;
int obegv, ozv, same_region;
glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &area, 0);
if (glyph == NULL
|| area != TEXT_AREA
|| !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
{
if (clear_mouse_face (dpyinfo))
cursor = None;
goto set_cursor;
}
pos = glyph->charpos;
object = glyph->object;
if (!STRINGP (object) && !BUFFERP (object))
goto set_cursor;
if (BUFFERP (object) && pos > BUF_Z (b))
goto set_cursor;
obuf = current_buffer;
current_buffer = b;
obegv = BEGV;
ozv = ZV;
BEGV = BEG;
ZV = Z;
position = make_number (pos);
if (BUFFERP (object))
{
len = 10;
overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL, 0);
if (noverlays > len)
{
len = noverlays;
overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL,0);
}
noverlays = sort_overlays (overlay_vec, noverlays, w);
}
else
noverlays = 0;
same_region = (EQ (window, dpyinfo->mouse_face_window)
&& vpos >= dpyinfo->mouse_face_beg_row
&& vpos <= dpyinfo->mouse_face_end_row
&& (vpos > dpyinfo->mouse_face_beg_row
|| hpos >= dpyinfo->mouse_face_beg_col)
&& (vpos < dpyinfo->mouse_face_end_row
|| hpos < dpyinfo->mouse_face_end_col
|| dpyinfo->mouse_face_past_end));
if (same_region)
cursor = None;
if (! same_region
|| (OVERLAYP (dpyinfo->mouse_face_overlay)
&& mouse_face_overlay_overlaps (dpyinfo->mouse_face_overlay)))
{
overlay = Qnil;
for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
{
mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
if (!NILP (mouse_face))
overlay = overlay_vec[i];
}
if (!NILP (overlay)
&& EQ (overlay, dpyinfo->mouse_face_overlay))
goto check_help_echo;
dpyinfo->mouse_face_overlay = overlay;
if (clear_mouse_face (dpyinfo))
cursor = None;
if (NILP (overlay))
mouse_face = Fget_text_property (position, Qmouse_face, object);
if (!NILP (overlay))
{
Lisp_Object before, after;
int ignore;
before = Foverlay_start (overlay);
after = Foverlay_end (overlay);
fast_find_position (w, XFASTINT (before),
&dpyinfo->mouse_face_beg_col,
&dpyinfo->mouse_face_beg_row,
&dpyinfo->mouse_face_beg_x,
&dpyinfo->mouse_face_beg_y, Qnil);
dpyinfo->mouse_face_past_end
= !fast_find_position (w, XFASTINT (after),
&dpyinfo->mouse_face_end_col,
&dpyinfo->mouse_face_end_row,
&dpyinfo->mouse_face_end_x,
&dpyinfo->mouse_face_end_y, Qnil);
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
&ignore, pos + 1, 1);
show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
cursor = None;
}
else if (!NILP (mouse_face) && BUFFERP (object))
{
Lisp_Object before, after, beginning, end;
int ignore;
beginning = Fmarker_position (w->start);
end = make_number (BUF_Z (XBUFFER (object))
- XFASTINT (w->window_end_pos));
before
= Fprevious_single_property_change (make_number (pos + 1),
Qmouse_face,
object, beginning);
after
= Fnext_single_property_change (position, Qmouse_face,
object, end);
fast_find_position (w, XFASTINT (before),
&dpyinfo->mouse_face_beg_col,
&dpyinfo->mouse_face_beg_row,
&dpyinfo->mouse_face_beg_x,
&dpyinfo->mouse_face_beg_y, Qnil);
dpyinfo->mouse_face_past_end
= !fast_find_position (w, XFASTINT (after),
&dpyinfo->mouse_face_end_col,
&dpyinfo->mouse_face_end_row,
&dpyinfo->mouse_face_end_x,
&dpyinfo->mouse_face_end_y, Qnil);
dpyinfo->mouse_face_window = window;
if (BUFFERP (object))
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
&ignore, pos + 1, 1);
show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
cursor = None;
}
else if (!NILP (mouse_face) && STRINGP (object))
{
Lisp_Object b, e;
int ignore;
b = Fprevious_single_property_change (make_number (pos + 1),
Qmouse_face,
object, Qnil);
e = Fnext_single_property_change (position, Qmouse_face,
object, Qnil);
if (NILP (b))
b = make_number (0);
if (NILP (e))
e = make_number (XSTRING (object)->size - 1);
fast_find_string_pos (w, XINT (b), object,
&dpyinfo->mouse_face_beg_col,
&dpyinfo->mouse_face_beg_row,
&dpyinfo->mouse_face_beg_x,
&dpyinfo->mouse_face_beg_y, 0);
fast_find_string_pos (w, XINT (e), object,
&dpyinfo->mouse_face_end_col,
&dpyinfo->mouse_face_end_row,
&dpyinfo->mouse_face_end_x,
&dpyinfo->mouse_face_end_y, 1);
dpyinfo->mouse_face_past_end = 0;
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id
= face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
glyph->face_id, 1);
show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
cursor = None;
}
else if (STRINGP (object) && NILP (mouse_face))
{
struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
int start = MATRIX_ROW_START_CHARPOS (r);
pos = string_buffer_position (w, object, start);
if (pos > 0)
mouse_face = get_char_property_and_overlay (make_number (pos),
Qmouse_face,
w->buffer,
&overlay);
if (!NILP (mouse_face) && !NILP (overlay))
{
Lisp_Object before = Foverlay_start (overlay);
Lisp_Object after = Foverlay_end (overlay);
int ignore;
fast_find_position (w, XFASTINT (before),
&dpyinfo->mouse_face_beg_col,
&dpyinfo->mouse_face_beg_row,
&dpyinfo->mouse_face_beg_x,
&dpyinfo->mouse_face_beg_y,
object);
dpyinfo->mouse_face_past_end
= !fast_find_position (w, XFASTINT (after),
&dpyinfo->mouse_face_end_col,
&dpyinfo->mouse_face_end_row,
&dpyinfo->mouse_face_end_x,
&dpyinfo->mouse_face_end_y,
Qnil);
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
&ignore, pos + 1, 1);
show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
cursor = None;
}
}
}
check_help_echo:
{
Lisp_Object help, overlay;
help = overlay = Qnil;
for (i = noverlays - 1; i >= 0 && NILP (help); --i)
{
overlay = overlay_vec[i];
help = Foverlay_get (overlay, Qhelp_echo);
}
if (!NILP (help))
{
help_echo = help;
help_echo_window = window;
help_echo_object = overlay;
help_echo_pos = pos;
}
else
{
Lisp_Object object = glyph->object;
int charpos = glyph->charpos;
if (STRINGP (object)
&& charpos >= 0
&& charpos < XSTRING (object)->size)
{
help = Fget_text_property (make_number (charpos),
Qhelp_echo, object);
if (NILP (help))
{
struct glyph_row *r
= MATRIX_ROW (w->current_matrix, vpos);
int start = MATRIX_ROW_START_CHARPOS (r);
int pos = string_buffer_position (w, object, start);
if (pos > 0)
{
help = Fget_char_property (make_number (pos),
Qhelp_echo, w->buffer);
if (!NILP (help))
{
charpos = pos;
object = w->buffer;
}
}
}
}
else if (BUFFERP (object)
&& charpos >= BEGV
&& charpos < ZV)
help = Fget_text_property (make_number (charpos), Qhelp_echo,
object);
if (!NILP (help))
{
help_echo = help;
help_echo_window = window;
help_echo_object = object;
help_echo_pos = charpos;
}
}
}
BEGV = obegv;
ZV = ozv;
current_buffer = obuf;
}
set_cursor:
if (cursor != None)
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
}
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 int x_tool_bar_item P_ ((struct frame *, int, int,
struct glyph **, int *, int *, int *));
static int last_tool_bar_item;
static int
x_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
struct frame *f;
int x, y;
struct glyph **glyph;
int *hpos, *vpos, *prop_idx;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
struct window *w = XWINDOW (f->tool_bar_window);
int area;
*glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, &area, 0);
if (*glyph == NULL)
return -1;
if (!tool_bar_item_info (f, *glyph, prop_idx))
return -1;
if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
&& *vpos >= dpyinfo->mouse_face_beg_row
&& *vpos <= dpyinfo->mouse_face_end_row
&& (*vpos > dpyinfo->mouse_face_beg_row
|| *hpos >= dpyinfo->mouse_face_beg_col)
&& (*vpos < dpyinfo->mouse_face_end_row
|| *hpos < dpyinfo->mouse_face_end_col
|| dpyinfo->mouse_face_past_end))
return 0;
return 1;
}
static void
x_handle_tool_bar_click (f, button_event)
struct frame *f;
XButtonEvent *button_event;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
struct window *w = XWINDOW (f->tool_bar_window);
int hpos, vpos, prop_idx;
struct glyph *glyph;
Lisp_Object enabled_p;
int x = button_event->x;
int y = button_event->y;
frame_to_window_pixel_xy (w, &x, &y);
if (x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
return;
enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
if (NILP (enabled_p))
return;
if (button_event->type == ButtonPress)
{
show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
last_tool_bar_item = prop_idx;
}
else
{
Lisp_Object key, frame;
struct input_event event;
show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
XSETFRAME (frame, f);
event.kind = TOOL_BAR_EVENT;
event.frame_or_window = frame;
event.arg = frame;
kbd_buffer_store_event (&event);
event.kind = TOOL_BAR_EVENT;
event.frame_or_window = frame;
event.arg = key;
event.modifiers = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
button_event->state);
kbd_buffer_store_event (&event);
last_tool_bar_item = -1;
}
}
static void
note_tool_bar_highlight (f, x, y)
struct frame *f;
int x, y;
{
Lisp_Object window = f->tool_bar_window;
struct window *w = XWINDOW (window);
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
int hpos, vpos;
struct glyph *glyph;
struct glyph_row *row;
int i;
Lisp_Object enabled_p;
int prop_idx;
enum draw_glyphs_face draw;
int mouse_down_p, rc;
if (x <= 0 || y <= 0)
{
clear_mouse_face (dpyinfo);
return;
}
rc = x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
if (rc < 0)
{
clear_mouse_face (dpyinfo);
return;
}
else if (rc == 0)
goto set_help_echo;
clear_mouse_face (dpyinfo);
mouse_down_p = (dpyinfo->grabbed
&& f == last_mouse_frame
&& FRAME_LIVE_P (f));
if (mouse_down_p
&& last_tool_bar_item != prop_idx)
return;
dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
if (!NILP (enabled_p))
{
row = MATRIX_ROW (w->current_matrix, vpos);
for (i = x = 0; i < hpos; ++i)
x += row->glyphs[TEXT_AREA][i].pixel_width;
dpyinfo->mouse_face_beg_col = hpos;
dpyinfo->mouse_face_beg_row = vpos;
dpyinfo->mouse_face_beg_x = x;
dpyinfo->mouse_face_beg_y = row->y;
dpyinfo->mouse_face_past_end = 0;
dpyinfo->mouse_face_end_col = hpos + 1;
dpyinfo->mouse_face_end_row = vpos;
dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
dpyinfo->mouse_face_end_y = row->y;
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
show_mouse_face (dpyinfo, draw);
dpyinfo->mouse_face_image_state = draw;
}
set_help_echo:
help_echo_object = help_echo_window = Qnil;
help_echo_pos = -1;
help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
if (NILP (help_echo))
help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
}
#if 0
static int
fast_find_position (w, charpos, hpos, vpos, x, y, stop)
struct window *w;
int charpos;
int *hpos, *vpos, *x, *y;
Lisp_Object stop;
{
struct glyph_row *row, *first;
struct glyph *glyph, *end;
int i, past_end = 0;
first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
row = row_containing_pos (w, charpos, first, NULL, 0);
if (row == NULL)
{
if (charpos < MATRIX_ROW_START_CHARPOS (first))
{
*x = *y = *hpos = *vpos = 0;
return 0;
}
else
{
row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
past_end = 1;
}
}
*x = row->x;
*y = row->y;
*vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
glyph = row->glyphs[TEXT_AREA];
end = glyph + row->used[TEXT_AREA];
if (row->displays_text_p)
while (glyph < end
&& INTEGERP (glyph->object)
&& !EQ (stop, glyph->object)
&& glyph->charpos < 0)
{
*x += glyph->pixel_width;
++glyph;
}
while (glyph < end
&& !INTEGERP (glyph->object)
&& !EQ (stop, glyph->object)
&& (!BUFFERP (glyph->object)
|| glyph->charpos < charpos))
{
*x += glyph->pixel_width;
++glyph;
}
*hpos = glyph - row->glyphs[TEXT_AREA];
return past_end;
}
#else
static int
fast_find_position (w, pos, hpos, vpos, x, y, stop)
struct window *w;
int pos;
int *hpos, *vpos, *x, *y;
Lisp_Object stop;
{
int i;
int lastcol;
int maybe_next_line_p = 0;
int line_start_position;
int yb = window_text_bottom_y (w);
struct glyph_row *row, *best_row;
int row_vpos, best_row_vpos;
int current_x;
row = best_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
row_vpos = best_row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
while (row->y < yb)
{
if (row->used[TEXT_AREA])
line_start_position = row->glyphs[TEXT_AREA]->charpos;
else
line_start_position = 0;
if (line_start_position > pos)
break;
else if (line_start_position == pos
&& pos == BUF_ZV (XBUFFER (w->buffer)))
{
maybe_next_line_p = 1;
break;
}
else if (line_start_position > 0)
{
best_row = row;
best_row_vpos = row_vpos;
}
if (row->y + row->height >= yb)
break;
++row;
++row_vpos;
}
lastcol = 0;
current_x = best_row->x;
for (i = 0; i < best_row->used[TEXT_AREA]; i++)
{
struct glyph *glyph = best_row->glyphs[TEXT_AREA] + i;
int charpos = glyph->charpos;
if (BUFFERP (glyph->object))
{
if (charpos == pos)
{
*hpos = i;
*vpos = best_row_vpos;
*x = current_x;
*y = best_row->y;
return 1;
}
else if (charpos > pos)
break;
}
else if (EQ (glyph->object, stop))
break;
if (charpos > 0)
lastcol = i;
current_x += glyph->pixel_width;
}
if (maybe_next_line_p)
{
++best_row;
++best_row_vpos;
lastcol = 0;
current_x = best_row->x;
}
*vpos = best_row_vpos;
*hpos = lastcol + 1;
*x = current_x;
*y = best_row->y;
return 0;
}
#endif
static int
fast_find_string_pos (w, pos, object, hpos, vpos, x, y, right_p)
struct window *w;
int pos;
Lisp_Object object;
int *hpos, *vpos, *x, *y;
int right_p;
{
int yb = window_text_bottom_y (w);
struct glyph_row *r;
struct glyph *best_glyph = NULL;
struct glyph_row *best_row = NULL;
int best_x = 0;
for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
r->enabled_p && r->y < yb;
++r)
{
struct glyph *g = r->glyphs[TEXT_AREA];
struct glyph *e = g + r->used[TEXT_AREA];
int gx;
for (gx = r->x; g < e; gx += g->pixel_width, ++g)
if (EQ (g->object, object))
{
if (g->charpos == pos)
{
best_glyph = g;
best_x = gx;
best_row = r;
goto found;
}
else if (best_glyph == NULL
|| ((abs (g->charpos - pos)
< abs (best_glyph->charpos - pos))
&& (right_p
? g->charpos < pos
: g->charpos > pos)))
{
best_glyph = g;
best_x = gx;
best_row = r;
}
}
}
found:
if (best_glyph)
{
*x = best_x;
*hpos = best_glyph - best_row->glyphs[TEXT_AREA];
if (right_p)
{
*x += best_glyph->pixel_width;
++*hpos;
}
*y = best_row->y;
*vpos = best_row - w->current_matrix->rows;
}
return best_glyph != NULL;
}
static void
show_mouse_face (dpyinfo, draw)
struct x_display_info *dpyinfo;
enum draw_glyphs_face draw;
{
struct window *w = XWINDOW (dpyinfo->mouse_face_window);
struct frame *f = XFRAME (WINDOW_FRAME (w));
if (
w->current_matrix != NULL
&& dpyinfo->mouse_face_end_row < w->current_matrix->nrows)
{
int phys_cursor_on_p = w->phys_cursor_on_p;
struct glyph_row *row, *first, *last;
first = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
last = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
for (row = first; row <= last && row->enabled_p; ++row)
{
int start_hpos, end_hpos, start_x;
if (row == first)
{
start_hpos = dpyinfo->mouse_face_beg_col;
start_x = dpyinfo->mouse_face_beg_x;
}
else
{
start_hpos = 0;
start_x = 0;
}
if (row == last)
end_hpos = dpyinfo->mouse_face_end_col;
else
end_hpos = row->used[TEXT_AREA];
if (end_hpos > start_hpos)
{
x_draw_glyphs (w, start_x, row, TEXT_AREA,
start_hpos, end_hpos, draw, 0);
row->mouse_face_p = draw == DRAW_MOUSE_FACE || DRAW_IMAGE_RAISED;
}
}
if (phys_cursor_on_p && !w->phys_cursor_on_p)
x_display_cursor (w, 1,
w->phys_cursor.hpos, w->phys_cursor.vpos,
w->phys_cursor.x, w->phys_cursor.y);
}
if (draw == DRAW_NORMAL_TEXT)
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->text_cursor);
else if (draw == DRAW_MOUSE_FACE)
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->cross_cursor);
else
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->nontext_cursor);
}
static int
clear_mouse_face (dpyinfo)
struct x_display_info *dpyinfo;
{
int cleared = 0;
if (!NILP (dpyinfo->mouse_face_window))
{
show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
cleared = 1;
}
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_overlay = Qnil;
return cleared;
}
static void
x_clear_mouse_face (w)
struct window *w;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
Lisp_Object window;
BLOCK_INPUT;
XSETWINDOW (window, w);
if (EQ (window, dpyinfo->mouse_face_window))
clear_mouse_face (dpyinfo);
UNBLOCK_INPUT;
}
void
cancel_mouse_face (f)
FRAME_PTR f;
{
Lisp_Object window;
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
window = dpyinfo->mouse_face_window;
if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
{
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;
}
}
static int glyph_rect P_ ((struct frame *f, int, int, XRectangle *));
static int
glyph_rect (f, x, y, rect)
struct frame *f;
int x, y;
XRectangle *rect;
{
Lisp_Object window;
int part, found = 0;
window = window_from_coordinates (f, x, y, &part, 0);
if (!NILP (window))
{
struct window *w = XWINDOW (window);
struct glyph_row *r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
struct glyph_row *end = r + w->current_matrix->nrows - 1;
int area;
frame_to_window_pixel_xy (w, &x, &y);
for (; !found && r < end && r->enabled_p; ++r)
if (r->y >= y)
{
struct glyph *g = r->glyphs[TEXT_AREA];
struct glyph *end = g + r->used[TEXT_AREA];
int gx;
for (gx = r->x; !found && g < end; gx += g->pixel_width, ++g)
if (gx >= x)
{
rect->width = g->pixel_width;
rect->height = r->height;
rect->x = WINDOW_TO_FRAME_PIXEL_X (w, gx);
rect->y = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
found = 1;
}
}
}
return found;
}
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;
int count;
win = root;
count = 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 (FRAME_X_DISPLAY (*fp), count);
if (! f1)
{
struct scroll_bar *bar = x_window_to_scroll_bar (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)
{
int width, height, gx, gy;
XRectangle rect;
if (glyph_rect (f1, win_x, win_y, &rect))
last_mouse_glyph = rect;
else
{
width = FRAME_SMALLEST_CHAR_WIDTH (f1);
height = FRAME_SMALLEST_FONT_HEIGHT (f1);
gx = win_x;
gy = win_y;
if (gx < 0)
gx -= width - 1;
if (gy < 0)
gy -= height - 1;
gx = (gx + width - 1) / width * width;
gy = (gy + height - 1) / height * height;
last_mouse_glyph.width = width;
last_mouse_glyph.height = height;
last_mouse_glyph.x = gx;
last_mouse_glyph.y = gy;
}
*bar_window = Qnil;
*part = 0;
*fp = f1;
XSETINT (*x, win_x);
XSETINT (*y, win_y);
*time = last_mouse_movement_time;
}
}
}
UNBLOCK_INPUT;
}
#ifdef USE_X_TOOLKIT
static void
x_process_timeouts (timer)
struct atimer *timer;
{
if (toolkit_scroll_bar_interaction || popup_activated_flag)
{
BLOCK_INPUT;
while (XtAppPending (Xt_app_con) & XtIMTimer)
XtAppProcessEvent (Xt_app_con, XtIMTimer);
UNBLOCK_INPUT;
}
}
#endif
static struct scroll_bar *
x_window_to_scroll_bar (window_id)
Window window_id;
{
Lisp_Object tail;
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)
return XSCROLL_BAR (bar);
}
return 0;
}
#if defined USE_X_TOOLKIT && 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 XtActionHookId action_hook_id;
static Lisp_Object window_being_scrolled;
static int last_scroll_bar_part;
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);
XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
window_being_scrolled = Qnil;
last_scroll_bar_part = -1;
toolkit_scroll_bar_interaction = 0;
}
}
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;
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;
ievent->frame_or_window = window;
ievent->arg = Qnil;
ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
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_MIN 1
#define XM_SB_MAX 10000000
#define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
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;
double percent;
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;
int dragging_down_p = (INTEGERP (bar->dragging)
&& XINT (bar->dragging) <= cs->value);
BLOCK_INPUT;
XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
UNBLOCK_INPUT;
if (cs->value + slider_size == XM_SB_MAX
|| (dragging_down_p
&& last_scroll_bar_part == scroll_bar_down_arrow))
{
part = scroll_bar_down_arrow;
bar->dragging = Qnil;
}
else
{
whole = XM_SB_RANGE;
portion = min (cs->value - XM_SB_MIN, XM_SB_MAX - slider_size);
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
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 = (int) 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
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 = "verticalScrollBar";
unsigned long pixel;
BLOCK_INPUT;
#ifdef USE_MOTIF
XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
XtSetArg (av[ac], XmNminimum, XM_SB_MIN); ++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;
}
widget = XtCreateWidget (scroll_bar_name, scrollbarWidgetClass,
f->output_data.x->edit_widget, av, ac);
{
char *initial = "";
char *val = initial;
XtVaGetValues (widget, XtNscrollVCursor, (XtPointer) &val,
XtNpickTop, (XtPointer) &xaw3d_pick_top, NULL);
if (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;
}
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;
if (whole == 0)
top = 0, shown = 1;
else
{
top = (float) position / whole;
shown = (float) portion / whole;
}
BLOCK_INPUT;
#ifdef USE_MOTIF
{
int size, value;
XmScrollBarWidget sb;
size = shown * XM_SB_RANGE;
size = min (size, XM_SB_RANGE);
size = max (size, 1);
value = top * XM_SB_RANGE;
value = min (value, XM_SB_MAX - size);
value = max (value, XM_SB_MIN);
if (NILP (bar->dragging))
XmScrollBarSetValues (widget, value, size, 0, 0, False);
else if (last_scroll_bar_part == scroll_bar_down_arrow)
XmScrollBarSetValues (widget, value, XM_SB_RANGE - value, 0, 0, False);
else
{
int old_value, old_size, increment, page_increment;
XmScrollBarGetValues (widget, &old_value, &old_size,
&increment, &page_increment);
XmScrollBarSetValues (widget, old_value,
min (size, XM_SB_RANGE - old_value),
0, 0, False);
}
}
#else
{
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
{
#ifdef HAVE_XAW3D
ScrollbarWidget sb = (ScrollbarWidget) widget;
int scroll_mode = 0;
if (xaw3d_arrow_scroll)
{
scroll_mode = sb->scrollbar.scroll_mode;
if (scroll_mode == 2)
sb->scrollbar.scroll_mode = 0;
}
#endif
if (!xaw3d_pick_top)
shown = min (shown, old_shown);
XawScrollbarSetThumb (widget, top, shown);
#ifdef HAVE_XAW3D
if (xaw3d_arrow_scroll && scroll_mode == 2)
sb->scrollbar.scroll_mode = scroll_mode;
#endif
}
}
}
#endif
UNBLOCK_INPUT;
}
#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
{
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);
}
#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
XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar));
#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_x, window_y, window_width, window_height;
window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
top = window_y;
width = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
height = window_height;
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
left = XINT (w->left) + XINT (w->width) - FRAME_SCROLL_BAR_COLS (f);
else
left = XFASTINT (w->left);
left *= CANON_X_UNIT (f);
left += FRAME_INTERNAL_BORDER_WIDTH (f);
if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0)
sb_width = FRAME_SCROLL_BAR_PIXEL_WIDTH (f);
else
sb_width = width;
#ifdef USE_TOOLKIT_SCROLL_BARS
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
sb_left = left + width - sb_width - (width - sb_width) / 2;
else
sb_left = left + (width - sb_width) / 2;
#else
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
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 (width > 0 && height > 0)
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
left, top, width, height, False);
if (mask)
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);
#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 = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
int rest = area_width - sb_width;
if (rest > 0 && height > 0)
{
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
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;
}
}
static void
x_scroll_bar_expose (bar, event)
struct scroll_bar *bar;
XEvent *event;
{
#ifndef USE_TOOLKIT_SCROLL_BARS
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);
XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,
0, 0,
XINT (bar->width) - 1 - width_trim - width_trim,
XINT (bar->height) - 1);
UNBLOCK_INPUT;
#endif
}
#ifndef USE_TOOLKIT_SCROLL_BARS
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;
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
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;
}
#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);
}
}
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
}
int
process_expose_from_menu (event)
XEvent event;
{
FRAME_PTR f;
struct x_display_info *dpyinfo;
int frame_exposed_p = 0;
BLOCK_INPUT;
dpyinfo = x_display_info_for_display (event.xexpose.display);
f = x_window_to_frame (dpyinfo, event.xexpose.window);
if (f)
{
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 (x_window_to_frame (dpyinfo, event.xexpose.window),
event.xexpose.x, event.xexpose.y,
event.xexpose.width, event.xexpose.height);
frame_exposed_p = 1;
}
}
else
{
struct scroll_bar *bar
= x_window_to_scroll_bar (event.xexpose.window);
if (bar)
x_scroll_bar_expose (bar, &event);
}
UNBLOCK_INPUT;
return frame_exposed_p;
}
struct selection_event_queue
{
XEvent event;
struct selection_event_queue *next;
};
static struct selection_event_queue *queue;
static int x_queue_selection_requests;
static void
x_queue_event (f, event)
FRAME_PTR f;
XEvent *event;
{
struct selection_event_queue *queue_tmp
= (struct selection_event_queue *) xmalloc (sizeof (struct selection_event_queue));
if (queue_tmp != NULL)
{
queue_tmp->event = *event;
queue_tmp->next = queue;
queue = queue_tmp;
}
}
static void
x_unqueue_events (display)
Display *display;
{
while (queue != NULL)
{
struct selection_event_queue *queue_tmp = queue;
XPutBackEvent (display, &queue_tmp->event);
queue = queue_tmp->next;
xfree ((char *)queue_tmp);
}
}
void
x_start_queuing_selection_requests (display)
Display *display;
{
x_queue_selection_requests++;
}
void
x_stop_queuing_selection_requests (display)
Display *display;
{
x_queue_selection_requests--;
x_unqueue_events (display);
}
static Time enter_timestamp;
static XComposeStatus compose_status;
static int temp_index;
static short temp_buffer[100];
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); \
if (numchars >= 1) \
{ \
bufp->kind = menu_bar_activate_event; \
XSETFRAME (bufp->frame_or_window, f); \
bufp->arg = Qnil; \
bufp++; \
count++; \
numchars--; \
} \
} \
while (0)
#define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
#define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
int
XTread_socket (sd, bufp, numchars, expected)
register int sd;
struct input_event *bufp;
int numchars;
int expected;
{
int count = 0;
int nbytes = 0;
XEvent event;
struct frame *f;
int event_found = 0;
struct x_display_info *dpyinfo;
struct coding_system coding;
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
return -1;
}
interrupt_input_pending = 0;
BLOCK_INPUT;
input_signal_count++;
if (numchars <= 0)
abort ();
++handling_signal;
setup_coding_system (Vlocale_coding_system, &coding);
coding.src_multibyte = 0;
coding.dst_multibyte = 1;
coding.composing = COMPOSITION_DISABLED;
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);
}
while (XPending (dpyinfo->display))
{
XNextEvent (dpyinfo->display, &event);
#ifdef HAVE_X_I18N
{
struct frame *f1 = x_any_window_to_frame (dpyinfo,
event.xclient.window);
if (XFilterEvent (&event, f1 ? FRAME_X_WINDOW (f1) : None))
break;
}
#endif
event_found = 1;
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;
int count = x_catch_errors (d);
XSetInputFocus (d, event.xclient.window,
RevertToParent,
event.xclient.data.l[1]);
XSync (d, False);
x_uncatch_errors (d, count);
}
#endif
}
else if (event.xclient.data.l[0]
== dpyinfo->Xatom_wm_save_yourself)
{
if (numchars > 0)
{
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);
}
}
else if (event.xclient.data.l[0]
== dpyinfo->Xatom_wm_delete_window)
{
struct frame *f
= x_any_window_to_frame (dpyinfo,
event.xclient.window);
if (f)
{
if (numchars == 0)
abort ();
bufp->kind = delete_window_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp++;
count += 1;
numchars -= 1;
}
}
}
else if (event.xclient.message_type
== dpyinfo->Xatom_wm_configure_denied)
{
}
else if (event.xclient.message_type
== dpyinfo->Xatom_wm_window_moved)
{
int new_x, new_y;
struct frame *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->output_data.x->left_pos = new_x;
f->output_data.x->top_pos = new_y;
}
}
#ifdef HACK_EDITRES
else if (event.xclient.message_type
== dpyinfo->Xatom_editres)
{
struct frame *f
= x_any_window_to_frame (dpyinfo, event.xclient.window);
_XEditResCheckMessages (f->output_data.x->widget, NULL,
&event, NULL);
}
#endif
else if ((event.xclient.message_type
== dpyinfo->Xatom_DONE)
|| (event.xclient.message_type
== dpyinfo->Xatom_PAGE))
{
Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
struct frame *f
= x_window_to_frame (dpyinfo, event.xclient.window);
x_kill_gs_process (pixmap, f);
expose_frame (f, 0, 0, 0, 0);
}
#ifdef USE_TOOLKIT_SCROLL_BARS
else if (event.xclient.message_type
== dpyinfo->Xatom_Scrollbar)
{
x_scroll_bar_to_input_event (&event, bufp);
++bufp, ++count, --numchars;
goto out;
}
#endif
else
goto OTHER;
}
break;
case SelectionNotify:
#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:
#ifdef USE_X_TOOLKIT
if (! x_window_to_frame (dpyinfo, event.xselectionclear.window))
goto OTHER;
#endif
{
XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
if (numchars == 0)
abort ();
bufp->kind = selection_clear_event;
SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
SELECTION_EVENT_TIME (bufp) = eventp->time;
bufp->frame_or_window = Qnil;
bufp->arg = Qnil;
bufp++;
count += 1;
numchars -= 1;
}
break;
case SelectionRequest:
#ifdef USE_X_TOOLKIT
if (!x_window_to_frame (dpyinfo, event.xselectionrequest.owner))
goto OTHER;
#endif
if (x_queue_selection_requests)
x_queue_event (x_window_to_frame (dpyinfo, event.xselectionrequest.owner),
&event);
else
{
XSelectionRequestEvent *eventp
= (XSelectionRequestEvent *) &event;
if (numchars == 0)
abort ();
bufp->kind = selection_request_event;
SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
SELECTION_EVENT_REQUESTOR (bufp) = eventp->requestor;
SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
SELECTION_EVENT_TARGET (bufp) = eventp->target;
SELECTION_EVENT_PROPERTY (bufp) = eventp->property;
SELECTION_EVENT_TIME (bufp) = eventp->time;
bufp->frame_or_window = Qnil;
bufp->arg = Qnil;
bufp++;
count += 1;
numchars -= 1;
}
break;
case PropertyNotify:
#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->output_data.x->left_pos = x;
f->output_data.x->top_pos = y;
}
break;
case Expose:
f = x_window_to_frame (dpyinfo, event.xexpose.window);
if (f)
{
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 (x_window_to_frame (dpyinfo,
event.xexpose.window),
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_X_TOOLKIT && 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.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;
bufp->kind = iconify_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp++;
count++;
numchars--;
}
}
goto OTHER;
case MapNotify:
if (event.xmap.window == tip_window)
goto OTHER;
f = x_top_window_to_frame (dpyinfo, event.xmap.window);
if (f)
{
f->async_visible = 1;
f->async_iconified = 0;
f->output_data.x->has_been_visible = 1;
SET_FRAME_GARBAGED (f);
if (f->iconified)
{
bufp->kind = deiconify_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp++;
count++;
numchars--;
}
else if (! NILP (Vframe_list)
&& ! NILP (XCDR (Vframe_list)))
record_asynch_buffer_change ();
}
goto OTHER;
case KeyPress:
f = x_any_window_to_frame (dpyinfo, event.xkey.window);
#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;
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;
nbytes = XmbLookupString (FRAME_XIC (f),
&event.xkey, copy_bufptr,
copy_bufsiz, &keysym,
&status_return);
if (status_return == XBufferOverflow)
{
copy_bufsiz = nbytes + 1;
copy_bufptr = (char *) alloca (copy_bufsiz);
nbytes = XmbLookupString (FRAME_XIC (f),
&event.xkey, copy_bufptr,
copy_bufsiz, &keysym,
&status_return);
}
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
orig_keysym = keysym;
if (numchars > 1)
{
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
|| (keysym >= XK_Kanji && keysym <= XK_Eisu_toggle)
|| 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)))
&& ! (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 (temp_index == sizeof temp_buffer / sizeof (short))
temp_index = 0;
temp_buffer[temp_index++] = keysym;
bufp->kind = non_ascii_keystroke;
bufp->code = keysym;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp->modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
count++;
numchars--;
}
else if (numchars > nbytes)
{
register int i;
register int c;
int nchars, len;
for (i = 0; i < nbytes; i++)
{
if (temp_index == (sizeof temp_buffer
/ sizeof (short)))
temp_index = 0;
temp_buffer[temp_index++] = copy_bufptr[i];
}
if (
event.xkey.keycode != 0
|| coding.type == coding_type_raw_text
|| coding.type == coding_type_no_conversion)
{
nchars = nbytes;
}
else
{
int require;
unsigned char *p;
require = decoding_buffer_size (&coding, nbytes);
p = (unsigned char *) alloca (require);
coding.mode |= CODING_MODE_LAST_BLOCK;
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);
bufp->kind = (SINGLE_BYTE_CHAR_P (c)
? ascii_keystroke
: multibyte_char_keystroke);
bufp->code = c;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp->modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
}
count += nchars;
numchars -= nchars;
if (keysym == NoSymbol)
break;
}
else
abort ();
}
else
abort ();
}
#ifdef HAVE_X_I18N
break;
#else
goto OTHER;
#endif
case KeyRelease:
#ifdef HAVE_X_I18N
break;
#else
goto OTHER;
#endif
case EnterNotify:
{
f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
#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);
goto OTHER;
}
case FocusIn:
f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
if (event.xfocus.detail != NotifyPointer)
dpyinfo->x_focus_event_frame = f;
if (f)
{
x_new_focus_frame (dpyinfo, f);
if (GC_NILP (Vterminal_frame)
&& GC_CONSP (Vframe_list)
&& !GC_NILP (XCDR (Vframe_list)))
{
bufp->kind = FOCUS_IN_EVENT;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
++bufp, ++count, --numchars;
}
}
#ifdef HAVE_X_I18N
if (f && FRAME_XIC (f))
XSetICFocus (FRAME_XIC (f));
#endif
goto OTHER;
case LeaveNotify:
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)
{
Lisp_Object frame;
int n;
XSETFRAME (frame, f);
help_echo = Qnil;
n = gen_help_event (bufp, numchars,
Qnil, frame, Qnil, Qnil, 0);
bufp += n, count += n, numchars -= n;
}
#if 0
if (event.xcrossing.focus)
x_mouse_leave (dpyinfo);
else
{
if (f == dpyinfo->x_focus_event_frame)
dpyinfo->x_focus_event_frame = 0;
if (f == dpyinfo->x_focus_frame)
x_new_focus_frame (dpyinfo, 0);
}
#endif
}
goto OTHER;
case FocusOut:
f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
if (event.xfocus.detail != NotifyPointer
&& f == dpyinfo->x_focus_event_frame)
dpyinfo->x_focus_event_frame = 0;
if (f && f == dpyinfo->x_focus_frame)
x_new_focus_frame (dpyinfo, 0);
#ifdef HAVE_X_I18N
if (f && FRAME_XIC (f))
XUnsetICFocus (FRAME_XIC (f));
#endif
goto OTHER;
case MotionNotify:
{
previous_help_echo = help_echo;
help_echo = help_echo_object = help_echo_window = Qnil;
help_echo_pos = -1;
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 (f)
note_mouse_movement (f, &event.xmotion);
else
{
#ifndef USE_TOOLKIT_SCROLL_BARS
struct scroll_bar *bar
= x_window_to_scroll_bar (event.xmotion.window);
if (bar)
x_scroll_bar_note_movement (bar, &event);
#endif
clear_mouse_face (dpyinfo);
}
if (!NILP (help_echo)
|| !NILP (previous_help_echo))
{
Lisp_Object frame;
int n;
if (f)
XSETFRAME (frame, f);
else
frame = Qnil;
any_help_event_p = 1;
n = gen_help_event (bufp, numchars, help_echo, frame,
help_echo_window, help_echo_object,
help_echo_pos);
bufp += n, count += n, numchars -= n;
}
goto OTHER;
}
case ConfigureNotify:
f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
if (f)
{
#ifndef USE_X_TOOLKIT
int rows = PIXEL_TO_CHAR_HEIGHT (f, event.xconfigure.height);
int columns = PIXEL_TO_CHAR_WIDTH (f, event.xconfigure.width);
if (columns != f->width
|| rows != f->height
|| event.xconfigure.width != f->output_data.x->pixel_width
|| event.xconfigure.height != f->output_data.x->pixel_height)
{
change_frame_size (f, rows, columns, 0, 1, 0);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
}
#endif
f->output_data.x->pixel_width = event.xconfigure.width;
f->output_data.x->pixel_height = event.xconfigure.height;
x_real_positions (f, &f->output_data.x->left_pos,
&f->output_data.x->top_pos);
#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->output_data.x->win_gravity = NorthWestGravity;
x_wm_set_size_hint (f, (long) 0, 0);
}
#ifdef USE_MOTIF
if (event.xconfigure.x == 0 && event.xconfigure.y == 0)
{
event.xconfigure.x = f->output_data.x->widget->core.x;
event.xconfigure.y = f->output_data.x->widget->core.y;
}
#endif
}
goto OTHER;
case ButtonPress:
case ButtonRelease:
{
struct input_event emacs_event;
int tool_bar_p = 0;
emacs_event.kind = no_event;
bzero (&compose_status, sizeof (compose_status));
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)
&& XFASTINT (XWINDOW (f->tool_bar_window)->height))
{
Lisp_Object window;
int p, x, y;
x = event.xbutton.x;
y = event.xbutton.y;
window = window_from_coordinates (f, x, y, &p, 1);
if (EQ (window, f->tool_bar_window))
{
x_handle_tool_bar_click (f, &event.xbutton);
tool_bar_p = 1;
}
}
if (!tool_bar_p)
if (!dpyinfo->x_focus_frame
|| f == dpyinfo->x_focus_frame)
construct_mouse_click (&emacs_event, &event, f);
}
else
{
#ifndef USE_TOOLKIT_SCROLL_BARS
struct scroll_bar *bar
= x_window_to_scroll_bar (event.xbutton.window);
if (bar)
x_scroll_bar_handle_click (bar, &event, &emacs_event);
#endif
}
if (event.type == ButtonPress)
{
dpyinfo->grabbed |= (1 << event.xbutton.button);
last_mouse_frame = f;
if (f != 0)
f->mouse_moved = 0;
if (!tool_bar_p)
last_tool_bar_item = -1;
}
else
{
dpyinfo->grabbed &= ~(1 << event.xbutton.button);
}
if (numchars >= 1 && emacs_event.kind != no_event)
{
bcopy (&emacs_event, bufp, sizeof (struct input_event));
bufp++;
count++;
numchars--;
}
#ifdef USE_X_TOOLKIT
f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
if (f && event.type == ButtonPress
&& event.xbutton.x >= 0
&& event.xbutton.x < f->output_data.x->pixel_width
&& 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);
}
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;
XtDispatchEvent (&event);
UNBLOCK_INPUT;
#endif
break;
}
}
}
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;
}
UNBLOCK_INPUT;
--handling_signal;
return count;
}
static void
notice_overwritten_cursor (w, start_x, end_x)
struct window *w;
int start_x, end_x;
{
if (updated_area == TEXT_AREA
&& w->phys_cursor_on_p
&& output_cursor.vpos == w->phys_cursor.vpos
&& start_x <= w->phys_cursor.x
&& (end_x < 0 || end_x > w->phys_cursor.x))
w->phys_cursor_on_p = 0;
}
static void
x_clip_to_row (w, row, gc, whole_line_p)
struct window *w;
struct glyph_row *row;
GC gc;
int whole_line_p;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
XRectangle clip_rect;
int window_x, window_y, window_width, window_height;
window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
clip_rect.x = WINDOW_TO_FRAME_PIXEL_X (w, 0);
clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
clip_rect.y = max (clip_rect.y, window_y);
clip_rect.width = window_width;
clip_rect.height = row->visible_height;
if (whole_line_p)
{
clip_rect.x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
clip_rect.width += FRAME_X_FLAGS_AREA_WIDTH (f);
}
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;
x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
y = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
+ row->ascent - w->phys_cursor_ascent);
h = row->height - 1;
cursor_glyph = get_phys_cursor_glyph (w);
if (cursor_glyph == NULL)
return;
wd = cursor_glyph->pixel_width - 1;
if (cursor_glyph->type == STRETCH_GLYPH
&& !x_stretch_cursor_p)
wd = min (CANON_X_UNIT (f), wd);
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, gc, 0);
XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h);
XSetClipMask (dpy, gc, None);
}
static void
x_draw_bar_cursor (w, row, width)
struct window *w;
struct glyph_row *row;
int width;
{
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);
x_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 = f->output_data.x->cursor_width;
width = min (cursor_glyph->pixel_width, width);
x_clip_to_row (w, row, gc, 0);
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);
XSetClipMask (dpy, gc, None);
}
}
static void
x_clear_cursor (w)
struct window *w;
{
if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
x_update_window_cursor (w, 0);
}
static void
x_draw_phys_cursor_glyph (w, row, hl)
struct window *w;
struct glyph_row *row;
enum draw_glyphs_face hl;
{
if (w->phys_cursor.hpos < row->used[TEXT_AREA])
{
int on_p = w->phys_cursor_on_p;
x_draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
hl, 0);
w->phys_cursor_on_p = on_p;
if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
{
if (row > w->current_matrix->rows
&& MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
x_fix_overlapping_area (w, row - 1, TEXT_AREA);
if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
&& MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
x_fix_overlapping_area (w, row + 1, TEXT_AREA);
}
}
}
static void
x_erase_phys_cursor (w)
struct window *w;
{
struct frame *f = XFRAME (w->frame);
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
int hpos = w->phys_cursor.hpos;
int vpos = w->phys_cursor.vpos;
int mouse_face_here_p = 0;
struct glyph_matrix *active_glyphs = w->current_matrix;
struct glyph_row *cursor_row;
struct glyph *cursor_glyph;
enum draw_glyphs_face hl;
if (w->phys_cursor_type == NO_CURSOR)
goto mark_cursor_off;
if (vpos >= active_glyphs->nrows)
goto mark_cursor_off;
cursor_row = MATRIX_ROW (active_glyphs, vpos);
if (!cursor_row->enabled_p)
goto mark_cursor_off;
if (cursor_row->visible_height <= 0)
goto mark_cursor_off;
if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
goto mark_cursor_off;
if (! NILP (dpyinfo->mouse_face_window)
&& w == XWINDOW (dpyinfo->mouse_face_window)
&& (vpos > dpyinfo->mouse_face_beg_row
|| (vpos == dpyinfo->mouse_face_beg_row
&& hpos >= dpyinfo->mouse_face_beg_col))
&& (vpos < dpyinfo->mouse_face_end_row
|| (vpos == dpyinfo->mouse_face_end_row
&& hpos < dpyinfo->mouse_face_end_col))
&& cursor_row->used[TEXT_AREA] > hpos)
mouse_face_here_p = 1;
if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
{
int x;
int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
cursor_glyph = get_phys_cursor_glyph (w);
if (cursor_glyph == NULL)
goto mark_cursor_off;
x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
x,
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
cursor_row->y)),
cursor_glyph->pixel_width,
cursor_row->visible_height,
False);
}
if (mouse_face_here_p)
hl = DRAW_MOUSE_FACE;
else if (cursor_row->inverse_p)
hl = DRAW_INVERSE_VIDEO;
else
hl = DRAW_NORMAL_TEXT;
x_draw_phys_cursor_glyph (w, cursor_row, hl);
mark_cursor_off:
w->phys_cursor_on_p = 0;
w->phys_cursor_type = NO_CURSOR;
}
static int
cursor_in_mouse_face_p (w)
struct window *w;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
int in_mouse_face = 0;
if (WINDOWP (dpyinfo->mouse_face_window)
&& XWINDOW (dpyinfo->mouse_face_window) == w)
{
int hpos = w->phys_cursor.hpos;
int vpos = w->phys_cursor.vpos;
if (vpos >= dpyinfo->mouse_face_beg_row
&& vpos <= dpyinfo->mouse_face_end_row
&& (vpos > dpyinfo->mouse_face_beg_row
|| hpos >= dpyinfo->mouse_face_beg_col)
&& (vpos < dpyinfo->mouse_face_end_row
|| hpos < dpyinfo->mouse_face_end_col
|| dpyinfo->mouse_face_past_end))
in_mouse_face = 1;
}
return in_mouse_face;
}
void
x_display_and_set_cursor (w, on, hpos, vpos, x, y)
struct window *w;
int on, hpos, vpos, x, y;
{
struct frame *f = XFRAME (w->frame);
int new_cursor_type;
int new_cursor_width;
struct glyph_matrix *current_glyphs;
struct glyph_row *glyph_row;
struct glyph *glyph;
if (! FRAME_VISIBLE_P (f)
|| FRAME_GARBAGED_P (f)
|| vpos >= w->current_matrix->nrows
|| hpos >= w->current_matrix->matrix_w)
return;
if (!on && !w->phys_cursor_on_p)
return;
current_glyphs = w->current_matrix;
glyph_row = MATRIX_ROW (current_glyphs, vpos);
glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
if (!glyph_row->enabled_p)
{
w->phys_cursor_on_p = 0;
return;
}
xassert (interrupt_input_blocked);
new_cursor_width = -1;
if (cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f)
&& EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
{
if (w == XWINDOW (echo_area_window))
new_cursor_type = FRAME_DESIRED_CURSOR (f);
else if (cursor_in_non_selected_windows)
new_cursor_type = HOLLOW_BOX_CURSOR;
else
new_cursor_type = NO_CURSOR;
}
else
{
if (f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
|| w != XWINDOW (f->selected_window))
{
extern int cursor_in_non_selected_windows;
if ((MINI_WINDOW_P (w) && minibuf_level == 0)
|| !cursor_in_non_selected_windows
|| NILP (XBUFFER (w->buffer)->cursor_type))
new_cursor_type = NO_CURSOR;
else
new_cursor_type = HOLLOW_BOX_CURSOR;
}
else if (w->cursor_off_p)
new_cursor_type = NO_CURSOR;
else
{
struct buffer *b = XBUFFER (w->buffer);
if (EQ (b->cursor_type, Qt))
new_cursor_type = FRAME_DESIRED_CURSOR (f);
else
new_cursor_type = x_specified_cursor_type (b->cursor_type,
&new_cursor_width);
}
}
if (w->phys_cursor_on_p
&& (!on
|| w->phys_cursor.x != x
|| w->phys_cursor.y != y
|| new_cursor_type != w->phys_cursor_type))
x_erase_phys_cursor (w);
if (on && !w->phys_cursor_on_p)
{
w->phys_cursor_ascent = glyph_row->ascent;
w->phys_cursor_height = glyph_row->height;
w->phys_cursor.x = x;
w->phys_cursor.y = glyph_row->y;
w->phys_cursor.hpos = hpos;
w->phys_cursor.vpos = vpos;
w->phys_cursor_type = new_cursor_type;
w->phys_cursor_on_p = 1;
switch (new_cursor_type)
{
case HOLLOW_BOX_CURSOR:
x_draw_hollow_cursor (w, glyph_row);
break;
case FILLED_BOX_CURSOR:
x_draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
break;
case BAR_CURSOR:
x_draw_bar_cursor (w, glyph_row, new_cursor_width);
break;
case NO_CURSOR:
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
}
void
x_display_cursor (w, on, hpos, vpos, x, y)
struct window *w;
int on, hpos, vpos, x, y;
{
BLOCK_INPUT;
x_display_and_set_cursor (w, on, hpos, vpos, x, y);
UNBLOCK_INPUT;
}
void
x_update_cursor (f, on_p)
struct frame *f;
{
x_update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
}
static void
x_update_cursor_in_window_tree (w, on_p)
struct window *w;
int on_p;
{
while (w)
{
if (!NILP (w->hchild))
x_update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
else if (!NILP (w->vchild))
x_update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
else
x_update_window_cursor (w, on_p);
w = NILP (w->next) ? 0 : XWINDOW (w->next);
}
}
static void
x_update_window_cursor (w, on)
struct window *w;
int on;
{
if (w->current_matrix)
{
BLOCK_INPUT;
x_display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
w->phys_cursor.x, w->phys_cursor.y);
UNBLOCK_INPUT;
}
}
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))
bitmap_id = x_create_bitmap_from_file (f, file);
else
{
if (FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id
= x_create_bitmap_from_data (f, gnu_bits,
gnu_width, gnu_height);
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);
#ifdef USE_X_TOOLKIT
XSetWMIconName (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
&text);
#else
XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &text);
#endif
}
#else
XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_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
static Lisp_Object x_error_message_string;
static void
x_error_catcher (display, error)
Display *display;
XErrorEvent *error;
{
XGetErrorText (display, error->error_code,
XSTRING (x_error_message_string)->data,
X_ERROR_MESSAGE_SIZE);
}
void x_check_errors ();
static Lisp_Object x_catch_errors_unwind ();
int
x_catch_errors (dpy)
Display *dpy;
{
int count = specpdl_ptr - specpdl;
XSync (dpy, False);
record_unwind_protect (x_catch_errors_unwind, x_error_message_string);
x_error_message_string = make_uninit_string (X_ERROR_MESSAGE_SIZE);
XSTRING (x_error_message_string)->data[0] = 0;
return count;
}
static Lisp_Object
x_catch_errors_unwind (old_val)
Lisp_Object old_val;
{
x_error_message_string = old_val;
return Qnil;
}
void
x_check_errors (dpy, format)
Display *dpy;
char *format;
{
XSync (dpy, False);
if (XSTRING (x_error_message_string)->data[0])
error (format, XSTRING (x_error_message_string)->data);
}
int
x_had_errors_p (dpy)
Display *dpy;
{
XSync (dpy, False);
return XSTRING (x_error_message_string)->data[0] != 0;
}
void
x_clear_errors (dpy)
Display *dpy;
{
XSTRING (x_error_message_string)->data[0] = 0;
}
void
x_uncatch_errors (dpy, count)
Display *dpy;
int count;
{
unbind_to (count, Qnil);
}
#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 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;
int count;
char *msg;
msg = (char *) alloca (strlen (error_message) + 1);
strcpy (msg, error_message);
handling_signal = 0;
count = x_catch_errors (dpy);
#ifdef USE_X_TOOLKIT
if (dpyinfo)
XtCloseDisplay (dpy);
#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 (dpy, count);
if (x_display_list == 0)
{
fprintf (stderr, "%s\n", 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", msg);
}
static void
x_error_quitter (display, error)
Display *display;
XErrorEvent *error;
{
char buf[256], buf1[356];
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_error_handler (display, error)
Display *display;
XErrorEvent *error;
{
if (! NILP (x_error_message_string))
x_error_catcher (display, error);
else
x_error_quitter (display, error);
return 0;
}
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;
f->output_data.x->font = (XFontStruct *) (fontp->font);
f->output_data.x->baseline_offset = fontp->baseline_offset;
f->output_data.x->fontset = -1;
if (f->scroll_bar_pixel_width > 0)
{
int wid = FONT_WIDTH (f->output_data.x->font);
f->scroll_bar_cols = (f->scroll_bar_pixel_width + wid-1) / wid;
}
else
{
int wid = FONT_WIDTH (f->output_data.x->font);
f->scroll_bar_cols = (14 + wid - 1) / wid;
}
if (FRAME_X_WINDOW (f) != 0)
{
XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
f->output_data.x->font->fid);
XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc,
f->output_data.x->font->fid);
XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc,
f->output_data.x->font->fid);
frame_update_line_height (f);
if (NILP (tip_frame) || XFRAME (tip_frame) != f)
x_set_window_size (f, 0, f->width, f->height);
}
else
f->output_data.x->line_height = FONT_HEIGHT (f->output_data.x->font);
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 (f->output_data.x->fontset == fontset)
return fontset_name (fontset);
result = x_new_font (f, (XSTRING (fontset_ascii (fontset))->data));
if (!STRINGP (result))
return Qnil;
f->output_data.x->fontset = fontset;
#ifdef HAVE_X_I18N
if (FRAME_XIC (f)
&& (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
xic_set_xfontset (f, XSTRING (fontset_ascii (fontset))->data);
#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;
if (FRAME_XIC_FONTSET (f))
{
XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
FRAME_XIC_FONTSET (f) = NULL;
}
}
}
dpyinfo->xim = NULL;
XFree (dpyinfo->xim_styles);
UNBLOCK_INPUT;
}
#endif
static void
xim_open_dpy (dpyinfo, resource_name)
struct x_display_info *dpyinfo;
char *resource_name;
{
#ifdef USE_XIM
XIM 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
dpyinfo->xim = NULL;
#endif
}
#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 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,
(XPointer) xim_inst);
#else
dpyinfo->xim = NULL;
xim_open_dpy (dpyinfo, resource_name);
#endif
#else
dpyinfo->xim = NULL;
#endif
}
static void
xim_close_dpy (dpyinfo)
struct x_display_info *dpyinfo;
{
#ifdef 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;
{
Window child;
int win_x = 0, win_y = 0;
int flags = f->output_data.x->size_hint_flags;
int this_window;
if (! ((flags & XNegative) || (flags & YNegative)))
return;
#ifdef USE_X_TOOLKIT
this_window = XtWindow (f->output_data.x->widget);
#else
this_window = FRAME_X_WINDOW (f);
#endif
if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
{
int count;
BLOCK_INPUT;
count = x_catch_errors (FRAME_X_DISPLAY (f));
while (1)
{
x_clear_errors (FRAME_X_DISPLAY (f));
XTranslateCoordinates (FRAME_X_DISPLAY (f),
this_window,
f->output_data.x->parent_desc,
0, 0, &win_x, &win_y,
&child);
if (x_had_errors_p (FRAME_X_DISPLAY (f)))
{
Window newroot, newparent = 0xdeadbeef;
Window *newchildren;
unsigned int nchildren;
if (! XQueryTree (FRAME_X_DISPLAY (f), this_window, &newroot,
&newparent, &newchildren, &nchildren))
break;
XFree ((char *) newchildren);
f->output_data.x->parent_desc = newparent;
}
else
break;
}
x_uncatch_errors (FRAME_X_DISPLAY (f), count);
UNBLOCK_INPUT;
}
if (flags & XNegative)
f->output_data.x->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
- 2 * f->output_data.x->border_width - win_x
- PIXEL_WIDTH (f)
+ f->output_data.x->left_pos);
{
int height = 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->output_data.x->top_pos = (FRAME_X_DISPLAY_INFO (f)->height
- 2 * f->output_data.x->border_width
- win_y
- height
+ f->output_data.x->top_pos);
}
f->output_data.x->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)
{
f->output_data.x->top_pos = yoff;
f->output_data.x->left_pos = xoff;
f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
if (xoff < 0)
f->output_data.x->size_hint_flags |= XNegative;
if (yoff < 0)
f->output_data.x->size_hint_flags |= YNegative;
f->output_data.x->win_gravity = NorthWestGravity;
}
x_calc_absolute_position (f);
BLOCK_INPUT;
x_wm_set_size_hint (f, (long) 0, 0);
modified_left = f->output_data.x->left_pos;
modified_top = f->output_data.x->top_pos;
#if 0
if (change_gravity != 0)
{
modified_left += f->output_data.x->border_width;
modified_top += f->output_data.x->border_width;
}
#endif
#ifdef USE_X_TOOLKIT
XMoveWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
modified_left, modified_top);
#else
XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
modified_left, modified_top);
#endif
UNBLOCK_INPUT;
}
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->output_data.x->vertical_scroll_bar_extra
= (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
? 0
: FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0
? FRAME_SCROLL_BAR_PIXEL_WIDTH (f)
: (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.x->font)));
f->output_data.x->flags_areas_extra
= FRAME_FLAGS_AREA_WIDTH (f);
pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);
f->output_data.x->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);
PIXEL_WIDTH (f) = pixelwidth;
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_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 = CHAR_TO_PIXEL_COL (f, x) + FONT_WIDTH (f->output_data.x->font) / 2;
pix_y = CHAR_TO_PIXEL_ROW (f, y) + f->output_data.x->line_height / 2;
if (pix_x < 0) pix_x = 0;
if (pix_x > PIXEL_WIDTH (f)) pix_x = PIXEL_WIDTH (f);
if (pix_y < 0) pix_y = 0;
if (pix_y > PIXEL_HEIGHT (f)) pix_y = 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;
{
if (f->async_visible)
{
BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
XRaiseWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
#else
XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
}
void
x_lower_frame (f)
struct frame *f;
{
if (f->async_visible)
{
BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
XLowerWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
#else
XLowerWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
XFlush (FRAME_X_DISPLAY (f));
UNBLOCK_INPUT;
}
}
static void
XTframe_raise_lower (f, raise_flag)
FRAME_PTR f;
int raise_flag;
{
if (raise_flag)
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->output_data.x->left_pos, f->output_data.x->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
XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#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->output_data.x->left_pos;
original_top = f->output_data.x->top_pos;
UNBLOCK_INPUT;
if (! FRAME_VISIBLE_P (f) && ! FRAME_ICONIFIED_P (f)
&& f->output_data.x->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;
#ifdef USE_X_TOOLKIT
window = XtWindow (f->output_data.x->widget);
#else
window = FRAME_X_WINDOW (f);
#endif
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 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_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->output_data.x->left_pos, f->output_data.x->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
if (FRAME_X_WINDOW (f))
XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#ifdef USE_X_TOOLKIT
if (f->output_data.x->widget)
{
XtDestroyWidget (f->output_data.x->widget);
f->output_data.x->widget = NULL;
}
free_frame_menubar (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);
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--;
}
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;
Window window = XtWindow (f->output_data.x->widget);
#else
Window window = FRAME_X_WINDOW (f);
#endif
size_hints.flags = PResizeInc | PMinSize ;
size_hints.x = f->output_data.x->left_pos;
size_hints.y = f->output_data.x->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 = PIXEL_HEIGHT (f);
size_hints.width = PIXEL_WIDTH (f);
#endif
size_hints.width_inc = FONT_WIDTH (f->output_data.x->font);
size_hints.height_inc = f->output_data.x->line_height;
size_hints.max_width
= FRAME_X_DISPLAY_INFO (f)->width - CHAR_TO_PIXEL_WIDTH (f, 0);
size_hints.max_height
= FRAME_X_DISPLAY_INFO (f)->height - CHAR_TO_PIXEL_HEIGHT (f, 0);
#ifndef USE_X_TOOLKIT
{
int base_width, base_height;
int min_rows = 0, min_cols = 0;
base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
base_height = CHAR_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->output_data.x->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
}
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;
#ifndef USE_X_TOOLKIT
Window window = FRAME_X_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;
}
else
{
#if 0
f->output_data.x->wm_hints.icon_pixmap = None;
#else
return;
#endif
}
#ifdef USE_X_TOOLKIT
{
Arg al[1];
XtSetArg (al[0], XtNiconPixmap, icon_pixmap);
XtSetValues (f->output_data.x->widget, al, 1);
}
#else
f->output_data.x->wm_hints.flags |= IconPixmapHint;
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;
{
#ifdef USE_X_TOOLKIT
Window window = XtWindow (f->output_data.x->widget);
#else
Window window = FRAME_X_WINDOW (f);
#endif
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 count;
int allow_scalable_fonts_p = 0;
if (size < 0)
{
allow_scalable_fonts_p = 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_scalable_fonts_p ? Qt : Qnil);
list = Fassoc (key, tem);
if (!NILP (list))
{
list = Fcdr_safe (list);
goto label_cached;
}
BLOCK_INPUT;
count = x_catch_errors (dpy);
if (try_XLoadQueryFont)
{
XFontStruct *font;
unsigned long value;
font = XLoadQueryFont (dpy, XSTRING (pattern)->data);
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)
{
names = XListFonts (dpy, XSTRING (pattern)->data, max (maxnames, 10),
&num_fonts);
if (x_had_errors_p (dpy))
{
names = NULL;
x_clear_errors (dpy);
}
}
x_uncatch_errors (dpy, count);
UNBLOCK_INPUT;
if (names)
{
int i;
for (i = 0; i < num_fonts; i++)
{
int width = 0;
char *p = names[i];
int average_width = -1, dashes = 0;
while (*p)
if (*p++ == '-')
{
dashes++;
if (dashes == 7)
width = atoi (p);
else if (dashes == 12)
average_width = atoi (p);
}
if (allow_scalable_fonts_p
|| dashes < 14 || average_width != 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;
}
}
XCDR (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;
count = x_catch_errors (dpy);
thisinfo = XLoadQueryFont (dpy,
XSTRING (XCAR (tem))->data);
if (x_had_errors_p (dpy))
{
thisinfo = NULL;
x_clear_errors (dpy);
}
x_uncatch_errors (dpy, count);
UNBLOCK_INPUT;
if (thisinfo)
{
XCDR (tem)
= (thisinfo->min_bounds.width == 0
? make_number (0)
: make_number (thisinfo->max_bounds.width));
BLOCK_INPUT;
XFreeFont (dpy, thisinfo);
UNBLOCK_INPUT;
}
else
XCDR (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;
int count;
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,
XSTRING (XCAR (tail))->data)
|| !strcmp (dpyinfo->font_table[i].full_name,
XSTRING (XCAR (tail))->data)))
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 *) XSTRING (XCAR (font_names))->data;
BLOCK_INPUT;
count = 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 (FRAME_X_DISPLAY (f), count);
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;
fontp->font = font;
fontp->font_idx = i;
fontp->name = (char *) xmalloc (strlen (fontname) + 1);
bcopy (fontname, fontp->name, strlen (fontname) + 1);
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);
XCDR (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);
XCDR (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
&& (!strcmp (dpyinfo->font_table[i].name, fontname)
|| !strcmp (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}
};
#endif
static int x_initialized;
#ifdef MULTI_KBOARD
static int
same_x_server (name1, name2)
char *name1, *name2;
{
int seen_colon = 0;
unsigned char *system_name = XSTRING (Vsystem_name)->data;
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
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 = 1;
}
#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;
}
dpy = XtOpenDisplay (Xt_app_con, XSTRING (display_name)->data,
resource_name, EMACS_CLASS,
emacs_options, XtNumber (emacs_options),
&argc, argv);
#ifdef HAVE_X11XTR6
fixup_locale ();
#endif
}
#else
#ifdef HAVE_X11R5
XSetLocaleModifiers ("");
#endif
dpy = XOpenDisplay (XSTRING (display_name)->data);
#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 (XSTRING (XCAR (XCAR (tail)))->data,
XSTRING (display_name)->data))
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 (STRING_BYTES (XSTRING (Vinvocation_name))
+ STRING_BYTES (XSTRING (Vsystem_name))
+ 2);
sprintf (dpyinfo->x_id_name, "%s@%s",
XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
x_find_modifier_meanings (dpyinfo);
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->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->x_focus_frame = 0;
dpyinfo->x_focus_event_frame = 0;
dpyinfo->x_highlight_frame = 0;
dpyinfo->image_cache = make_image_cache ();
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 (XSTRING (value)->data, "true")
|| !strcmp (XSTRING (value)->data, "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 = pixels * 25.4 / mm;
pixels = DisplayWidth (dpyinfo->display, screen_number);
mm = DisplayWidthMM (dpyinfo->display, screen_number);
dpyinfo->resx = 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_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_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_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;
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;
int count;
d.addr = (XPointer)&dpy;
d.size = sizeof (Display *);
fr.addr = XtDefaultFont;
fr.size = sizeof (XtDefaultFont);
to.size = sizeof (Font *);
to.addr = (XPointer)&font;
count = 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 (dpy, count);
}
#endif
#endif
{
Lisp_Object value;
value = display_x_get_resource (dpyinfo,
build_string ("synchronous"),
build_string ("Synchronous"),
Qnil, Qnil);
if (STRINGP (value)
&& (!strcmp (XSTRING (value)->data, "true")
|| !strcmp (XSTRING (value)->data, "on")))
XSynchronize (dpyinfo->display, True);
}
UNBLOCK_INPUT;
return dpyinfo;
}
void
x_delete_display (dpyinfo)
struct x_display_info *dpyinfo;
{
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))
{
XCDR (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
xfree (dpyinfo->font_table);
xfree (dpyinfo->x_id_name);
xfree (dpyinfo->color_cells);
xfree (dpyinfo);
}
static struct redisplay_interface x_redisplay_interface =
{
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,
XTcursor_to,
x_flush,
x_clear_mouse_face,
x_get_glyph_overhangs,
x_fix_overlapping_area
};
void
x_initialize ()
{
rif = &x_redisplay_interface;
clear_frame_hook = x_clear_frame;
ins_del_lines_hook = x_ins_del_lines;
change_line_highlight_hook = x_change_line_highlight;
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;
reassert_line_highlight_hook = XTreassert_line_highlight;
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;
estimate_mode_line_height_hook = x_estimate_mode_line_height;
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;
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);
{
EMACS_TIME interval;
EMACS_SET_SECS_USECS (interval, 0, 100000);
start_atimer (ATIMER_CONTINUOUS, interval, x_process_timeouts, 0);
}
#endif
#ifdef USE_TOOLKIT_SCROLL_BARS
xaw3d_arrow_scroll = False;
xaw3d_pick_top = True;
#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 ()
{
staticpro (&x_error_message_string);
x_error_message_string = Qnil;
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 (&last_mouse_press_frame);
last_mouse_press_frame = Qnil;
help_echo = Qnil;
staticpro (&help_echo);
help_echo_object = Qnil;
staticpro (&help_echo_object);
help_echo_window = Qnil;
staticpro (&help_echo_window);
previous_help_echo = Qnil;
staticpro (&previous_help_echo);
help_echo_pos = -1;
DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
"*Non-nil means draw block cursor as wide as the glyph under it.\n\
For example, if a block cursor is over a tab, it will be drawn as\n\
wide as that tab on the display.");
x_stretch_cursor_p = 0;
DEFVAR_BOOL ("x-use-underline-position-properties",
&x_use_underline_position_properties,
"*Non-nil means make use of UNDERLINE_POSITION font properties.\n\
Nil means ignore them. If you encounter fonts with bogus\n\
UNDERLINE_POSITION font properties, for example 7x13 on XFree prior\n\
to 4.1, set this to nil.");
x_use_underline_position_properties = 1;
DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
"What X toolkit scroll bars Emacs uses.\n\
A value of nil means Emacs doesn't use X toolkit scroll bars.\n\
Otherwise, value is a symbol describing the X toolkit.");
#ifdef USE_TOOLKIT_SCROLL_BARS
#ifdef USE_MOTIF
Vx_toolkit_scroll_bars = intern ("motif");
#elif defined HAVE_XAW3D
Vx_toolkit_scroll_bars = intern ("xaw3d");
#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;
}
#endif