#include <config.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include "lisp.h"
#include "charset.h"
#include "blockinput.h"
#include "w32heap.h"
#include "w32term.h"
#include "w32bdf.h"
#include <shellapi.h>
#include "systty.h"
#include "systime.h"
#include "atimer.h"
#include <ctype.h>
#include <errno.h>
#include <setjmp.h>
#include <sys/stat.h>
#include "keyboard.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 "intervals.h"
#include "composite.h"
#include "coding.h"
#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 short zv_bits[] = {
0x00, 0x00, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00};
static HBITMAP zv_bmp;
#define left_width 8
#define left_height 8
static unsigned short left_bits[] = {
0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
static HBITMAP left_bmp;
#define right_width 8
#define right_height 8
static unsigned short right_bits[] = {
0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
static HBITMAP right_bmp;
#define continued_width 8
#define continued_height 8
static unsigned short continued_bits[] = {
0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
static HBITMAP continued_bmp;
#define continuation_width 8
#define continuation_height 8
static unsigned short continuation_bits[] = {
0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
static HBITMAP continuation_bmp;
#if 0
#define ov_width 8
#define ov_height 8
static unsigned short ov_bits[] = {
0x0c, 0x10, 0x3c, 0x7e, 0x5e, 0x5e, 0x46, 0x3c};
#else
#define ov_width 8
#define ov_height 8
static unsigned short ov_bits[] = {
0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
#endif
static HBITMAP ov_bmp;
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;
extern unsigned int msh_mousewheel;
extern void free_frame_menubar ();
extern void w32_menu_display_help (HMENU menu, UINT menu_item, UINT flags);
extern int w32_codepage_for_font (char *fontname);
extern glyph_metric *w32_BDF_TextMetric(bdffont *fontp,
unsigned char *text, int dim);
extern Lisp_Object Vwindow_system;
#define x_any_window_to_frame x_window_to_frame
#define x_top_window_to_frame x_window_to_frame
struct w32_display_info one_w32_display_info;
struct w32_display_info *x_display_list;
Lisp_Object w32_display_name_list;
extern struct frame *updating_frame;
struct frame *pending_autoraise_frame;
struct cursor_pos output_cursor;
int w32_enable_unicode_output;
DWORD dwWindowsThreadId = 0;
HANDLE hWindowsThread = NULL;
DWORD dwMainThreadId = 0;
HANDLE hMainThread = NULL;
#ifndef SIF_ALL
#define SIF_RANGE 0x0001
#define SIF_PAGE 0x0002
#define SIF_POS 0x0004
#define SIF_DISABLENOSCROLL 0x0008
#define SIF_TRACKPOS 0x0010
#define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
typedef struct tagSCROLLINFO
{
UINT cbSize;
UINT fMask;
int nMin;
int nMax;
UINT nPage;
int nPos;
int nTrackPos;
} SCROLLINFO, FAR *LPSCROLLINFO;
typedef SCROLLINFO CONST FAR *LPCSCROLLINFO;
#endif
int (PASCAL *pfnSetScrollInfo) (HWND hwnd, int fnBar, LPSCROLLINFO lpsi, BOOL fRedraw);
BOOL (PASCAL *pfnGetScrollInfo) (HWND hwnd, int fnBar, LPSCROLLINFO lpsi);
int vertical_scroll_bar_min_handle;
int vertical_scroll_bar_top_border;
int vertical_scroll_bar_bottom_border;
int last_scroll_bar_drag_pos;
FRAME_PTR last_mouse_frame;
static RECT last_mouse_glyph;
static Lisp_Object last_mouse_press_frame;
Lisp_Object Vw32_num_mouse_buttons;
Lisp_Object Vw32_swap_mouse_buttons;
Lisp_Object Vw32_grab_focus_on_raise;
Lisp_Object Vw32_capslock_is_shiftlock;
Lisp_Object Vw32_recognize_altgr;
static Lisp_Object last_mouse_scroll_bar;
static int last_mouse_scroll_bar_pos;
static Time last_mouse_movement_time;
#ifdef __STDC__
static int volatile input_signal_count;
#else
static int input_signal_count;
#endif
extern Lisp_Object Vcommand_line_args, Vsystem_name;
extern Lisp_Object Qface, Qmouse_face;
#ifndef USE_CRT_DLL
extern int errno;
#endif
extern int extra_keyboard_modifiers;
enum draw_glyphs_face
{
DRAW_NORMAL_TEXT,
DRAW_INVERSE_VIDEO,
DRAW_CURSOR,
DRAW_MOUSE_FACE,
DRAW_IMAGE_RAISED,
DRAW_IMAGE_SUNKEN
};
static void x_update_window_end P_ ((struct window *, int, int));
static void frame_to_window_pixel_xy P_ ((struct window *, int *, int *));
void w32_delete_display P_ ((struct w32_display_info *));
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 w32_handle_tool_bar_click P_ ((struct frame *,
struct input_event *));
static void show_mouse_face P_ ((struct w32_display_info *,
enum draw_glyphs_face));
static int cursor_in_mouse_face_p P_ ((struct window *));
static int clear_mouse_face P_ ((struct w32_display_info *));
void x_lower_frame P_ ((struct frame *));
void x_scroll_bar_clear P_ ((struct frame *));
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 w32_initialize P_ ((void));
static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
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 w32_frame_up_to_date P_ ((struct frame *));
static void w32_reassert_line_highlight P_ ((int, int));
static void x_change_line_highlight P_ ((int, int, int, int));
static void w32_set_terminal_modes P_ ((void));
static void w32_reset_terminal_modes P_ ((void));
static void w32_cursor_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 w32_new_focus_frame P_ ((struct w32_display_info *,
struct frame *));
static void w32_frame_rehighlight P_ ((struct frame *));
static void x_frame_rehighlight P_ ((struct w32_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 void expose_frame P_ ((struct frame *, int, int, int, int));
static int expose_window_tree P_ ((struct window *, RECT *));
static int expose_window P_ ((struct window *, RECT *));
static void expose_area P_ ((struct window *, struct glyph_row *,
RECT *, enum glyph_row_area));
static int expose_line P_ ((struct window *, struct glyph_row *,
RECT *));
void x_update_cursor P_ ((struct frame *, int));
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_cursor P_ ((struct window *w, int, int, int, int, int));
void x_display_and_set_cursor P_ ((struct window *, int, int, int, int, int));
static void w32_draw_bitmap P_ ((struct window *, HDC hdc, struct glyph_row *,
enum bitmap_type));
static void w32_clip_to_row P_ ((struct window *, struct glyph_row *,
HDC, int));
static int x_phys_cursor_in_rect_p P_ ((struct window *, RECT *));
static void x_draw_row_bitmaps P_ ((struct window *, struct glyph_row *));
static void notice_overwritten_cursor P_ ((struct window *, int, int));
static Lisp_Object Qvendor_specific_keysyms;
#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
void XChangeGC (void * ignore, XGCValues* gc, unsigned long mask,
XGCValues *xgcv)
{
if (mask & GCForeground)
gc->foreground = xgcv->foreground;
if (mask & GCBackground)
gc->background = xgcv->background;
if (mask & GCFont)
gc->font = xgcv->font;
}
XGCValues *XCreateGC (void * ignore, Window window, unsigned long mask,
XGCValues *xgcv)
{
XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues));
bzero (gc, sizeof (XGCValues));
XChangeGC (ignore, gc, mask, xgcv);
return gc;
}
void XGetGCValues (void* ignore, XGCValues *gc,
unsigned long mask, XGCValues *xgcv)
{
XChangeGC (ignore, xgcv, mask, gc);
}
static void
w32_set_clip_rectangle (HDC hdc, RECT *rect)
{
if (rect)
{
HRGN clip_region = CreateRectRgnIndirect (rect);
SelectClipRgn (hdc, clip_region);
DeleteObject (clip_region);
}
else
SelectClipRgn (hdc, NULL);
}
void
w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y,
int width, int height)
{
HBRUSH hb, oldhb;
HPEN hp, oldhp;
hb = CreateSolidBrush (gc->background);
hp = CreatePen (PS_SOLID, 0, gc->foreground);
oldhb = SelectObject (hdc, hb);
oldhp = SelectObject (hdc, hp);
Rectangle (hdc, x, y, x + width, y + height);
SelectObject (hdc, oldhb);
SelectObject (hdc, oldhp);
DeleteObject (hb);
DeleteObject (hp);
}
void
w32_fill_rect (f, hdc, pix, lprect)
FRAME_PTR f;
HDC hdc;
COLORREF pix;
RECT * lprect;
{
HBRUSH hb;
hb = CreateSolidBrush (pix);
FillRect (hdc, lprect, hb);
DeleteObject (hb);
}
void
w32_clear_window (f)
FRAME_PTR f;
{
RECT rect;
HDC hdc = get_frame_dc (f);
if (hdc)
{
GetClientRect (FRAME_W32_WINDOW (f), &rect);
w32_clear_rect (f, hdc, &rect);
}
release_frame_dc (f, hdc);
}
static void
x_update_begin (f)
struct frame *f;
{
struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
if (! FRAME_W32_P (f))
return;
if (display_info->regen_palette)
{
w32_regenerate_palette (f);
display_info->regen_palette = FALSE;
}
}
static void
x_update_window_begin (w)
struct window *w;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct w32_display_info *display_info = FRAME_W32_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))
{
RECT r;
HDC hdc;
window_box_edges (w, -1, (int *) &r.left, (int *) &r.top,
(int *) &r.right, (int *) &r.bottom);
r.left = r.right + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f);
r.right = r.left + 1;
r.bottom -= 1;
hdc = get_frame_dc (f);
w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
release_frame_dc (f, hdc);
}
}
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 w32_display_info *dpyinfo
= FRAME_W32_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;
{
if (! FRAME_W32_P (f))
return;
FRAME_W32_DISPLAY_INFO (f)->mouse_face_defer = 0;
}
static void
w32_frame_up_to_date (f)
struct frame *f;
{
if (FRAME_W32_P (f))
{
struct w32_display_info *dpyinfo = FRAME_W32_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;
{
HDC hdc = get_frame_dc (f);
w32_clear_area (f, hdc, 0, y, width, height);
w32_clear_area (f, hdc, f->output_data.w32->pixel_width - width,
y, width, height);
release_frame_dc (f, hdc);
}
UNBLOCK_INPUT;
}
}
static void
w32_draw_bitmap (w, hdc, row, which)
struct window *w;
HDC hdc;
struct glyph_row *row;
enum bitmap_type which;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
Window window = FRAME_W32_WINDOW (f);
HDC compat_hdc;
int x, y, wd, h, dy;
HBITMAP pixmap;
HANDLE horig_obj;
struct face *face;
w32_clip_to_row (w, row, hdc, 1);
switch (which)
{
case LEFT_TRUNCATION_BITMAP:
wd = left_width;
h = left_height;
pixmap = left_bmp;
x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
- wd
- (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
break;
case OVERLAY_ARROW_BITMAP:
wd = ov_width;
h = ov_height;
pixmap = ov_bmp;
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;
pixmap = right_bmp;
x = window_box_right (w, -1);
x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
break;
case CONTINUED_LINE_BITMAP:
wd = continued_width;
h = continued_height;
pixmap = continued_bmp;
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;
pixmap = continuation_bmp;
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;
pixmap = zv_bmp;
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);
compat_hdc = CreateCompatibleDC (hdc);
SaveDC (hdc);
horig_obj = SelectObject (compat_hdc, pixmap);
SetTextColor (hdc, face->background);
SetBkColor (hdc, face->foreground);
BitBlt (hdc, x, y + dy, wd, h, compat_hdc, 0, 0, SRCCOPY);
SelectObject (compat_hdc, horig_obj);
DeleteDC (compat_hdc);
RestoreDC (hdc, -1);
}
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;
HDC hdc;
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;
hdc = get_frame_dc (f);
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);
w32_fill_area (f, hdc, face->background,
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 (bitmap != NO_BITMAP)
w32_draw_bitmap (w, hdc, 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);
w32_fill_area (f, hdc, face->background,
right,
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
row->y)),
FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f),
row->visible_height);
}
if (bitmap != NO_BITMAP)
w32_draw_bitmap (w, hdc, row, bitmap);
release_frame_dc (f, hdc);
}
static void
w32_reassert_line_highlight (new, vpos)
int new, vpos;
{
struct frame *f;
if (updating_frame)
f = updating_frame;
else
f = SELECTED_FRAME ();
if (! FRAME_W32_P (f))
return;
abort ();
}
static void
x_change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
int new_highlight, vpos, y, first_unused_hpos;
{
struct frame *f;
if (updating_frame)
f = updating_frame;
else
f = SELECTED_FRAME ();
if (! FRAME_W32_P (f))
return;
abort ();
}
static void
w32_set_terminal_modes (void)
{
}
static void
w32_reset_terminal_modes (void)
{
}
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
w32_cursor_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);
UNBLOCK_INPUT;
}
}
static struct face *x_get_glyph_face_and_encoding P_ ((struct frame *,
struct glyph *,
wchar_t *,
int *));
static struct face *x_get_char_face_and_encoding P_ ((struct frame *, int,
int, wchar_t *, int));
static XCharStruct *w32_per_char_metric P_ ((XFontStruct *,
wchar_t *,
enum w32_char_font_type));
static enum w32_char_font_type
w32_encode_char P_ ((int, wchar_t *, struct font_info *, int *));
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));
#define BUILD_WCHAR_T(byte1, byte2) \
((wchar_t)((((byte1) & 0x00ff) << 8) | ((byte2) & 0x00ff)))
#define BYTE1(ch) \
(((ch) & 0xff00) >> 8)
#define BYTE2(ch) \
((ch) & 0x00ff)
static int
w32_bdf_per_char_metric (font, char2b, dim, pcm)
XFontStruct *font;
wchar_t *char2b;
int dim;
XCharStruct * pcm;
{
glyph_metric * bdf_metric;
char buf[2];
if (dim == 1)
buf[0] = (char)(*char2b);
else
{
buf[0] = BYTE1 (*char2b);
buf[1] = BYTE2 (*char2b);
}
bdf_metric = w32_BDF_TextMetric (font->bdf, buf, dim);
if (bdf_metric)
{
pcm->width = bdf_metric->dwidth;
pcm->lbearing = bdf_metric->bbox;
pcm->rbearing = bdf_metric->dwidth
- (bdf_metric->bbox + bdf_metric->bbw);
pcm->ascent = bdf_metric->bboy + bdf_metric->bbh;
pcm->descent = -bdf_metric->bboy;
return 1;
}
return 0;
}
static int
w32_native_per_char_metric (font, char2b, font_type, pcm)
XFontStruct *font;
wchar_t *char2b;
enum w32_char_font_type font_type;
XCharStruct * pcm;
{
HDC hdc = GetDC (NULL);
HFONT old_font;
BOOL retval = FALSE;
xassert (font && char2b);
xassert (font->hfont);
xassert (font_type == UNICODE_FONT || font_type == ANSI_FONT);
old_font = SelectObject (hdc, font->hfont);
if ((font->tm.tmPitchAndFamily & TMPF_TRUETYPE) != 0)
{
ABC char_widths;
if (font_type == UNICODE_FONT)
retval = GetCharABCWidthsW (hdc, *char2b, *char2b, &char_widths);
else
retval = GetCharABCWidthsA (hdc, *char2b, *char2b, &char_widths);
if (retval)
{
#if 0
int real_width;
GetCharWidth (hdc, *char2b, *char2b, &real_width);
#endif
pcm->width = char_widths.abcA + char_widths.abcB + char_widths.abcC;
#if 0
if (pcm->width != real_width)
pcm->width = (pcm->width + real_width) / 2;
#endif
pcm->lbearing = char_widths.abcA;
pcm->rbearing = pcm->width - char_widths.abcC;
pcm->ascent = FONT_BASE (font);
pcm->descent = FONT_DESCENT (font);
}
}
if (!retval)
{
SIZE sz;
if (font_type == UNICODE_FONT)
retval = GetTextExtentPoint32W (hdc, char2b, 1, &sz);
else
retval = GetTextExtentPoint32A (hdc, (char*)char2b, 1, &sz);
if (retval)
{
pcm->width = sz.cx - font->tm.tmOverhang;
pcm->rbearing = sz.cx;
pcm->lbearing = 0;
pcm->ascent = FONT_BASE (font);
pcm->descent = FONT_DESCENT (font);
}
}
if (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0)
{
retval = FALSE;
}
SelectObject (hdc, old_font);
ReleaseDC (NULL, hdc);
return retval;
}
static XCharStruct *
w32_per_char_metric (font, char2b, font_type)
XFontStruct *font;
wchar_t *char2b;
enum w32_char_font_type font_type;
{
XCharStruct *pcm;
BOOL retval;
xassert (font && char2b);
xassert (font_type != UNKNOWN_FONT);
if (!font->bdf && font->per_char == NULL)
return &font->max_bounds;
else if (!font->bdf && *char2b < 128)
return &font->per_char[*char2b];
pcm = &font->scratch;
if (font_type == BDF_1D_FONT)
retval = w32_bdf_per_char_metric (font, char2b, 1, pcm);
else if (font_type == BDF_2D_FONT)
retval = w32_bdf_per_char_metric (font, char2b, 2, pcm);
else
retval = w32_native_per_char_metric (font, char2b, font_type, pcm);
if (retval)
return pcm;
return NULL;
}
void
w32_cache_char_metrics (font)
XFontStruct *font;
{
wchar_t char2b = L'x';
if (font->bdf)
{
if (!w32_bdf_per_char_metric (font, &char2b, 1, &font->max_bounds))
{
font->max_bounds.width = FONT_MAX_WIDTH (font);
font->max_bounds.lbearing = -font->bdf->llx;
font->max_bounds.rbearing = FONT_MAX_WIDTH (font) - font->bdf->urx;
font->max_bounds.ascent = FONT_BASE (font);
font->max_bounds.descent = FONT_DESCENT (font);
}
}
else
{
if (((font->tm.tmPitchAndFamily & TMPF_FIXED_PITCH) != 0)
|| (font->tm.tmMaxCharWidth != font->tm.tmAveCharWidth))
{
int i;
font->per_char = xmalloc (128 * sizeof(XCharStruct));
for (i = 0; i < 128; i++)
{
char2b = i;
w32_native_per_char_metric (font, &char2b, ANSI_FONT,
&font->per_char[i]);
}
}
else
w32_native_per_char_metric (font, &char2b, ANSI_FONT,
&font->max_bounds);
}
}
int w32_font_is_double_byte (XFontStruct *font)
{
return font->double_byte_p;
}
static BOOL
w32_use_unicode_for_codepage (codepage)
int codepage;
{
return (w32_enable_unicode_output
&& codepage != CP_8BIT
&& (codepage == CP_UNICODE || IsValidCodePage (codepage)));
}
static INLINE enum w32_char_font_type
w32_encode_char (c, char2b, font_info, two_byte_p)
int c;
wchar_t *char2b;
struct font_info *font_info;
int * two_byte_p;
{
int charset = CHAR_CHARSET (c);
int codepage;
int unicode_p = 0;
XFontStruct *font = font_info->font;
xassert (two_byte_p);
*two_byte_p = w32_font_is_double_byte (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] = BYTE2 (*char2b);
}
else
{
ccl->reg[0] = charset;
ccl->reg[1] = BYTE1 (*char2b);
ccl->reg[2] = BYTE2 (*char2b);
}
ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
if (!*two_byte_p)
*char2b = BUILD_WCHAR_T (0, ccl->reg[1]);
else
*char2b = BUILD_WCHAR_T (ccl->reg[1], 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 = BUILD_WCHAR_T (BYTE1 (*char2b) | 0x80, BYTE2 (*char2b));
if (enc == 1 || enc == 3
|| (enc == 4 && CHARSET_DIMENSION (charset) == 1))
*char2b = BUILD_WCHAR_T (BYTE1 (*char2b), BYTE2 (*char2b) | 0x80);
else if (enc == 4)
{
int sjis1, sjis2;
ENCODE_SJIS (BYTE1 (*char2b), BYTE2 (*char2b),
sjis1, sjis2);
*char2b = BUILD_WCHAR_T (sjis1, sjis2);
}
}
codepage = font_info->codepage;
if ( font && !font->bdf && w32_use_unicode_for_codepage (codepage)
&& charset != CHARSET_ASCII && charset != charset_latin_iso8859_1
&& charset != CHARSET_8_BIT_CONTROL && charset != CHARSET_8_BIT_GRAPHIC)
{
char temp[3];
temp[0] = BYTE1 (*char2b);
temp[1] = BYTE2 (*char2b);
temp[2] = '\0';
if (codepage != CP_UNICODE)
{
if (temp[0])
MultiByteToWideChar (codepage, 0, temp, 2, char2b, 1);
else
MultiByteToWideChar (codepage, 0, temp+1, 1, char2b, 1);
}
unicode_p = 1;
*two_byte_p = 1;
}
if (!font)
return UNKNOWN_FONT;
else if (font->bdf && CHARSET_DIMENSION (charset) == 1)
return BDF_1D_FONT;
else if (font->bdf)
return BDF_2D_FONT;
else if (unicode_p)
return UNICODE_FONT;
else
return ANSI_FONT;
}
static INLINE struct face *
x_get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p)
struct frame *f;
int c, face_id;
wchar_t *char2b;
int multibyte_p;
{
struct face *face = FACE_FROM_ID (f, face_id);
if (!multibyte_p)
{
*char2b = BUILD_WCHAR_T (0, 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 = BUILD_WCHAR_T (0, c);
}
else
{
int c1, c2, charset;
SPLIT_CHAR (c, charset, c1, c2);
if (c2 > 0)
*char2b = BUILD_WCHAR_T (c1, c2);
else
*char2b = BUILD_WCHAR_T (0, c1);
if (face->font != NULL)
{
struct font_info *font_info
= FONT_INFO_FROM_ID (f, face->font_info_id);
if (font_info)
w32_encode_char (c, char2b, font_info, &multibyte_p);
}
}
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;
wchar_t *char2b;
int *two_byte_p;
{
struct face *face;
int dummy = 0;
xassert (glyph->type == CHAR_GLYPH);
face = FACE_FROM_ID (f, glyph->face_id);
if (two_byte_p)
*two_byte_p = 0;
else
two_byte_p = &dummy;
if (!glyph->multibyte_p)
{
*char2b = BUILD_WCHAR_T (0, glyph->u.ch);
}
else if (glyph->u.ch < 128
&& glyph->face_id < BASIC_FACE_ID_SENTINEL)
{
*char2b = BUILD_WCHAR_T (0, glyph->u.ch);
}
else
{
int c1, c2, charset;
SPLIT_CHAR (glyph->u.ch, charset, c1, c2);
if (c2 > 0)
*char2b = BUILD_WCHAR_T (c1, c2);
else
*char2b = BUILD_WCHAR_T (0, c1);
if (charset != CHARSET_ASCII)
{
struct font_info *font_info
= FONT_INFO_FROM_ID (f, face->font_info_id);
if (font_info)
{
glyph->w32_font_type
= w32_encode_char (glyph->u.ch, char2b, font_info, two_byte_p);
}
}
}
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;
glyph->w32_font_type = UNKNOWN_FONT;
++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;
glyph->w32_font_type = UNKNOWN_FONT;
++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;
glyph->w32_font_type = UNKNOWN_FONT;
++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;
glyph->w32_font_type = UNKNOWN_FONT;
++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_BASE (font) / 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 (FONT) \
+ (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
+ (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
- (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (F)))
static void
x_produce_glyphs (it)
struct it *it;
{
it->glyph_not_available_p = 0;
if (it->what == IT_CHARACTER)
{
wchar_t 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.w32->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 = w32_per_char_metric (font, &char2b,
font->bdf ? BDF_1D_FONT : ANSI_FONT);
it->ascent = FONT_BASE (font) + boff;
it->descent = FONT_DESCENT (font) - 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_BASE (font) + boff;
it->phys_descent = FONT_DESCENT (font) - 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_BASE (font)
/ 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_BASE (font) + boff;
it->descent = it->phys_descent = FONT_DESCENT (font) - 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_BASE (font) + boff;
it->descent = it->phys_descent = FONT_DESCENT (font) - 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
{
enum w32_char_font_type type;
if (font->bdf && CHARSET_DIMENSION (CHAR_CHARSET (it->c)) == 1)
type = BDF_1D_FONT;
else if (font->bdf)
type = BDF_2D_FONT;
else
type = UNICODE_FONT;
pcm = w32_per_char_metric (font, &char2b, type);
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_BASE (font) + boff;
it->phys_descent = FONT_DESCENT (font) - 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_BASE (font) + boff;
it->descent = FONT_DESCENT (font) - 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)
{
wchar_t 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.w32->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_BASE (font) + boff;
int font_descent = FONT_DESCENT (font) - boff;
int leftmost, rightmost, lowest, highest;
int i, width, ascent, descent;
enum w32_char_font_type font_type;
cmp->font = (void *) font;
if (font->bdf && CHARSET_DIMENSION (CHAR_CHARSET (it->c)) == 1)
font_type = BDF_1D_FONT;
else if (font->bdf)
font_type = BDF_2D_FONT;
else
font_type = UNICODE_FONT;
if (font_info
&& (pcm = w32_per_char_metric (font, &char2b, font_type)))
{
width = pcm->width;
ascent = pcm->ascent;
descent = pcm->descent;
}
else
{
width = FONT_WIDTH (font);
ascent = FONT_BASE (font);
descent = FONT_DESCENT (font);
}
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.w32->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->bdf && CHARSET_DIMENSION (CHAR_CHARSET (ch)) == 1)
font_type = BDF_1D_FONT;
else if (font->bdf)
font_type = BDF_2D_FONT;
else
font_type = UNICODE_FONT;
if (font_info
&& (pcm = w32_per_char_metric (font, &char2b, font_type)))
{
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;
Window window;
struct glyph_row *row;
enum glyph_row_area area;
wchar_t *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;
XGCValues *gc;
HDC hdc;
struct glyph *first_glyph;
struct image *img;
struct glyph_string *next, *prev;
};
void W32_TEXTOUT (s, x, y,chars,nchars)
struct glyph_string * s;
int x, y;
wchar_t * chars;
int nchars;
{
int charset_dim = w32_font_is_double_byte (s->gc->font) ? 2 : 1;
if (s->gc->font->bdf)
w32_BDF_TextOut (s->gc->font->bdf, s->hdc,
x, y, (char *) chars, charset_dim,
nchars * charset_dim, 0);
else if (s->first_glyph->w32_font_type == UNICODE_FONT)
ExtTextOutW (s->hdc, x, y, 0, NULL, chars, nchars, NULL);
else
ExtTextOut (s->hdc, x, y, 0, NULL, (char *) chars,
nchars * charset_dim, NULL);
}
#if 0
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 w32_init_glyph_string P_ ((struct glyph_string *, HDC hdc,
wchar_t *, 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 w32_get_glyph_overhangs P_ ((HDC hdc, struct glyph *,
struct frame *,
int *, int *));
static void x_compute_overhangs_and_x P_ ((struct glyph_string *, int, int));
static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int);
static void w32_setup_relief_color P_ ((struct frame *, struct relief *,
double, int, COLORREF));
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 w32_draw_image_foreground_1 P_ ((struct glyph_string *, HBITMAP));
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 w32_draw_relief_rect P_ ((struct frame *, int, int, int, int,
int, int, int, int, RECT *));
static void w32_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
int, int, int, RECT *));
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.w32->cursor_gc;
else
{
XGCValues xgcv;
unsigned long mask;
xgcv.background = s->f->output_data.w32->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.w32->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;
mask = GCForeground | GCBackground | GCFont;
if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
mask, &xgcv);
else
FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
= XCreateGC (NULL, s->window, mask, &xgcv);
s->gc = FRAME_W32_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_W32_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;
mask = GCForeground | GCBackground | GCFont;
if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
mask, &xgcv);
else
FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
= XCreateGC (NULL, s->window, mask, &xgcv);
s->gc = FRAME_W32_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
w32_get_glyph_string_clip_rect (s, r)
struct glyph_string *s;
RECT *r;
{
int r_height, r_width;
if (s->row->full_width_p)
{
int canon_x = CANON_X_UNIT (s->f);
r->left = 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->left -= width;
}
r->left += 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->left = 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->top = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
r_height = window_text_bottom_y (s->w) - r->top;
}
else
{
if (!s->row->full_width_p
&& MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
r->top = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
else
r->top = max (0, s->row->y);
if (s->w == XWINDOW (s->f->tool_bar_window))
r->top -= s->f->output_data.w32->internal_border_width;
}
r->top = WINDOW_TO_FRAME_PIXEL_Y (s->w, r->top);
r->bottom = r->top + r_height;
r->right = r->left + r_width;
}
static INLINE void
x_set_glyph_string_clipping (s)
struct glyph_string *s;
{
RECT r;
w32_get_glyph_string_clip_rect (s, &r);
w32_set_clip_rectangle (s->hdc, &r);
}
static INLINE void
x_compute_glyph_string_overhangs (s)
struct glyph_string *s;
{
}
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
w32_get_glyph_overhangs (hdc, glyph, f, left, right)
HDC hdc;
struct glyph *glyph;
struct frame *f;
int *left, *right;
{
*left = *right = 0;
if (glyph->type == CHAR_GLYPH)
{
XFontStruct *font;
struct face *face;
wchar_t char2b;
XCharStruct *pcm;
face = x_get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
font = face->font;
if (font
&& (pcm = w32_per_char_metric (font, &char2b,
glyph->w32_font_type)))
{
if (pcm->rbearing > pcm->width)
*right = pcm->rbearing - pcm->width;
if (pcm->lbearing < 0)
*left = -pcm->lbearing;
}
}
}
static void
x_get_glyph_overhangs (glyph, f, left, right)
struct glyph *glyph;
struct frame *f;
int *left, *right;
{
HDC hdc = get_frame_dc (f);
w32_get_glyph_overhangs (hdc, glyph, f, left, right);
release_frame_dc (f, hdc);
}
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;
w32_get_glyph_overhangs (s->hdc, 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;
w32_get_glyph_overhangs (s->hdc, 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;
{
int real_x = x;
int real_y = y;
int real_w = w;
int real_h = h;
#if 0
if (s->gc->clip_mask == Rect)
{
real_x = max (real_x, s->gc->clip_rectangle.left);
real_y = max (real_y, s->gc->clip_rectangle.top);
real_w = min (real_w, s->gc->clip_rectangle.right
- s->gc->clip_rectangle.left);
real_h = min (real_h, s->gc->clip_rectangle.bottom
- s->gc->clip_rectangle.top);
}
#endif
w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y,
real_w, real_h);
}
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 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
#endif
if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
|| s->font_not_found_p
|| s->extends_to_end_of_line_p
|| s->font->bdf
|| 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;
HFONT old_font;
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->for_overlaps_p || (s->background_filled_p && s->hl != DRAW_CURSOR))
SetBkMode (s->hdc, TRANSPARENT);
else
SetBkMode (s->hdc, OPAQUE);
SetTextColor (s->hdc, s->gc->foreground);
SetBkColor (s->hdc, s->gc->background);
SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
if (s->font && s->font->hfont)
old_font = SelectObject (s->hdc, s->font->hfont);
if (s->font_not_found_p)
{
for (i = 0; i < s->nchars; ++i)
{
struct glyph *g = s->first_glyph + i;
w32_draw_rectangle (s->hdc, 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] = BYTE2 (s->char2b[i]);
W32_TEXTOUT (s, x, s->ybase - boff, s->char2b, s->nchars);
}
if (s->font && s->font->hfont)
SelectObject (s->hdc, old_font);
}
static void
x_draw_composite_glyph_string_foreground (s)
struct glyph_string *s;
{
int i, x;
HFONT old_font;
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;
SetTextColor (s->hdc, s->gc->foreground);
SetBkColor (s->hdc, s->gc->background);
SetBkMode (s->hdc, TRANSPARENT);
SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
if (s->font && s->font->hfont)
old_font = SelectObject (s->hdc, s->font->hfont);
if (s->font_not_found_p)
{
if (s->gidx == 0)
w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1,
s->height - 1);
}
else
{
for (i = 0; i < s->nchars; i++, ++s->gidx)
W32_TEXTOUT (s, x + s->cmp->offsets[s->gidx * 2],
s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
s->char2b + i, 1);
}
if (s->font && s->font->hfont)
SelectObject (s->hdc, old_font);
}
#define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
static int
w32_alloc_lighter_color (f, color, factor, delta)
struct frame *f;
COLORREF *color;
double factor;
int delta;
{
COLORREF new;
long bright;
delta /= 256;
xassert (factor >= 0);
new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
min (0xff, factor * GetGValue (*color)),
min (0xff, factor * GetBValue (*color)));
bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
+ GetBValue (*color)) / 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 = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))),
max (0, min (0xff, min_delta - GetGValue (*color))),
max (0, min (0xff, min_delta - GetBValue (*color))));
else
new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))),
max (0, min (0xff, min_delta + GetGValue (*color))),
max (0, min (0xff, min_delta + GetBValue (*color))));
}
if (new == *color)
new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))),
max (0, min (0xff, delta + GetGValue (*color))),
max (0, min (0xff, delta + GetBValue (*color))));
if (new == *color)
return 0;
*color = new;
return 1;
}
static void
w32_setup_relief_color (f, relief, factor, delta, default_pixel)
struct frame *f;
struct relief *relief;
double factor;
int delta;
COLORREF default_pixel;
{
XGCValues xgcv;
struct w32_output *di = f->output_data.w32;
unsigned long mask = GCForeground;
COLORREF pixel;
COLORREF background = di->relief_background;
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
xgcv.foreground = default_pixel;
pixel = background;
if (w32_alloc_lighter_color (f, &pixel, factor, delta))
{
relief->allocated_p = 1;
xgcv.foreground = relief->pixel = pixel;
}
if (relief->gc == 0)
{
#if 0
xgcv.stipple = dpyinfo->gray;
mask |= GCStipple;
#endif
relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv);
}
else
XChangeGC (NULL, relief->gc, mask, &xgcv);
}
static void
x_setup_relief_colors (s)
struct glyph_string *s;
{
struct w32_output *di = s->f->output_data.w32;
COLORREF color;
if (s->face->use_box_color_for_shadows_p)
color = s->face->box_color;
else
color = s->gc->background;
if (di->white_relief.gc == 0
|| color != di->relief_background)
{
di->relief_background = color;
w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
WHITE_PIX_DEFAULT (s->f));
w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
BLACK_PIX_DEFAULT (s->f));
}
}
static void
w32_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;
RECT *clip_rect;
{
int i;
XGCValues gc;
HDC hdc = get_frame_dc (f);
if (raised_p)
gc.foreground = f->output_data.w32->white_relief.gc->foreground;
else
gc.foreground = f->output_data.w32->black_relief.gc->foreground;
w32_set_clip_rectangle (hdc, clip_rect);
for (i = 0; i < width; ++i)
{
w32_fill_area (f, hdc, gc.foreground,
left_x + i * left_p, top_y + i,
(right_x + 1 - i * right_p) - (left_x + i * left_p) + 1,
1);
}
if (left_p)
for (i = 0; i < width; ++i)
{
w32_fill_area (f, hdc, gc.foreground,
left_x + i, top_y + i, 1,
(bottom_y - i) - (top_y + i) + 2);
}
w32_set_clip_rectangle (hdc, NULL);
if (raised_p)
gc.foreground = f->output_data.w32->black_relief.gc->foreground;
else
gc.foreground = f->output_data.w32->white_relief.gc->foreground;
w32_set_clip_rectangle (hdc, clip_rect);
for (i = 0; i < width; ++i)
{
w32_fill_area (f, hdc, gc.foreground,
left_x + i * left_p, bottom_y - i,
(right_x - i * right_p) - (left_x + i * left_p) + 2, 1);
}
if (right_p)
for (i = 0; i < width; ++i)
{
w32_fill_area (f, hdc, gc.foreground,
right_x - i, top_y + i + 1, 1,
(bottom_y - i) - (top_y + i));
}
w32_set_clip_rectangle (hdc, NULL);
release_frame_dc (f, hdc);
}
static void
w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
left_p, right_p, clip_rect)
struct glyph_string *s;
int left_x, top_y, right_x, bottom_y, width, left_p, right_p;
RECT *clip_rect;
{
w32_set_clip_rectangle (s->hdc, clip_rect);
w32_fill_area (s->f, s->hdc, s->face->box_color,
left_x, top_y, right_x - left_x + 1, width);
if (left_p)
{
w32_fill_area (s->f, s->hdc, s->face->box_color,
left_x, top_y, width, bottom_y - top_y + 1);
}
w32_fill_area (s->f, s->hdc, s->face->box_color,
left_x, bottom_y - width + 1, right_x - left_x + 1, width);
if (right_p)
{
w32_fill_area (s->f, s->hdc, s->face->box_color,
right_x - width + 1, top_y, width, bottom_y - top_y + 1);
}
w32_set_clip_rectangle (s->hdc, NULL);
}
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;
RECT 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)));
w32_get_glyph_string_clip_rect (s, &clip_rect);
if (s->face->box == FACE_SIMPLE_BOX)
w32_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);
w32_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;
SaveDC (s->hdc);
if (s->img->pixmap)
{
#if 0
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);
w32_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 (IntersectRect (&r, &clip_rect, &image_rect))
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
#endif
{
HDC compat_hdc = CreateCompatibleDC (s->hdc);
HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
x_set_glyph_string_clipping (s);
SetTextColor (s->hdc, s->gc->foreground);
SetBkColor (s->hdc, s->gc->background);
#if 0
BitBlt (s->hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, SRCCOPY);
BitBlt (s->hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, 0xB8074A);
#else
BitBlt (s->hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, 0xE20746);
#endif
SelectObject (s->hdc, orig_brush);
DeleteObject (fg_brush);
SelectObject (compat_hdc, orig_obj);
DeleteDC (compat_hdc);
if (s->hl == DRAW_CURSOR)
w32_draw_rectangle (s->hdc, s->gc, x, y, s->img->width - 1,
s->img->height - 1);
w32_set_clip_rectangle (s->hdc, NULL);
}
}
else
w32_draw_rectangle (s->hdc, s->gc, x, y, s->img->width -1,
s->img->height - 1);
RestoreDC (s->hdc ,-1);
}
static void
x_draw_image_relief (s)
struct glyph_string *s;
{
int x0, y0, x1, y1, thick, raised_p;
RECT 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);
w32_get_glyph_string_clip_rect (s, &r);
w32_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
}
static void
w32_draw_image_foreground_1 (s, pixmap)
struct glyph_string *s;
HBITMAP pixmap;
{
HDC hdc = CreateCompatibleDC (s->hdc);
HGDIOBJ orig_hdc_obj = SelectObject (hdc, 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 0
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
#endif
{
HDC compat_hdc = CreateCompatibleDC (hdc);
HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
HBRUSH orig_brush = SelectObject (hdc, fg_brush);
HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
SetTextColor (hdc, s->gc->foreground);
SetBkColor (hdc, s->gc->background);
#if 0
BitBlt (hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, SRCCOPY);
BitBlt (hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, 0xB8074A);
#else
BitBlt (hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, 0xE20746);
#endif
SelectObject (hdc, orig_brush);
DeleteObject (fg_brush);
SelectObject (compat_hdc, orig_obj);
DeleteDC (compat_hdc);
if (s->hl == DRAW_CURSOR)
w32_draw_rectangle (hdc, s->gc, x, y, s->img->width - 1,
s->img->height - 1);
}
}
else
w32_draw_rectangle (hdc, s->gc, x, y, s->img->width - 1,
s->img->height - 1);
SelectObject (hdc, orig_hdc_obj);
DeleteDC (hdc);
}
static void
x_draw_glyph_string_bg_rect (s, x, y, w, h)
struct glyph_string *s;
int x, y, w, h;
{
#if 0
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
#endif
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;
HBITMAP pixmap = 0;
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
#if 0
|| s->img->mask
#endif
|| 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 0
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
#endif
x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
s->background_filled_p = 1;
}
if (pixmap != 0)
{
w32_draw_image_foreground_1 (s, pixmap);
x_set_glyph_string_clipping (s);
{
HDC compat_hdc = CreateCompatibleDC (s->hdc);
HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap);
SetTextColor (s->hdc, s->gc->foreground);
SetBkColor (s->hdc, s->gc->background);
#if 0
BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
compat_hdc, 0, 0, SRCCOPY);
BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
compat_hdc, 0, 0, 0xB8074A);
#else
BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
compat_hdc, 0, 0, 0xE20746);
#endif
SelectObject (s->hdc, orig_brush);
DeleteObject (fg_brush);
SelectObject (compat_hdc, orig_obj);
DeleteDC (compat_hdc);
}
DeleteObject (pixmap);
pixmap = 0;
}
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)
{
XGCValues *gc = s->face->gc;
int x = s->x + width, y = s->y;
int w = s->background_width - width, h = s->height;
RECT r;
HDC hdc = s->hdc;
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;
w32_get_glyph_string_clip_rect (s, &r);
w32_set_clip_rectangle (hdc, &r);
#if 0
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
#endif
{
w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h);
}
}
}
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
&& (s->font->bdf || !s->font->tm.tmUnderlined))
{
unsigned long h = 1;
unsigned long dy = s->height - h;
if (s->face->underline_defaulted_p)
{
w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
s->y + dy, s->width, 1);
}
else
{
w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
s->y + dy, s->width, 1);
}
}
if (s->face->overline_p)
{
unsigned long dy = 0, h = 1;
if (s->face->overline_color_defaulted_p)
{
w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
s->y + dy, s->width, h);
}
else
{
w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
s->y + dy, s->width, h);
}
}
if (s->face->strike_through_p
&& (s->font->bdf || !s->font->tm.tmStruckOut))
{
unsigned long h = 1;
unsigned long dy = (s->height - h) / 2;
if (s->face->strike_through_color_defaulted_p)
{
w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy,
s->width, h);
}
else
{
w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
s->y + dy, s->width, h);
}
}
if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
x_draw_glyph_string_box (s);
}
w32_set_clip_rectangle (s->hdc, NULL);
}
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
w32_init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
struct glyph_string *s;
HDC hdc;
wchar_t *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->hdc = hdc;
s->window = FRAME_W32_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.w32->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(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
w32_init_glyph_string (s, hdc, 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(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
w32_init_glyph_string (s, hdc, 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(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
do \
{ \
int c, face_id; \
wchar_t *char2b; \
\
c = (ROW)->glyphs[AREA][START].u.ch; \
face_id = (ROW)->glyphs[AREA][START].face_id; \
\
s = (struct glyph_string *) alloca (sizeof *s); \
char2b = (wchar_t *) alloca ((END - START) * sizeof *char2b); \
w32_init_glyph_string (s, hdc, 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(hdc, 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; \
wchar_t *char2b; \
struct face **faces; \
struct glyph_string *first_s = NULL; \
int n; \
\
base_face = base_face->ascii_face; \
char2b = (wchar_t *) 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); \
w32_init_glyph_string (s, hdc, 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(hdc, 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 (hdc, W, ROW, AREA, START, END, \
HEAD, TAIL, HL, X, LAST_X, \
OVERLAPS_P); \
break; \
\
case COMPOSITE_GLYPH: \
BUILD_COMPOSITE_GLYPH_STRING (hdc, W, ROW, AREA, START, \
END, HEAD, TAIL, HL, X, \
LAST_X, OVERLAPS_P); \
break; \
\
case STRETCH_GLYPH: \
BUILD_STRETCH_GLYPH_STRING (hdc, W, ROW, AREA, START, END,\
HEAD, TAIL, HL, X, LAST_X); \
break; \
\
case IMAGE_GLYPH: \
BUILD_IMAGE_GLYPH_STRING (hdc, 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;
HDC hdc = get_frame_dc (XFRAME (WINDOW_FRAME (w)));
end = min (end, row->used[area]);
start = max (0, start);
start = min (end, start);
if (row->full_width_p)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
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 (hdc, 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 (hdc, 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 (hdc, 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 (hdc, 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 (hdc, 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 (!row->full_width_p && 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)
x_reached -= window_box_width (w, LEFT_MARGIN_AREA);
if (area > TEXT_AREA)
x_reached -= window_box_width (w, TEXT_AREA);
}
release_frame_dc (XFRAME (WINDOW_FRAME (w)), hdc);
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;
HDC hdc;
xassert (updated_window && updated_row);
BLOCK_INPUT;
w = updated_window;
f = XFRAME (WINDOW_FRAME (w));
hdc = get_frame_dc (f);
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);
BitBlt (hdc, frame_x + shift_by_width, frame_y,
shifted_region_width, line_height,
hdc, frame_x, frame_y, SRCCOPY);
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;
release_frame_dc (f, hdc);
UNBLOCK_INPUT;
}
static void
x_delete_glyphs (n)
register int n;
{
struct frame *f;
if (updating_frame)
f = updating_frame;
else
f = SELECTED_FRAME ();
if (! FRAME_W32_P (f))
return;
abort ();
}
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)
{
HDC hdc;
BLOCK_INPUT;
hdc = get_frame_dc (f);
w32_clear_area (f, hdc, from_x, from_y, to_x - from_x, to_y - from_y);
release_frame_dc (f, hdc);
UNBLOCK_INPUT;
}
}
static void
x_clear_frame ()
{
struct frame *f;
if (updating_frame)
f = updating_frame;
else
f = SELECTED_FRAME ();
if (! FRAME_W32_P (f))
return;
mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
output_cursor.hpos = output_cursor.vpos = 0;
output_cursor.x = -1;
BLOCK_INPUT;
w32_clear_window (f);
x_scroll_bar_clear (f);
UNBLOCK_INPUT;
}
static void
w32_ring_bell (void)
{
struct frame *f;
f = SELECTED_FRAME ();
BLOCK_INPUT;
if (FRAME_W32_P (f) && visible_bell)
{
int i;
HWND hwnd = FRAME_W32_WINDOW (SELECTED_FRAME ());
for (i = 0; i < 5; i++)
{
FlashWindow (hwnd, TRUE);
Sleep (10);
}
FlashWindow (hwnd, FALSE);
}
else
w32_sys_ring_bell ();
UNBLOCK_INPUT;
}
static void
w32_set_terminal_window (n)
register int n;
{
}
static void
x_ins_del_lines (vpos, n)
int vpos, n;
{
struct frame *f;
if (updating_frame)
f = updating_frame;
else
f = SELECTED_FRAME ();
if (! FRAME_W32_P (f))
return;
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;
HWND hwnd = FRAME_W32_WINDOW (f);
HRGN expect_dirty;
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;
expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y);
}
else
{
if (to_y + run->height > bottom_y)
height = bottom_y - to_y;
else
height = run->height;
expect_dirty = CreateRectRgn (x, y, x + width, to_y);
}
BLOCK_INPUT;
updated_window = w;
x_clear_cursor (w);
#if 0
{
RECT from;
RECT to;
HRGN dirty = CreateRectRgn (0, 0, 0, 0);
HRGN combined = CreateRectRgn (0, 0, 0, 0);
from.left = to.left = x;
from.right = to.right = x + width;
from.top = from_y;
from.bottom = from_y + height;
to.top = y;
to.bottom = bottom_y;
ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty,
NULL, SW_INVALIDATE);
CombineRgn (combined, dirty, expect_dirty, RGN_OR);
if (!EqualRgn (combined, expect_dirty))
SET_FRAME_GARBAGED (f);
}
#else
{
HDC hdc = get_frame_dc (f);
BitBlt (hdc, x, to_y, width, height, hdc, x, from_y, SRCCOPY);
release_frame_dc (f, hdc);
}
#endif
UNBLOCK_INPUT;
}
static void
expose_frame (f, x, y, w, h)
struct frame *f;
int x, y, w, h;
{
RECT 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.left = r.top = 0;
r.right = CANON_X_UNIT (f) * f->width;
r.bottom = CANON_Y_UNIT (f) * f->height;
}
else
{
r.left = x;
r.top = y;
r.right = x + w;
r.bottom = y + h;
}
TRACE ((stderr, "(%d, %d, %d, %d)\n", r.left, r.top, r.right, r.bottom));
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);
}
static int
expose_window_tree (w, r)
struct window *w;
RECT *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;
RECT *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->left)
{
x += first->pixel_width;
++first;
}
last = first;
first_x = x;
while (last < end
&& x < r->right)
{
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;
RECT *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;
RECT *r;
{
RECT cr, result;
struct glyph *cursor_glyph;
cursor_glyph = get_phys_cursor_glyph (w);
if (cursor_glyph)
{
cr.left = w->phys_cursor.x;
cr.top = w->phys_cursor.y;
cr.right = cr.left + cursor_glyph->pixel_width;
cr.bottom = cr.top + w->phys_cursor_height;
return IntersectRect (&result, &cr, r);
}
else
return 0;
}
static int
expose_window (w, fr)
struct window *w;
RECT *fr;
{
struct frame *f = XFRAME (w->frame);
RECT 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.left = XFASTINT (w->left) * CANON_X_UNIT (f);
wr.top = XFASTINT (w->top) * CANON_Y_UNIT (f);
wr.right = wr.left + XFASTINT (w->width) * CANON_X_UNIT (f);
wr.bottom = wr.top + XFASTINT (w->height) * CANON_Y_UNIT (f);
if (IntersectRect(&r, fr, &wr))
{
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.left, r.top, r.right, r.bottom));
r.left = FRAME_TO_WINDOW_PIXEL_X (w, r.left);
r.right = FRAME_TO_WINDOW_PIXEL_X (w, r.right);
r.top = FRAME_TO_WINDOW_PIXEL_Y (w, r.top);
r.bottom = FRAME_TO_WINDOW_PIXEL_Y (w, r.bottom);
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.top && y0 < r.bottom)
|| (y1 > r.top && y1 < r.bottom)
|| (r.top >= y0 && r.top < y1)
|| (r.bottom > y0 && r.bottom < 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.bottom)
{
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 void
frame_highlight (f)
struct frame *f;
{
x_update_cursor (f, 1);
}
static void
frame_unhighlight (f)
struct frame *f;
{
x_update_cursor (f, 1);
}
static void
x_new_focus_frame (dpyinfo, frame)
struct w32_display_info *dpyinfo;
struct frame *frame;
{
struct frame *old_focus = dpyinfo->w32_focus_frame;
if (frame != dpyinfo->w32_focus_frame)
{
dpyinfo->w32_focus_frame = frame;
if (old_focus && old_focus->auto_lower)
x_lower_frame (old_focus);
if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise)
pending_autoraise_frame = dpyinfo->w32_focus_frame;
else
pending_autoraise_frame = 0;
}
x_frame_rehighlight (dpyinfo);
}
void
x_mouse_leave (dpyinfo)
struct w32_display_info *dpyinfo;
{
x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame);
}
static void
w32_frame_rehighlight (frame)
struct frame *frame;
{
if (! FRAME_W32_P (frame))
return;
x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame));
}
static void
x_frame_rehighlight (dpyinfo)
struct w32_display_info *dpyinfo;
{
struct frame *old_highlight = dpyinfo->w32_highlight_frame;
if (dpyinfo->w32_focus_frame)
{
dpyinfo->w32_highlight_frame
= ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)))
? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))
: dpyinfo->w32_focus_frame);
if (! FRAME_LIVE_P (dpyinfo->w32_highlight_frame))
{
FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame) = Qnil;
dpyinfo->w32_highlight_frame = dpyinfo->w32_focus_frame;
}
}
else
dpyinfo->w32_highlight_frame = 0;
if (dpyinfo->w32_highlight_frame != old_highlight)
{
if (old_highlight)
frame_unhighlight (old_highlight);
if (dpyinfo->w32_highlight_frame)
frame_highlight (dpyinfo->w32_highlight_frame);
}
}
char *
x_get_keysym_name (keysym)
int keysym;
{
static char value[100];
BLOCK_INPUT;
GetKeyNameText (keysym, value, 100);
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;
RECT *bounds;
int noclip;
{
if (NILP (Vwindow_system))
{
*x = pix_x;
*y = pix_y;
return;
}
if (pix_x < 0)
pix_x -= FONT_WIDTH (FRAME_FONT (f)) - 1;
if (pix_y < 0)
pix_y -= (f)->output_data.w32->line_height - 1;
pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
if (bounds)
{
bounds->left = CHAR_TO_PIXEL_COL (f, pix_x);
bounds->top = CHAR_TO_PIXEL_ROW (f, pix_y);
bounds->right = bounds->left + FONT_WIDTH (FRAME_FONT (f)) - 1;
bounds->bottom = bounds->top + f->output_data.w32->line_height - 1;
}
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;
}
BOOL
parse_button (message, pbutton, pup)
int message;
int * pbutton;
int * pup;
{
int button = 0;
int up = 0;
switch (message)
{
case WM_LBUTTONDOWN:
button = 0;
up = 0;
break;
case WM_LBUTTONUP:
button = 0;
up = 1;
break;
case WM_MBUTTONDOWN:
if (NILP (Vw32_swap_mouse_buttons))
button = 1;
else
button = 2;
up = 0;
break;
case WM_MBUTTONUP:
if (NILP (Vw32_swap_mouse_buttons))
button = 1;
else
button = 2;
up = 1;
break;
case WM_RBUTTONDOWN:
if (NILP (Vw32_swap_mouse_buttons))
button = 2;
else
button = 1;
up = 0;
break;
case WM_RBUTTONUP:
if (NILP (Vw32_swap_mouse_buttons))
button = 2;
else
button = 1;
up = 1;
break;
default:
return (FALSE);
}
if (pup) *pup = up;
if (pbutton) *pbutton = button;
return (TRUE);
}
static Lisp_Object
construct_mouse_click (result, msg, f)
struct input_event *result;
W32Msg *msg;
struct frame *f;
{
int button;
int up;
parse_button (msg->msg.message, &button, &up);
result->kind = mouse_click;
result->code = button;
result->timestamp = msg->msg.time;
result->modifiers = (msg->dwModifiers
| (up
? up_modifier
: down_modifier));
XSETINT (result->x, LOWORD (msg->msg.lParam));
XSETINT (result->y, HIWORD (msg->msg.lParam));
XSETFRAME (result->frame_or_window, f);
result->arg = Qnil;
return Qnil;
}
static Lisp_Object
construct_mouse_wheel (result, msg, f)
struct input_event *result;
W32Msg *msg;
struct frame *f;
{
POINT p;
result->kind = mouse_wheel;
result->code = (short) HIWORD (msg->msg.wParam);
result->timestamp = msg->msg.time;
result->modifiers = msg->dwModifiers;
p.x = LOWORD (msg->msg.lParam);
p.y = HIWORD (msg->msg.lParam);
ScreenToClient (msg->msg.hwnd, &p);
XSETINT (result->x, p.x);
XSETINT (result->y, p.y);
XSETFRAME (result->frame_or_window, f);
result->arg = Qnil;
return Qnil;
}
static Lisp_Object
construct_drag_n_drop (result, msg, f)
struct input_event *result;
W32Msg *msg;
struct frame *f;
{
Lisp_Object files;
Lisp_Object frame;
HDROP hdrop;
POINT p;
WORD num_files;
char *name;
int i, len;
result->kind = drag_n_drop;
result->code = 0;
result->timestamp = msg->msg.time;
result->modifiers = msg->dwModifiers;
hdrop = (HDROP) msg->msg.wParam;
DragQueryPoint (hdrop, &p);
#if 0
p.x = LOWORD (msg->msg.lParam);
p.y = HIWORD (msg->msg.lParam);
ScreenToClient (msg->msg.hwnd, &p);
#endif
XSETINT (result->x, p.x);
XSETINT (result->y, p.y);
num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
files = Qnil;
for (i = 0; i < num_files; i++)
{
len = DragQueryFile (hdrop, i, NULL, 0);
if (len <= 0)
continue;
name = alloca (len + 1);
DragQueryFile (hdrop, i, name, len + 1);
files = Fcons (build_string (name), files);
}
DragFinish (hdrop);
XSETFRAME (frame, f);
result->frame_or_window = Fcons (frame, files);
result->arg = Qnil;
return Qnil;
}
static MSG last_mouse_motion_event;
static Lisp_Object last_mouse_motion_frame;
static void remember_mouse_glyph P_ ((struct frame *, int, int));
static void
note_mouse_movement (frame, msg)
FRAME_PTR frame;
MSG *msg;
{
int mouse_x = LOWORD (msg->lParam);
int mouse_y = HIWORD (msg->lParam);
last_mouse_movement_time = msg->time;
memcpy (&last_mouse_motion_event, msg, sizeof (last_mouse_motion_event));
XSETFRAME (last_mouse_motion_frame, frame);
if (msg->hwnd != FRAME_W32_WINDOW (frame))
{
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
note_mouse_highlight (frame, -1, -1);
}
else if (mouse_x < last_mouse_glyph.left
|| mouse_x > last_mouse_glyph.right
|| mouse_y < last_mouse_glyph.top
|| mouse_y > last_mouse_glyph.bottom)
{
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
note_mouse_highlight (frame, mouse_x, mouse_y);
remember_mouse_glyph (frame, mouse_x, mouse_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 w32_display_info *dpyinfo = FRAME_W32_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.w32->nontext_cursor;
else
{
map = Fget_text_property (make_number (glyph->charpos),
Qkeymap, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.w32->nontext_cursor;
}
}
}
#if 0
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
#endif
}
static void
note_mouse_highlight (f, x, y)
struct frame *f;
int x, y;
{
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
int portion;
Lisp_Object window;
struct window *w;
struct buffer *b;
if (popup_activated ())
return;
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;
help_echo = Qnil;
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 0
else if (portion == 2)
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->horizontal_drag_cursor);
else
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->text_cursor);
#endif
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)
{
clear_mouse_face (dpyinfo);
return;
}
pos = glyph->charpos;
object = glyph->object;
if (!STRINGP (object) && !BUFFERP (object))
return;
if (BUFFERP (object) && pos > BUF_Z (b))
return;
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
|| (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;
clear_mouse_face (dpyinfo);
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);
}
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);
}
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);
}
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);
}
}
}
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 (glyph->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;
}
}
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),
LOWORD (last_mouse_motion_event.lParam),
HIWORD (last_mouse_motion_event.lParam));
}
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 w32_display_info *dpyinfo = FRAME_W32_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
w32_handle_tool_bar_click (f, button_event)
struct frame *f;
struct input_event *button_event;
{
struct w32_display_info *dpyinfo = FRAME_W32_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 = XFASTINT (button_event->x);
int y = XFASTINT (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->kind == mouse_click)
{
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 = button_event->modifiers;
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 w32_display_info *dpyinfo = FRAME_W32_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 = DRAW_IMAGE_RAISED;
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);
}
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;
}
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 w32_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 == 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 0
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);
#endif
}
static int
clear_mouse_face (dpyinfo)
struct w32_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 w32_display_info *dpyinfo
= FRAME_W32_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 w32_display_info *dpyinfo = FRAME_W32_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 struct scroll_bar *x_window_to_scroll_bar ();
static void x_scroll_bar_report_motion ();
static int glyph_rect P_ ((struct frame *f, int, int, RECT *));
static int
glyph_rect (f, x, y, rect)
struct frame *f;
int x, y;
RECT *rect;
{
Lisp_Object window;
int part;
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;
frame_to_window_pixel_xy (w, &x, &y);
for (; r < end && r->enabled_p; ++r)
if (r->y <= y && r->y + r->height > y)
{
struct glyph *g = r->glyphs[TEXT_AREA];
struct glyph *end = g + r->used[TEXT_AREA];
int gx;
rect->top = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
rect->bottom = rect->top + r->height;
if (x < r->x)
{
rect->left = XINT (w->left);
rect->right = WINDOW_TO_FRAME_PIXEL_X (w, r->x);
return 1;
}
for (gx = r->x; g < end; gx += g->pixel_width, ++g)
if (gx <= x && gx + g->pixel_width > x)
{
rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
rect->right = rect->left + g->pixel_width;
return 1;
}
rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
rect->right = XINT (w->left) + XINT (w->width);
return 1;
}
}
return 0;
}
static void
remember_mouse_glyph (f1, gx, gy)
struct frame * f1;
int gx, gy;
{
if (!glyph_rect (f1, gx, gy, &last_mouse_glyph))
{
int width = FRAME_SMALLEST_CHAR_WIDTH (f1);
int height = FRAME_SMALLEST_FONT_HEIGHT (f1);
if (gx < 0)
gx -= width - 1;
if (gy < 0)
gy -= height - 1;
#if 0
gx = (gx + width - 1) / width * width;
gy = (gy + height - 1) / height * height;
#else
gx = gx / width * width;
gy = gy / height * height;
#endif
last_mouse_glyph.left = gx;
last_mouse_glyph.top = gy;
last_mouse_glyph.right = gx + width;
last_mouse_glyph.bottom = gy + height;
}
}
static void
w32_mouse_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
{
POINT pt;
Lisp_Object frame, tail;
FOR_EACH_FRAME (tail, frame)
XFRAME (frame)->mouse_moved = 0;
last_mouse_scroll_bar = Qnil;
GetCursorPos (&pt);
{
if (FRAME_W32_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
{
f1 = last_mouse_frame;
}
else
{
f1 = x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp),
WindowFromPoint (pt));
}
if (! f1)
{
struct scroll_bar *bar
= x_window_to_scroll_bar (WindowFromPoint (pt));
if (bar)
{
f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
}
}
if (f1 == 0 && insist > 0)
f1 = SELECTED_FRAME ();
if (f1)
{
#if OLD_REDISPLAY_CODE
int ignore1, ignore2;
ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
pixel_to_glyph_coords (f1, pt.x, pt.y, &ignore1, &ignore2,
&last_mouse_glyph,
FRAME_W32_DISPLAY_INFO (f1)->grabbed
|| insist);
#else
ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
remember_mouse_glyph (f1, pt.x, pt.y);
#endif
*bar_window = Qnil;
*part = 0;
*fp = f1;
XSETINT (*x, pt.x);
XSETINT (*y, pt.y);
*time = last_mouse_movement_time;
}
}
}
UNBLOCK_INPUT;
}
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_W32_WINDOW (XSCROLL_BAR (bar)) == window_id)
return XSCROLL_BAR (bar);
}
return 0;
}
static void
w32_set_scroll_bar_thumb (bar, portion, position, whole)
struct scroll_bar *bar;
int portion, position, whole;
{
Window w = SCROLL_BAR_W32_WINDOW (bar);
double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
int sb_page, sb_pos;
BOOL draggingp = !NILP (bar->dragging) ? TRUE : FALSE;
if (whole)
{
if (position + portion >= whole)
{
sb_page = range * (whole - position) / whole
+ VERTICAL_SCROLL_BAR_MIN_HANDLE;
sb_pos = range;
}
sb_page = portion * range / whole + VERTICAL_SCROLL_BAR_MIN_HANDLE;
sb_pos = position * range / whole;
}
else
{
sb_page = range;
sb_pos = 0;
}
BLOCK_INPUT;
if (pfnSetScrollInfo)
{
SCROLLINFO si;
si.cbSize = sizeof (si);
if (draggingp)
si.fMask = SIF_PAGE;
else
si.fMask = SIF_PAGE | SIF_POS;
si.nPage = sb_page;
si.nPos = sb_pos;
pfnSetScrollInfo (w, SB_CTL, &si, !draggingp);
}
else
SetScrollPos (w, SB_CTL, sb_pos, !draggingp);
UNBLOCK_INPUT;
}
HWND
my_create_scrollbar (f, bar)
struct frame * f;
struct scroll_bar * bar;
{
return (HWND) SendMessage (FRAME_W32_WINDOW (f),
WM_EMACS_CREATESCROLLBAR, (WPARAM) f,
(LPARAM) bar);
}
BOOL
my_show_window (FRAME_PTR f, HWND hwnd, int how)
{
#ifndef ATTACH_THREADS
return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW,
(WPARAM) hwnd, (LPARAM) how);
#else
return ShowWindow (hwnd, how);
#endif
}
void
my_set_window_pos (HWND hwnd, HWND hwndAfter,
int x, int y, int cx, int cy, UINT flags)
{
#ifndef ATTACH_THREADS
WINDOWPOS pos;
pos.hwndInsertAfter = hwndAfter;
pos.x = x;
pos.y = y;
pos.cx = cx;
pos.cy = cy;
pos.flags = flags;
SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0);
#else
SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags);
#endif
}
void
my_set_focus (f, hwnd)
struct frame * f;
HWND hwnd;
{
SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS,
(WPARAM) hwnd, 0);
}
void
my_set_foreground_window (hwnd)
HWND hwnd;
{
SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0);
}
void
my_destroy_window (f, hwnd)
struct frame * f;
HWND hwnd;
{
SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW,
(WPARAM) hwnd, 0);
}
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 (WINDOW_FRAME (w));
HWND hwnd;
struct scroll_bar *bar
= XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
BLOCK_INPUT;
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;
hwnd = my_create_scrollbar (f, bar);
if (pfnSetScrollInfo)
{
SCROLLINFO si;
si.cbSize = sizeof (si);
si.fMask = SIF_ALL;
si.nMin = 0;
si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
+ VERTICAL_SCROLL_BAR_MIN_HANDLE;
si.nPage = si.nMax;
si.nPos = 0;
pfnSetScrollInfo (hwnd, SB_CTL, &si, FALSE);
}
else
{
SetScrollRange (hwnd, SB_CTL, 0,
VERTICAL_SCROLL_BAR_TOP_RANGE (f, height), FALSE);
SetScrollPos (hwnd, SB_CTL, 0, FALSE);
}
SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
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);
UNBLOCK_INPUT;
return bar;
}
static void
x_scroll_bar_remove (bar)
struct scroll_bar *bar;
{
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
BLOCK_INPUT;
my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
UNBLOCK_INPUT;
}
static void
w32_set_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;
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;
if (NILP (w->vertical_scroll_bar))
{
HDC hdc;
BLOCK_INPUT;
if (width && height)
{
hdc = get_frame_dc (f);
w32_clear_area (f, hdc, left, top, width, height);
release_frame_dc (f, hdc);
}
UNBLOCK_INPUT;
bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
}
else
{
HWND hwnd;
bar = XSCROLL_BAR (w->vertical_scroll_bar);
hwnd = SCROLL_BAR_W32_WINDOW (bar);
if ( XINT (bar->left) == sb_left
&& XINT (bar->top) == top
&& XINT (bar->width) == sb_width
&& XINT (bar->height) == height )
{
if (!my_show_window (f, hwnd, SW_NORMAL))
InvalidateRect (hwnd, NULL, FALSE);
}
else
{
HDC hdc;
BLOCK_INPUT;
if (width > 0 && height > 0)
{
hdc = get_frame_dc (f);
w32_clear_area (f, hdc,
left,
top,
width,
height);
release_frame_dc (f, hdc);
}
my_show_window (f, hwnd, SW_HIDE);
MoveWindow (hwnd, sb_left, top,
sb_width, max (height, 1), TRUE);
if (pfnSetScrollInfo)
{
SCROLLINFO si;
si.cbSize = sizeof (si);
si.fMask = SIF_RANGE;
si.nMin = 0;
si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
+ VERTICAL_SCROLL_BAR_MIN_HANDLE;
pfnSetScrollInfo (hwnd, SB_CTL, &si, FALSE);
}
else
SetScrollRange (hwnd, SB_CTL, 0,
VERTICAL_SCROLL_BAR_TOP_RANGE (f, height), FALSE);
my_show_window (f, hwnd, SW_NORMAL);
XSETINT (bar->left, sb_left);
XSETINT (bar->top, top);
XSETINT (bar->width, sb_width);
XSETINT (bar->height, height);
UNBLOCK_INPUT;
}
}
w32_set_scroll_bar_thumb (bar, portion, position, whole);
XSETVECTOR (w->vertical_scroll_bar, bar);
}
static void
w32_condemn_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
w32_redeem_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
w32_judge_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 int
w32_scroll_bar_handle_click (bar, msg, emacs_event)
struct scroll_bar *bar;
W32Msg *msg;
struct input_event *emacs_event;
{
if (! GC_WINDOWP (bar->window))
abort ();
emacs_event->kind = w32_scroll_bar_click;
emacs_event->code = 0;
emacs_event->modifiers = msg->dwModifiers;
emacs_event->frame_or_window = bar->window;
emacs_event->arg = Qnil;
emacs_event->timestamp = msg->msg.time;
{
int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
int y;
int dragging = !NILP (bar->dragging);
if (pfnGetScrollInfo)
{
SCROLLINFO si;
si.cbSize = sizeof (si);
si.fMask = SIF_POS;
pfnGetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
y = si.nPos;
}
else
y = GetScrollPos ((HWND) msg->msg.lParam, SB_CTL);
bar->dragging = Qnil;
last_mouse_scroll_bar_pos = msg->msg.wParam;
switch (LOWORD (msg->msg.wParam))
{
case SB_LINEDOWN:
emacs_event->part = scroll_bar_down_arrow;
break;
case SB_LINEUP:
emacs_event->part = scroll_bar_up_arrow;
break;
case SB_PAGEUP:
emacs_event->part = scroll_bar_above_handle;
break;
case SB_PAGEDOWN:
emacs_event->part = scroll_bar_below_handle;
break;
case SB_TOP:
emacs_event->part = scroll_bar_handle;
y = 0;
break;
case SB_BOTTOM:
emacs_event->part = scroll_bar_handle;
y = top_range;
break;
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
y = HIWORD (msg->msg.wParam);
bar->dragging = Qt;
emacs_event->part = scroll_bar_handle;
if (pfnSetScrollInfo)
{
SCROLLINFO si;
si.cbSize = sizeof (si);
si.fMask = SIF_POS;
si.nPos = y;
last_scroll_bar_drag_pos = y;
pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
}
else
SetScrollPos (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, y, FALSE);
break;
case SB_ENDSCROLL:
if (dragging)
{
if (pfnSetScrollInfo)
{
SCROLLINFO si;
int start = XINT (bar->start);
int end = XINT (bar->end);
si.cbSize = sizeof (si);
si.fMask = SIF_PAGE | SIF_POS;
si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
si.nPos = last_scroll_bar_drag_pos;
pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
}
else
SetScrollPos (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, y, TRUE);
}
default:
emacs_event->kind = no_event;
return FALSE;
}
XSETINT (emacs_event->x, y);
XSETINT (emacs_event->y, top_range);
return TRUE;
}
}
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_W32_WINDOW (bar);
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
int pos;
int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
BLOCK_INPUT;
*fp = f;
*bar_window = bar->window;
if (pfnGetScrollInfo)
{
SCROLLINFO si;
si.cbSize = sizeof (si);
si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
pfnGetScrollInfo (w, SB_CTL, &si);
pos = si.nPos;
top_range = si.nMax - si.nPage + 1;
}
else
pos = GetScrollPos (w, SB_CTL);
switch (LOWORD (last_mouse_scroll_bar_pos))
{
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
*part = scroll_bar_handle;
if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
pos = HIWORD (last_mouse_scroll_bar_pos);
break;
case SB_LINEDOWN:
*part = scroll_bar_handle;
pos++;
break;
default:
*part = scroll_bar_handle;
break;
}
XSETINT (*x, pos);
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;
{
Lisp_Object bar;
if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
bar = XSCROLL_BAR (bar)->next)
{
HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
HDC hdc = GetDC (window);
RECT rect;
my_show_window (f, window, SW_HIDE);
GetClientRect (window, &rect);
select_palette (f, hdc);
w32_clear_rect (f, hdc, &rect);
deselect_palette (f, hdc);
ReleaseDC (window, hdc);
}
}
static Time enter_timestamp;
static int temp_index;
static short temp_buffer[100];
int
w32_read_socket (sd, bufp, numchars, expected)
register int sd;
struct input_event *bufp;
int numchars;
int expected;
{
int count = 0;
int check_visibility = 0;
W32Msg msg;
struct frame *f;
struct w32_display_info *dpyinfo = &one_w32_display_info;
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
return -1;
}
interrupt_input_pending = 0;
BLOCK_INPUT;
input_signal_count++;
if (numchars <= 0)
abort ();
while (get_next_msg (&msg, FALSE))
{
switch (msg.msg.message)
{
case WM_PAINT:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if (msg.rect.right == msg.rect.left ||
msg.rect.bottom == msg.rect.top)
{
DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
XSTRING (f->name)->data));
}
else if (f->async_visible != 1)
{
f->async_visible = 1;
f->async_iconified = 0;
SET_FRAME_GARBAGED (f);
DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
XSTRING (f->name)->data));
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 ();
}
else
{
HDC hdc = get_frame_dc (f);
w32_clear_rect (f, hdc, &msg.rect);
release_frame_dc (f, hdc);
expose_frame (f,
msg.rect.left,
msg.rect.top,
msg.rect.right - msg.rect.left,
msg.rect.bottom - msg.rect.top);
}
}
break;
case WM_INPUTLANGCHANGE:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if (numchars == 0)
abort ();
bufp->kind = language_change_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp->code = msg.msg.wParam;
bufp->modifiers = msg.msg.lParam & 0xffff;
bufp++;
count++;
numchars--;
}
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f && !f->iconified)
{
if (temp_index == sizeof temp_buffer / sizeof (short))
temp_index = 0;
temp_buffer[temp_index++] = msg.msg.wParam;
bufp->kind = non_ascii_keystroke;
bufp->code = msg.msg.wParam;
bufp->modifiers = msg.dwModifiers;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp->timestamp = msg.msg.time;
bufp++;
numchars--;
count++;
}
break;
case WM_SYSCHAR:
case WM_CHAR:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f && !f->iconified)
{
if (temp_index == sizeof temp_buffer / sizeof (short))
temp_index = 0;
temp_buffer[temp_index++] = msg.msg.wParam;
bufp->kind = ascii_keystroke;
bufp->code = msg.msg.wParam;
bufp->modifiers = msg.dwModifiers;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp->timestamp = msg.msg.time;
bufp++;
numchars--;
count++;
}
break;
case WM_MOUSEMOVE:
previous_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, msg.msg.hwnd);
if (f)
note_mouse_movement (f, &msg.msg);
else
{
clear_mouse_face (dpyinfo);
}
if (help_echo != 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;
}
break;
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
{
struct input_event emacs_event;
int tool_bar_p = 0;
int button;
int up;
emacs_event.kind = no_event;
if (dpyinfo->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
f = last_mouse_frame;
else
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
construct_mouse_click (&emacs_event, &msg, f);
if (WINDOWP (f->tool_bar_window)
&& XFASTINT (XWINDOW (f->tool_bar_window)->height))
{
Lisp_Object window;
int p;
window = window_from_coordinates (f,
emacs_event.x,
emacs_event.y,
&p, 1);
if (EQ (window, f->tool_bar_window))
{
w32_handle_tool_bar_click (f, &emacs_event);
tool_bar_p = 1;
}
}
if (!tool_bar_p)
if (!dpyinfo->w32_focus_frame
|| f == dpyinfo->w32_focus_frame
&& (numchars >= 1))
{
construct_mouse_click (bufp, &msg, f);
bufp++;
count++;
numchars--;
}
}
parse_button (msg.msg.message, &button, &up);
if (up)
{
dpyinfo->grabbed &= ~ (1 << button);
}
else
{
dpyinfo->grabbed |= (1 << button);
last_mouse_frame = f;
if (f != 0)
f->mouse_moved = 0;
if (!tool_bar_p)
last_tool_bar_item = -1;
}
break;
}
case WM_MOUSEWHEEL:
if (dpyinfo->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
f = last_mouse_frame;
else
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if ((!dpyinfo->w32_focus_frame
|| f == dpyinfo->w32_focus_frame)
&& (numchars >= 1))
{
construct_mouse_wheel (bufp, &msg, f);
bufp++;
count++;
numchars--;
}
}
break;
case WM_MENUSELECT:
{
HMENU menu = (HMENU) msg.msg.lParam;
UINT menu_item = (UINT) LOWORD (msg.msg.wParam);
UINT flags = (UINT) HIWORD (msg.msg.wParam);
w32_menu_display_help (menu, menu_item, flags);
}
break;
case WM_DROPFILES:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
construct_drag_n_drop (bufp, &msg, f);
bufp++;
count++;
numchars--;
}
break;
case WM_VSCROLL:
{
struct scroll_bar *bar =
x_window_to_scroll_bar ((HWND)msg.msg.lParam);
if (bar && numchars >= 1)
{
if (w32_scroll_bar_handle_click (bar, &msg, bufp))
{
bufp++;
count++;
numchars--;
}
}
break;
}
case WM_WINDOWPOSCHANGED:
case WM_ACTIVATE:
case WM_ACTIVATEAPP:
check_visibility = 1;
break;
case WM_MOVE:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f && !f->async_iconified)
{
int x, y;
x_real_positions (f, &x, &y);
f->output_data.w32->left_pos = x;
f->output_data.w32->top_pos = y;
}
check_visibility = 1;
break;
case WM_SHOWWINDOW:
#if 0
if (msg.msg.lParam != 0)
check_visibility = 1;
else
{
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
f->async_visible = msg.msg.wParam;
}
#endif
check_visibility = 1;
break;
case WM_SIZE:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
switch (msg.msg.wParam)
{
case SIZE_MINIMIZED:
f->async_visible = 0;
f->async_iconified = 1;
bufp->kind = iconify_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp++;
count++;
numchars--;
break;
case SIZE_MAXIMIZED:
case SIZE_RESTORED:
f->async_visible = 1;
f->async_iconified = 0;
SET_FRAME_GARBAGED (f);
if (f->iconified)
{
int x, y;
x_real_positions (f, &x, &y);
f->output_data.w32->left_pos = x;
f->output_data.w32->top_pos = y;
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 ();
break;
}
}
if (f && !f->async_iconified && msg.msg.wParam != SIZE_MINIMIZED)
{
RECT rect;
int rows;
int columns;
int width;
int height;
GetClientRect (msg.msg.hwnd, &rect);
height = rect.bottom - rect.top;
width = rect.right - rect.left;
rows = PIXEL_TO_CHAR_HEIGHT (f, height);
columns = PIXEL_TO_CHAR_WIDTH (f, width);
if (columns != f->width
|| rows != f->height
|| width != f->output_data.w32->pixel_width
|| height != f->output_data.w32->pixel_height)
{
change_frame_size (f, rows, columns, 0, 1, 0);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
f->output_data.w32->pixel_width = width;
f->output_data.w32->pixel_height = height;
f->output_data.w32->win_gravity = NorthWestGravity;
}
}
check_visibility = 1;
break;
case WM_SETFOCUS:
f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
dpyinfo->w32_focus_event_frame = f;
if (f)
x_new_focus_frame (dpyinfo, f);
dpyinfo->grabbed = 0;
check_visibility = 1;
break;
case WM_KILLFOCUS:
f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if (f == dpyinfo->w32_focus_event_frame)
dpyinfo->w32_focus_event_frame = 0;
if (f == dpyinfo->w32_focus_frame)
x_new_focus_frame (dpyinfo, 0);
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;
}
}
dpyinfo->grabbed = 0;
check_visibility = 1;
break;
case WM_CLOSE:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if (numchars == 0)
abort ();
bufp->kind = delete_window_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp++;
count++;
numchars--;
}
break;
case WM_INITMENU:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if (numchars == 0)
abort ();
bufp->kind = menu_bar_activate_event;
XSETFRAME (bufp->frame_or_window, f);
bufp->arg = Qnil;
bufp++;
count++;
numchars--;
}
break;
case WM_COMMAND:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
extern void menubar_selection_callback
(FRAME_PTR f, void * client_data);
menubar_selection_callback (f, (void *)msg.msg.wParam);
}
check_visibility = 1;
break;
case WM_DISPLAYCHANGE:
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
dpyinfo->width = (short) LOWORD (msg.msg.lParam);
dpyinfo->height = (short) HIWORD (msg.msg.lParam);
dpyinfo->n_cbits = msg.msg.wParam;
DebPrint (("display change: %d %d\n", dpyinfo->width,
dpyinfo->height));
}
check_visibility = 1;
break;
default:
if (msg.msg.message == msh_mousewheel)
{
if (dpyinfo->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
f = last_mouse_frame;
else
f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
if ((!dpyinfo->w32_focus_frame
|| f == dpyinfo->w32_focus_frame)
&& (numchars >= 1))
{
construct_mouse_wheel (bufp, &msg, f);
bufp++;
count++;
numchars--;
}
}
}
break;
}
}
if (pending_autoraise_frame)
{
x_raise_frame (pending_autoraise_frame);
pending_autoraise_frame = 0;
}
if (count > 0 || check_visibility)
{
Lisp_Object tail, frame;
FOR_EACH_FRAME (tail, frame)
{
FRAME_PTR f = XFRAME (frame);
if (FRAME_W32_P (f) && f->async_visible)
{
RECT clipbox;
HDC hdc;
enter_crit ();
hdc = GetWindowDC (FRAME_W32_WINDOW (f));
GetClipBox (hdc, &clipbox);
ReleaseDC (FRAME_W32_WINDOW (f), hdc);
leave_crit ();
if (clipbox.right == clipbox.left
|| clipbox.bottom == clipbox.top)
{
f->async_visible = 2;
if (!FRAME_OBSCURED_P (f))
{
DebPrint (("frame %p (%s) obscured\n", f,
XSTRING (f->name)->data));
}
}
else
{
f->async_visible = 1;
if (FRAME_OBSCURED_P (f))
{
SET_FRAME_GARBAGED (f);
DebPrint (("obscured frame %p (%s) found to be visible\n", f,
XSTRING (f->name)->data));
record_asynch_buffer_change ();
}
}
}
}
}
UNBLOCK_INPUT;
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
w32_clip_to_row (w, row, hdc, whole_line_p)
struct window *w;
struct glyph_row *row;
HDC hdc;
int whole_line_p;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
RECT 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.left = WINDOW_TO_FRAME_PIXEL_X (w, 0);
clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
clip_rect.top = max (clip_rect.top, window_y);
clip_rect.right = clip_rect.left + window_width;
clip_rect.bottom = clip_rect.top + row->visible_height;
if (whole_line_p)
{
clip_rect.left -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
clip_rect.right += FRAME_X_FLAGS_AREA_WIDTH (f);
}
w32_set_clip_rectangle (hdc, &clip_rect);
}
static void
x_draw_hollow_cursor (w, row)
struct window *w;
struct glyph_row *row;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
HDC hdc;
RECT rect;
int wd;
struct glyph *cursor_glyph;
HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
rect.left = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
rect.top = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
+ row->ascent - w->phys_cursor_ascent);
rect.bottom = rect.top + 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);
rect.right = rect.left + wd;
hdc = get_frame_dc (f);
FrameRect (hdc, &rect, hb);
DeleteObject (hb);
release_frame_dc (f, hdc);
}
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;
int x;
HDC hdc;
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
{
COLORREF cursor_color = f->output_data.w32->cursor_pixel;
struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
if (width < 0)
width = f->output_data.w32->cursor_width;
if (face->background == cursor_color)
cursor_color = face->foreground;
x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
hdc = get_frame_dc (f);
w32_clip_to_row (w, row, hdc, 0);
w32_fill_area (f, hdc, cursor_color,
x,
WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
min (cursor_glyph->pixel_width, width),
row->height);
release_frame_dc (f, hdc);
}
}
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 w32_display_info *dpyinfo = FRAME_W32_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);
HDC hdc;
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);
hdc = get_frame_dc (f);
w32_clear_area (f, hdc, x,
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
cursor_row->y)),
cursor_glyph->pixel_width,
cursor_row->visible_height);
release_frame_dc (f, hdc);
}
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 w32_display_info *dpyinfo
= FRAME_W32_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_W32_DISPLAY_INFO (f)->w32_highlight_frame
|| w != XWINDOW (f->selected_window))
{
extern int cursor_in_non_selected_windows;
if (MINI_WINDOW_P (w)
|| !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 ();
}
}
}
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;
int on_p;
{
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, icon)
struct frame *f;
Lisp_Object icon;
{
HANDLE hicon;
if (FRAME_W32_WINDOW (f) == 0)
return 1;
if (NILP (icon))
hicon = LoadIcon (hinst, EMACS_CLASS);
else if (STRINGP (icon))
hicon = LoadImage (NULL, (LPCTSTR) XSTRING (icon)->data, IMAGE_ICON, 0, 0,
LR_DEFAULTSIZE | LR_LOADFROMFILE);
else if (SYMBOLP (icon))
{
LPCTSTR name;
if (EQ (icon, intern ("application")))
name = (LPCTSTR) IDI_APPLICATION;
else if (EQ (icon, intern ("hand")))
name = (LPCTSTR) IDI_HAND;
else if (EQ (icon, intern ("question")))
name = (LPCTSTR) IDI_QUESTION;
else if (EQ (icon, intern ("exclamation")))
name = (LPCTSTR) IDI_EXCLAMATION;
else if (EQ (icon, intern ("asterisk")))
name = (LPCTSTR) IDI_ASTERISK;
else if (EQ (icon, intern ("winlogo")))
name = (LPCTSTR) IDI_WINLOGO;
else
return 1;
hicon = LoadIcon (NULL, name);
}
else
return 1;
if (hicon == NULL)
return 1;
PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
(LPARAM) hicon);
return 0;
}
Lisp_Object
x_new_font (f, fontname)
struct frame *f;
register char *fontname;
{
struct font_info *fontp
= FS_LOAD_FONT (f, 0, fontname, -1);
if (!fontp)
return Qnil;
FRAME_FONT (f) = (XFontStruct *) (fontp->font);
FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset;
FRAME_FONTSET (f) = -1;
if (f->scroll_bar_pixel_width > 0)
{
int wid = FONT_WIDTH (FRAME_FONT (f));
f->scroll_bar_cols = (f->scroll_bar_pixel_width + wid-1) / wid;
}
else
{
int wid = FONT_WIDTH (FRAME_FONT (f));
f->scroll_bar_cols = (14 + wid - 1) / wid;
}
if (FRAME_W32_WINDOW (f) != 0)
{
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.w32->line_height = FONT_HEIGHT (FRAME_FONT (f));
return build_string (fontp->full_name);
}
Lisp_Object
x_new_fontset (f, fontsetname)
struct frame *f;
char *fontsetname;
{
int fontset = fs_query_fontset (build_string (fontsetname), 0);
Lisp_Object result;
if (fontset < 0)
return Qnil;
if (FRAME_FONTSET (f) == fontset)
return fontset_name (fontset);
result = x_new_font (f, (XSTRING (fontset_ascii (fontset))->data));
if (!STRINGP (result))
return Qnil;
FRAME_FONTSET(f) = fontset;
return build_string (fontsetname);
}
void
x_calc_absolute_position (f)
struct frame *f;
{
POINT pt;
int flags = f->output_data.w32->size_hint_flags;
pt.x = pt.y = 0;
if (f->output_data.w32->parent_desc != FRAME_W32_DISPLAY_INFO (f)->root_window)
{
BLOCK_INPUT;
MapWindowPoints (FRAME_W32_WINDOW (f),
f->output_data.w32->parent_desc,
&pt, 1);
UNBLOCK_INPUT;
}
{
RECT rt;
rt.left = rt.right = rt.top = rt.bottom = 0;
BLOCK_INPUT;
AdjustWindowRect(&rt, f->output_data.w32->dwStyle,
FRAME_EXTERNAL_MENU_BAR (f));
UNBLOCK_INPUT;
pt.x += (rt.right - rt.left);
pt.y += (rt.bottom - rt.top);
}
if (flags & XNegative)
f->output_data.w32->left_pos = (FRAME_W32_DISPLAY_INFO (f)->width
- 2 * f->output_data.w32->border_width - pt.x
- PIXEL_WIDTH (f)
+ f->output_data.w32->left_pos);
if (flags & YNegative)
f->output_data.w32->top_pos = (FRAME_W32_DISPLAY_INFO (f)->height
- 2 * f->output_data.w32->border_width - pt.y
- PIXEL_HEIGHT (f)
+ f->output_data.w32->top_pos);
f->output_data.w32->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.w32->top_pos = yoff;
f->output_data.w32->left_pos = xoff;
f->output_data.w32->size_hint_flags &= ~ (XNegative | YNegative);
if (xoff < 0)
f->output_data.w32->size_hint_flags |= XNegative;
if (yoff < 0)
f->output_data.w32->size_hint_flags |= YNegative;
f->output_data.w32->win_gravity = NorthWestGravity;
}
x_calc_absolute_position (f);
BLOCK_INPUT;
x_wm_set_size_hint (f, (long) 0, 0);
modified_left = f->output_data.w32->left_pos;
modified_top = f->output_data.w32->top_pos;
my_set_window_pos (FRAME_W32_WINDOW (f),
NULL,
modified_left, modified_top,
0, 0,
SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
UNBLOCK_INPUT;
}
void
x_set_window_size (f, change_gravity, cols, rows)
struct frame *f;
int change_gravity;
int cols, rows;
{
int pixelwidth, pixelheight;
BLOCK_INPUT;
check_frame_size (f, &rows, &cols);
f->output_data.w32->vertical_scroll_bar_extra
= (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
? 0
: (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.w32->font)));
f->output_data.w32->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.w32->win_gravity = NorthWestGravity;
x_wm_set_size_hint (f, (long) 0, 0);
{
RECT rect;
rect.left = rect.top = 0;
rect.right = pixelwidth;
rect.bottom = pixelheight;
AdjustWindowRect(&rect, f->output_data.w32->dwStyle,
FRAME_EXTERNAL_MENU_BAR (f));
my_set_window_pos (FRAME_W32_WINDOW (f),
NULL,
0, 0,
rect.right - rect.left,
rect.bottom - rect.top,
SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
}
change_frame_size (f, rows, cols, 0, 1, 0);
PIXEL_WIDTH (f) = pixelwidth;
PIXEL_HEIGHT (f) = pixelheight;
SET_FRAME_GARBAGED (f);
mark_window_cursors_off (XWINDOW (f->root_window));
cancel_mouse_face (f);
UNBLOCK_INPUT;
}
void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
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.w32->font) / 2;
pix_y = CHAR_TO_PIXEL_ROW (f, y) + f->output_data.w32->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);
x_set_mouse_pixel_position (f, pix_x, pix_y);
}
void
x_set_mouse_pixel_position (f, pix_x, pix_y)
struct frame *f;
int pix_x, pix_y;
{
RECT rect;
POINT pt;
BLOCK_INPUT;
GetClientRect (FRAME_W32_WINDOW (f), &rect);
pt.x = rect.left + pix_x;
pt.y = rect.top + pix_y;
ClientToScreen (FRAME_W32_WINDOW (f), &pt);
SetCursorPos (pt.x, pt.y);
UNBLOCK_INPUT;
}
void
x_focus_on_frame (f)
struct frame *f;
{
struct w32_display_info *dpyinfo = &one_w32_display_info;
BLOCK_INPUT;
#if 0
if (x_window_to_frame (dpyinfo, GetForegroundWindow ()))
my_set_focus (f, FRAME_W32_WINDOW (f));
else
#endif
my_set_foreground_window (FRAME_W32_WINDOW (f));
UNBLOCK_INPUT;
}
void
x_unfocus_frame (f)
struct frame *f;
{
}
void
x_raise_frame (f)
struct frame *f;
{
BLOCK_INPUT;
if (NILP (Vw32_grab_focus_on_raise))
{
HDWP handle = BeginDeferWindowPos (2);
if (handle)
{
DeferWindowPos (handle,
FRAME_W32_WINDOW (f),
HWND_TOP,
0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
DeferWindowPos (handle,
GetForegroundWindow (),
FRAME_W32_WINDOW (f),
0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
EndDeferWindowPos (handle);
}
}
else
{
my_set_foreground_window (FRAME_W32_WINDOW (f));
}
UNBLOCK_INPUT;
}
void
x_lower_frame (f)
struct frame *f;
{
BLOCK_INPUT;
my_set_window_pos (FRAME_W32_WINDOW (f),
HWND_BOTTOM,
0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
UNBLOCK_INPUT;
}
static void
w32_frame_raise_lower (f, raise_flag)
FRAME_PTR f;
int raise_flag;
{
if (! FRAME_W32_P (f))
return;
if (raise_flag)
x_raise_frame (f);
else
x_lower_frame (f);
}
void
x_make_frame_visible (f)
struct frame *f;
{
Lisp_Object type;
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.w32->asked_for_visible)
x_set_offset (f, f->output_data.w32->left_pos, f->output_data.w32->top_pos, 0);
f->output_data.w32->asked_for_visible = 1;
my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL);
}
{
Lisp_Object frame;
int count;
UNBLOCK_INPUT;
XSETFRAME (frame, f);
for (count = input_signal_count + 10;
input_signal_count < count && !FRAME_VISIBLE_P (f);)
{
if (input_polling_used ())
{
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);
}
}
x_make_frame_invisible (f)
struct frame *f;
{
if (FRAME_W32_DISPLAY_INFO (f)->w32_highlight_frame == f)
FRAME_W32_DISPLAY_INFO (f)->w32_highlight_frame = 0;
BLOCK_INPUT;
my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE);
f->visible = 0;
FRAME_ICONIFIED_P (f) = 0;
f->async_visible = 0;
f->async_iconified = 0;
UNBLOCK_INPUT;
}
void
x_iconify_frame (f)
struct frame *f;
{
Lisp_Object type;
if (FRAME_W32_DISPLAY_INFO (f)->w32_highlight_frame == f)
FRAME_W32_DISPLAY_INFO (f)->w32_highlight_frame = 0;
if (f->async_iconified)
return;
BLOCK_INPUT;
type = x_icon_type (f);
if (!NILP (type))
x_bitmap_icon (f, type);
SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
UNBLOCK_INPUT;
}
void
x_free_frame_resources (f)
struct frame *f;
{
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
BLOCK_INPUT;
if (FRAME_W32_WINDOW (f))
my_destroy_window (f, FRAME_W32_WINDOW (f));
free_frame_menubar (f);
unload_color (f, f->output_data.x->foreground_pixel);
unload_color (f, f->output_data.x->background_pixel);
unload_color (f, f->output_data.w32->cursor_pixel);
unload_color (f, f->output_data.w32->cursor_foreground_pixel);
unload_color (f, f->output_data.w32->border_pixel);
unload_color (f, f->output_data.w32->mouse_pixel);
if (f->output_data.w32->white_relief.allocated_p)
unload_color (f, f->output_data.w32->white_relief.pixel);
if (f->output_data.w32->black_relief.allocated_p)
unload_color (f, f->output_data.w32->black_relief.pixel);
if (FRAME_FACE_CACHE (f))
free_frame_faces (f);
xfree (f->output_data.w32);
f->output_data.w32 = NULL;
if (f == dpyinfo->w32_focus_frame)
dpyinfo->w32_focus_frame = 0;
if (f == dpyinfo->w32_focus_event_frame)
dpyinfo->w32_focus_event_frame = 0;
if (f == dpyinfo->w32_highlight_frame)
dpyinfo->w32_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;
}
x_destroy_window (f)
struct frame *f;
{
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
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;
{
Window window = FRAME_W32_WINDOW (f);
enter_crit ();
SetWindowLong (window, WND_FONTWIDTH_INDEX, FONT_WIDTH (f->output_data.w32->font));
SetWindowLong (window, WND_LINEHEIGHT_INDEX, f->output_data.w32->line_height);
SetWindowLong (window, WND_BORDER_INDEX, f->output_data.w32->internal_border_width);
SetWindowLong (window, WND_SCROLLBAR_INDEX, f->output_data.w32->vertical_scroll_bar_extra);
leave_crit ();
}
x_wm_set_icon_position (f, icon_x, icon_y)
struct frame *f;
int icon_x, icon_y;
{
#if 0
Window window = FRAME_W32_WINDOW (f);
f->display.x->wm_hints.flags |= IconPositionHint;
f->display.x->wm_hints.icon_x = icon_x;
f->display.x->wm_hints.icon_y = icon_y;
XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
#endif
}
#if GLYPH_DEBUG
static void
x_check_font (f, font)
struct frame *f;
XFontStruct *font;
{
int i;
struct w32_display_info *dpyinfo = FRAME_W32_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_WIDTH (font);
}
int
x_compute_min_glyph_bounds (f)
struct frame *f;
{
int i;
struct w32_display_info *dpyinfo = FRAME_W32_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);
}
static int w32_initialized = 0;
void
w32_initialize_display_info (display_name)
Lisp_Object display_name;
{
struct w32_display_info *dpyinfo = &one_w32_display_info;
bzero (dpyinfo, sizeof (*dpyinfo));
w32_display_name_list = Fcons (Fcons (display_name, Qnil),
w32_display_name_list);
dpyinfo->name_list_element = XCAR (w32_display_name_list);
dpyinfo->w32_id_name
= (char *) xmalloc (XSTRING (Vinvocation_name)->size
+ XSTRING (Vsystem_name)->size
+ 2);
sprintf (dpyinfo->w32_id_name, "%s@%s",
XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
dpyinfo->resx = 1;
dpyinfo->resy = 1;
dpyinfo->height_in = 1;
dpyinfo->width_in = 1;
dpyinfo->n_planes = 1;
dpyinfo->n_cbits = 4;
dpyinfo->n_fonts = 0;
dpyinfo->smallest_font_height = 1;
dpyinfo->smallest_char_width = 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_face_id = DEFAULT_FACE_ID;
dpyinfo->mouse_face_window = Qnil;
dpyinfo->mouse_face_overlay = Qnil;
}
struct w32_display_info *
w32_term_init (display_name, xrm_option, resource_name)
Lisp_Object display_name;
char *xrm_option;
char *resource_name;
{
struct w32_display_info *dpyinfo;
HDC hdc;
BLOCK_INPUT;
if (!w32_initialized)
{
w32_initialize ();
w32_initialized = 1;
}
{
int argc = 0;
char *argv[3];
argv[0] = "";
argc = 1;
if (xrm_option)
{
argv[argc++] = "-xrm";
argv[argc++] = xrm_option;
}
}
w32_initialize_display_info (display_name);
dpyinfo = &one_w32_display_info;
dpyinfo->next = x_display_list;
x_display_list = dpyinfo;
hdc = GetDC (GetDesktopWindow ());
dpyinfo->height = GetDeviceCaps (hdc, VERTRES);
dpyinfo->width = GetDeviceCaps (hdc, HORZRES);
dpyinfo->root_window = GetDesktopWindow ();
dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES);
dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL);
dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX);
dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY);
dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE;
dpyinfo->image_cache = make_image_cache ();
dpyinfo->height_in = dpyinfo->height / dpyinfo->resx;
dpyinfo->width_in = dpyinfo->width / dpyinfo->resy;
ReleaseDC (GetDesktopWindow (), hdc);
{
COLORREF color;
w32_defined_color (0, "white", &color, 1);
w32_defined_color (0, "black", &color, 1);
}
left_bmp = CreateBitmap (left_width, left_height, 1, 1, left_bits);
ov_bmp = CreateBitmap (ov_width, ov_height, 1, 1, ov_bits);
right_bmp = CreateBitmap (right_width, right_height, 1, 1, right_bits);
continued_bmp = CreateBitmap (continued_width, continued_height, 1,
1, continued_bits);
continuation_bmp = CreateBitmap (continuation_width, continuation_height,
1, 1, continuation_bits);
zv_bmp = CreateBitmap (zv_width, zv_height, 1, 1, zv_bits);
#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
UNBLOCK_INPUT;
return dpyinfo;
}
void
x_delete_display (dpyinfo)
struct w32_display_info *dpyinfo;
{
if (! NILP (w32_display_name_list)
&& EQ (XCAR (w32_display_name_list), dpyinfo->name_list_element))
w32_display_name_list = XCDR (w32_display_name_list);
else
{
Lisp_Object tail;
tail = w32_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);
}
}
{
struct w32_palette_entry * plist;
plist = dpyinfo->color_list;
while (plist)
{
struct w32_palette_entry * pentry = plist;
plist = plist->next;
xfree (pentry);
}
dpyinfo->color_list = NULL;
if (dpyinfo->palette)
DeleteObject(dpyinfo->palette);
}
xfree (dpyinfo->font_table);
xfree (dpyinfo->w32_id_name);
DeleteObject (left_bmp);
DeleteObject (ov_bmp);
DeleteObject (right_bmp);
DeleteObject (continued_bmp);
DeleteObject (continuation_bmp);
DeleteObject (zv_bmp);
}
DWORD w32_msg_worker ();
void
x_flush (struct frame * f)
{ }
static struct redisplay_interface w32_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,
w32_cursor_to,
x_flush,
x_clear_mouse_face,
x_get_glyph_overhangs,
x_fix_overlapping_area
};
void
w32_initialize ()
{
rif = &w32_redisplay_interface;
clear_frame_hook = (void (*)(void)) x_clear_frame;
ring_bell_hook = (void (*)(void)) w32_ring_bell;
update_begin_hook = x_update_begin;
update_end_hook = x_update_end;
read_socket_hook = w32_read_socket;
frame_up_to_date_hook = w32_frame_up_to_date;
mouse_position_hook = w32_mouse_position;
frame_rehighlight_hook = w32_frame_rehighlight;
frame_raise_lower_hook = w32_frame_raise_lower;
set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
condemn_scroll_bars_hook = w32_condemn_scroll_bars;
redeem_scroll_bar_hook = w32_redeem_scroll_bar;
judge_scroll_bars_hook = w32_judge_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;
last_tool_bar_item = -1;
any_help_event_p = 0;
Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
init_crit ();
dwMainThreadId = GetCurrentThreadId ();
DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
GetCurrentProcess (), &hMainThread, 0, TRUE, DUPLICATE_SAME_ACCESS);
{
MSG msg;
PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
hWindowsThread = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) w32_msg_worker,
0, 0, &dwWindowsThreadId);
GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
}
#ifdef ATTACH_THREADS
AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
#endif
{
HANDLE user_lib = LoadLibrary ("user32.dll");
#define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
LOAD_PROC (SetScrollInfo);
LOAD_PROC (GetScrollInfo);
#undef LOAD_PROC
FreeLibrary (user_lib);
vertical_scroll_bar_min_handle = (pfnSetScrollInfo != NULL) ? 5 :
GetSystemMetrics (SM_CYVTHUMB);
vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border
= GetSystemMetrics (SM_CYVSCROLL);
}
}
void
syms_of_w32term ()
{
staticpro (&w32_display_name_list);
w32_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");
DEFVAR_INT ("w32-num-mouse-buttons",
&Vw32_num_mouse_buttons,
"Number of physical mouse buttons.");
Vw32_num_mouse_buttons = Qnil;
DEFVAR_LISP ("w32-swap-mouse-buttons",
&Vw32_swap_mouse_buttons,
"Swap the mapping of middle and right mouse buttons.\n\
When nil, middle button is mouse-2 and right button is mouse-3.");
Vw32_swap_mouse_buttons = Qnil;
DEFVAR_LISP ("w32-grab-focus-on-raise",
&Vw32_grab_focus_on_raise,
"Raised frame grabs input focus.\n\
When t, `raise-frame' grabs input focus as well. This fits well\n\
with the normal Windows click-to-focus policy, but might not be\n\
desirable when using a point-to-focus policy.");
Vw32_grab_focus_on_raise = Qt;
DEFVAR_LISP ("w32-capslock-is-shiftlock",
&Vw32_capslock_is_shiftlock,
"Apply CapsLock state to non character input keys.\n\
When nil, CapsLock only affects normal character input keys.");
Vw32_capslock_is_shiftlock = Qnil;
DEFVAR_LISP ("w32-recognize-altgr",
&Vw32_recognize_altgr,
"Recognize right-alt and left-ctrl as AltGr.\n\
When nil, the right-alt and left-ctrl key combination is\n\
interpreted normally.");
Vw32_recognize_altgr = Qt;
DEFVAR_BOOL ("w32-enable-unicode-output",
&w32_enable_unicode_output,
"Enable the use of Unicode for text output if non-nil.\n\
Unicode output may prevent some third party applications for displaying\n\
Far-East Languages on Windows 95/98 from working properly.\n\
NT uses Unicode internally anyway, so this flag will probably have no\n\
affect on NT machines.");
w32_enable_unicode_output = 1;
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_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
"If not nil, Emacs uses toolkit scroll bars.");
Vx_toolkit_scroll_bars = Qt;
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;
}