/* Implementation of GUI terminal on the Microsoft W32 API.
- Copyright (C) 1989, 93, 94, 95, 96, 97, 98 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU Emacs; see the file COPYING. If not, write to the
-Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+along with GNU Emacs; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <config.h>
#include <setjmp.h>
#include <sys/stat.h>
+#include "keyboard.h"
#include "frame.h"
#include "dispextern.h"
#include "fontset.h"
#include "disptab.h"
#include "buffer.h"
#include "window.h"
-#include "keyboard.h"
#include "intervals.h"
#include "composite.h"
#include "coding.h"
-#undef min
-#undef max
-#define min(x, y) (((x) < (y)) ? (x) : (y))
-#define max(x, y) (((x) > (y)) ? (x) : (y))
+#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))
extern Lisp_Object Qhelp_echo;
\f
-/* Non-zero means Emacs uses toolkit scroll bars. */
+/* Non-nil means Emacs uses toolkit scroll bars. */
-int x_toolkit_scroll_bars_p;
+Lisp_Object Vx_toolkit_scroll_bars;
/* If a string, w32_read_socket generates an event to display that string.
(The display is done in read_char.) */
static Lisp_Object help_echo;
+static Lisp_Object help_echo_window;
+static Lisp_Object help_echo_object;
+static int help_echo_pos;
/* Temporary variable for w32_read_socket. */
int x_stretch_cursor_p;
-#define CP_DEFAULT 1004
-
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
/* Mouse movement. */
/* Where the mouse was last time we reported a mouse event. */
+
FRAME_PTR last_mouse_frame;
static RECT last_mouse_glyph;
static Lisp_Object last_mouse_press_frame;
If the last motion event didn't occur in a scroll bar, we set this
to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
-Lisp_Object last_mouse_scroll_bar;
-int last_mouse_scroll_bar_pos;
+static Lisp_Object last_mouse_scroll_bar;
+static int last_mouse_scroll_bar_pos;
/* This is a hack. We would really prefer that w32_mouse_position would
return the time associated with the position it returns, but there
- doesn't seem to be any way to wrest the timestamp from the server
+ doesn't seem to be any way to wrest the time-stamp from the server
along with the position query. So, we just keep track of the time
of the last movement we received, and return that in hopes that
it's somewhat accurate. */
-Time last_mouse_movement_time;
-/* Associative list linking character set strings to Windows codepages. */
-Lisp_Object Vw32_charset_info_alist;
+static Time last_mouse_movement_time;
+
+/* Incremented by w32_read_socket whenever it really tries to read
+ events. */
-/* Incremented by w32_read_socket whenever it really tries to read events. */
#ifdef __STDC__
static int volatile input_signal_count;
#else
extern Lisp_Object Qface, Qmouse_face;
+#ifndef USE_CRT_DLL
extern int errno;
+#endif
/* A mask of extra modifier bits to put into every keyboard char. */
+
extern int extra_keyboard_modifiers;
/* Enumeration for overriding/changing the face to use for drawing
DRAW_IMAGE_SUNKEN
};
-static void x_update_window_end P_ ((struct window *, int));
+static void x_update_window_end P_ ((struct window *, int, int));
static void frame_to_window_pixel_xy P_ ((struct window *, int *, int *));
void w32_delete_display P_ ((struct w32_display_info *));
static int fast_find_position P_ ((struct window *, int, int *, int *,
static struct glyph *x_y_to_hpos_vpos P_ ((struct window *, int, int,
int *, int *, int *));
static void note_mode_line_highlight P_ ((struct window *, int, int));
-static void x_check_font P_ ((struct frame *, XFontStruct *));
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 *,
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 *));
-static int w32_intersect_rectangles P_ ((RECT *, RECT *, RECT *));
+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 void expose_window_tree P_ ((struct window *, RECT *));
static void expose_window P_ ((struct window *, RECT *));
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 note_overwritten_text_cursor P_ ((struct window *, int, int));
-static void w32_clip_to_row P_ ((struct window *, struct glyph_row *,
- HDC, int));
static Lisp_Object Qvendor_specific_keysyms;
-Lisp_Object Qw32_charset_ansi;
-Lisp_Object Qw32_charset_default;
-Lisp_Object Qw32_charset_symbol;
-Lisp_Object Qw32_charset_shiftjis;
-Lisp_Object Qw32_charset_hangul;
-Lisp_Object Qw32_charset_gb2312;
-Lisp_Object Qw32_charset_chinesebig5;
-Lisp_Object Qw32_charset_oem;
-
-#ifdef JOHAB_CHARSET
-Lisp_Object Qw32_charset_easteurope;
-Lisp_Object Qw32_charset_turkish;
-Lisp_Object Qw32_charset_baltic;
-Lisp_Object Qw32_charset_russian;
-Lisp_Object Qw32_charset_arabic;
-Lisp_Object Qw32_charset_greek;
-Lisp_Object Qw32_charset_hebrew;
-Lisp_Object Qw32_charset_thai;
-Lisp_Object Qw32_charset_johab;
-Lisp_Object Qw32_charset_mac;
-#endif
-
-#ifdef UNICODE_CHARSET
-Lisp_Object Qw32_charset_unicode;
-#endif
-
\f
+/***********************************************************************
+ Debugging
+ ***********************************************************************/
+
#if 0
-/* This is a function useful for recording debugging information
- about the sequence of occurrences in this file. */
+
+/* This is a function useful for recording debugging information about
+ the sequence of occurrences in this file. */
struct record
{
XChangeGC (ignore, xgcv, mask, gc);
}
-void XTextExtents16 (XFontStruct *font, wchar_t *text, int nchars,
- int *direction,int *font_ascent,
- int *font_descent, XCharStruct *cs)
-{
- /* NTEMACS_TODO: Use GetTextMetrics to do this and inline it below. */
-}
-
static void
w32_set_clip_rectangle (HDC hdc, RECT *rect)
{
RECT * lprect;
{
HBRUSH hb;
- RECT rect;
hb = CreateSolidBrush (pix);
FillRect (hdc, lprect, hb);
RECT rect;
HDC hdc = get_frame_dc (f);
- GetClientRect (FRAME_W32_WINDOW (f), &rect);
- w32_clear_rect (f, hdc, &rect);
+ /* Under certain conditions, this can be called at startup with
+ a console frame pointer before the GUI frame is created. An HDC
+ of 0 indicates this. */
+ if (hdc)
+ {
+ GetClientRect (FRAME_W32_WINDOW (f), &rect);
+ w32_clear_rect (f, hdc, &rect);
+ }
+
release_frame_dc (f, hdc);
}
/* Start an update of frame F. This function is installed as a hook
for update_begin, i.e. it is called when update_begin is called.
This function is called prior to calls to x_update_window_begin for
- each window being updated. Currently, there is nothing to do here
- because all interesting stuff is done on a window basis. */
+ each window being updated. */
static void
x_update_begin (f)
struct frame *f;
{
- /* Nothing to do. We have to do something though, otherwise the
- function gets optimized away and the hook is no longer valid. */
- struct frame *cf = f;
+ struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
+
+ if (! FRAME_W32_P (f))
+ return;
+
+ /* Regenerate display palette before drawing if list of requested
+ colors has changed. */
+ if (display_info->regen_palette)
+ {
+ w32_regenerate_palette (f);
+ display_info->regen_palette = FALSE;
+ }
}
BLOCK_INPUT;
- /* Regenerate display palette before drawing if list of requested
- colors has changed. */
- if (display_info->regen_palette)
- {
- w32_regenerate_palette (f);
- display_info->regen_palette = FALSE;
- }
-
if (f == display_info->mouse_face_mouse_frame)
{
/* Don't do highlighting for mouse motion during the update. */
display_info->mouse_face_defer = 1;
- /* If the frame needs to be redrawn,
- simply forget about any prior mouse highlighting. */
+ /* If F needs to be redrawn, simply forget about any prior mouse
+ highlighting. */
if (FRAME_GARBAGED_P (f))
display_info->mouse_face_window = Qnil;
+#if 0 /* Rows in a current matrix containing glyphs in mouse-face have
+ their mouse_face_p flag set, which means that they are always
+ unequal to rows in a desired matrix which never have that
+ flag set. So, rows containing mouse-face glyphs are never
+ scrolled, and we don't have to switch the mouse highlight off
+ here to prevent it from being scrolled. */
+
/* Can we tell that this update does not affect the window
where the mouse highlight is? If so, no need to turn off.
Likewise, don't do anything if the frame is garbaged;
if (i < w->desired_matrix->nrows)
clear_mouse_face (display_info);
}
+#endif /* 0 */
}
UNBLOCK_INPUT;
r.bottom -= 1;
hdc = get_frame_dc (f);
- w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), r);
+ w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
release_frame_dc (f, hdc);
}
}
-/* End update of window W (which is equal to updated_window). Draw
- vertical borders between horizontally adjacent windows, and display
- W's cursor if CURSOR_ON_P is non-zero. W may be a menu bar
- pseudo-window in case we don't have X toolkit support. Such
- windows don't have a cursor, so don't display it here. */
+/* End update of window W (which is equal to updated_window).
+
+ Draw vertical borders between horizontally adjacent windows, and
+ display W's cursor if CURSOR_ON_P is non-zero.
+
+ MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
+ glyphs in mouse-face were overwritten. In that case we have to
+ make sure that the mouse-highlight is properly redrawn.
+
+ W may be a menu bar pseudo-window in case we don't have X toolkit
+ support. Such windows don't have a cursor, so don't display it
+ here. */
static void
-x_update_window_end (w, cursor_on_p)
+x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
struct window *w;
- int cursor_on_p;
+ int cursor_on_p, mouse_face_overwritten_p;
{
if (!w->pseudo_window_p)
{
+ struct w32_display_info *dpyinfo
+ = FRAME_W32_DISPLAY_INFO (XFRAME (w->frame));
+
BLOCK_INPUT;
+
+ /* If a row with mouse-face was overwritten, arrange for
+ XTframe_up_to_date to redisplay the mouse highlight. */
+ 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;
+ }
+
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;
}
updated_window = NULL;
}
+
+/* End update of frame F. This function is installed as a hook in
+ update_end. */
+
static void
x_update_end (f)
struct frame *f;
{
+ if (! FRAME_W32_P (f))
+ return;
+
/* Mouse highlight may be displayed again. */
FRAME_W32_DISPLAY_INFO (f)->mouse_face_defer = 0;
}
+
/* This function is called from various places in xdisp.c whenever a
complete update has been performed. The global variable
updated_window is not available here. */
HDC compat_hdc;
int x, y, wd, h, dy;
HBITMAP pixmap;
- HBRUSH fg_brush, orig_brush;
HANDLE horig_obj;
struct face *face;
compat_hdc = CreateCompatibleDC (hdc);
SaveDC (hdc);
- fg_brush = CreateSolidBrush (FRAME_FOREGROUND_PIXEL (f));
- orig_brush = SelectObject (hdc, fg_brush);
+
horig_obj = SelectObject (compat_hdc, pixmap);
- SetTextColor (hdc, FRAME_BACKGROUND_PIXEL (f));
- SetBkColor (hdc, FRAME_FOREGROUND_PIXEL (f));
-#if 0 /* From w32bdf.c (which is from Meadow). */
+ SetTextColor (hdc, face->background);
+ SetBkColor (hdc, face->foreground);
+
BitBlt (hdc, x, y + dy, wd, h, compat_hdc, 0, 0, SRCCOPY);
-#else
- BitBlt (hdc, x, y + dy, wd, h, compat_hdc, 0, 0, 0xB8074A);
-#endif
+
SelectObject (compat_hdc, horig_obj);
- SelectObject (hdc, orig_brush);
- DeleteObject (fg_brush);
DeleteDC (compat_hdc);
RestoreDC (hdc, -1);
}
}
\f
-
/***********************************************************************
Line Highlighting
***********************************************************************/
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 ();
}
+
/* Call this when about to modify line at position VPOS and change
whether it is highlighted. Not used for W32 frames. Aborts when
called. */
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 ();
}
-/* This is used when starting Emacs and when restarting after suspend.
- When starting Emacs, no window is mapped. And nothing must be done
- to Emacs's own window if it is suspended (though that rarely happens). */
+
+/* This is called when starting Emacs and when restarting after
+ suspend. When starting Emacs, no window is mapped. And nothing
+ must be done to Emacs's own window if it is suspended (though that
+ rarely happens). */
static void
w32_set_terminal_modes (void)
{
}
-/* This is called when exiting or suspending Emacs.
- Exiting will make the W32 windows go away, and suspending
- requires no action. */
+/* This is called when exiting or suspending Emacs. Exiting will make
+ the W32 windows go away, and suspending requires no action. */
static void
w32_reset_terminal_modes (void)
{
}
+
\f
/***********************************************************************
Output Cursor
/* Set the global variable output_cursor to CURSOR. All cursor
positions are relative to updated_window. */
+
static void
set_output_cursor (cursor)
struct cursor_pos *cursor;
}
}
+
\f
/***********************************************************************
Display Iterator
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_ ((HDC hdc, XFontStruct *,
- wchar_t *, int unicode_p));
-static void x_encode_char P_ ((int, wchar_t *, struct font_info *));
+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,
((ch) & 0x00ff)
-/* NTEMACS_TODO: Add support for bdf fonts back in. */
-
/* Get metrics of character CHAR2B in FONT. Value is always non-null.
If CHAR2B is not contained in FONT, the font's default character
- metric is returned. If unicode_p is non-zero, use unicode functions,
- otherwise use ANSI functions. */
+ metric is returned. */
-static INLINE XCharStruct *
-w32_per_char_metric (hdc, font, char2b, unicode_p)
- HDC hdc;
+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)
+ {
+ pcm->width = char_widths.abcA + char_widths.abcB + char_widths.abcC;
+ pcm->lbearing = char_widths.abcA;
+ pcm->rbearing = pcm->width - char_widths.abcC;
+ pcm->ascent = FONT_BASE (font);
+ pcm->descent = FONT_DESCENT (font);
+ }
+ }
+
+ if (!retval)
+ {
+ /* Either font is not a True-type font, or GetCharABCWidthsW
+ failed (it is not supported on Windows 9x for instance), so we
+ can't determine the full info we would like. All is not lost
+ though - we can call GetTextExtentPoint32 to get rbearing and
+ deduce width based on the font's per-string overhang. lbearing
+ is assumed to be zero. */
+
+ /* TODO: Some Thai characters (and other composites if Windows
+ supports them) do have lbearing, and report their total width
+ as zero. Need some way of handling them when
+ GetCharABCWidthsW fails. */
+ 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;
- int unicode_p;
+ enum w32_char_font_type font_type;
{
/* The result metric information. */
XCharStruct *pcm;
- ABC char_widths;
- SIZE sz;
BOOL retval;
xassert (font && char2b);
+ xassert (font_type != UNKNOWN_FONT);
- pcm = (XCharStruct *) xmalloc (sizeof (XCharStruct));
+ /* Handle the common cases quickly. */
+ if (!font->bdf && font->per_char == NULL)
+ /* TODO: determine whether char2b exists in font? */
+ return &font->max_bounds;
+ else if (!font->bdf && *char2b < 128)
+ return &font->per_char[*char2b];
- if (font->hfont)
- SelectObject (hdc, font->hfont);
+ pcm = &font->scratch;
- if (unicode_p)
- retval = GetCharABCWidthsW (hdc, *char2b, *char2b, &char_widths);
+ 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 = GetCharABCWidthsA (hdc, *char2b, *char2b, &char_widths);
+ 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';
+
+ /* Cache char metrics for the common cases. */
+ if (font->bdf)
{
- pcm->width = char_widths.abcA + char_widths.abcB + char_widths.abcC;
- pcm->lbearing = char_widths.abcA;
- pcm->rbearing = pcm->width - char_widths.abcC;
+ /* TODO: determine whether font is fixed-pitch. */
+ if (!w32_bdf_per_char_metric (font, &char2b, 1, &font->max_bounds))
+ {
+ /* Use the font width and height as max bounds, as not all BDF
+ fonts contain the letter 'x'. */
+ 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
{
- /* Windows 9x does not implement GetCharABCWidthsW, so if that
- failed, try GetTextExtentPoint32W, which is implemented and
- at least gives us some of the info we are after (total
- character width). */
- if (unicode_p)
- retval = GetTextExtentPoint32W (hdc, char2b, 1, &sz);
+ if (((font->tm.tmPitchAndFamily & TMPF_FIXED_PITCH) != 0)
+ /* Some fonts (eg DBCS fonts) are marked as fixed width even
+ though they contain characters of different widths. */
+ || (font->tm.tmMaxCharWidth != font->tm.tmAveCharWidth))
+ {
+ /* Font is not fixed pitch, so cache per_char info for the
+ ASCII characters. It would be much more work, and probably
+ not worth it, to cache other chars, since we may change
+ between using Unicode and ANSI text drawing functions at
+ run-time. */
+ int i;
- if (retval)
- {
- pcm->width = sz.cx;
- pcm->rbearing = sz.cx;
- pcm->lbearing = 0;
- }
+ 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
- {
- pcm->width = FONT_MAX_WIDTH (font);
- pcm->rbearing = FONT_MAX_WIDTH (font);
- pcm->lbearing = 0;
- }
+ w32_native_per_char_metric (font, &char2b, ANSI_FONT,
+ &font->max_bounds);
}
+}
- pcm->ascent = FONT_BASE (font);
- pcm->descent = FONT_DESCENT (font);
-
- if (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0)
- {
- xfree (pcm);
- pcm = NULL;
- }
- return pcm;
+/* Determine if a font is double byte. */
+int w32_font_is_double_byte (XFontStruct *font)
+{
+ return font->double_byte_p;
}
+static BOOL
+w32_use_unicode_for_codepage (codepage)
+ int codepage;
+{
+ /* If the current codepage is supported, use Unicode for output. */
+ return (w32_enable_unicode_output
+ && codepage != CP_8BIT
+ && (codepage == CP_UNICODE || IsValidCodePage (codepage)));
+}
+
/* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
the two-byte form of C. Encoding is returned in *CHAR2B. */
-static INLINE void
-x_encode_char (c, char2b, font_info)
+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);
+
/* FONT_INFO may define a scheme by which to encode byte1 and byte2.
This may be either a program in a special encoder language or a
fixed encoding. */
/* We assume that MSBs are appropriately set/reset by CCL
program. */
- /* NTEMACS_TODO : Use GetFontLanguageInfo to determine if
- font is double byte. */
-#if 0
- if (FONT_MAX_BYTE1 (font) == 0) /* 1-byte font */
-#endif
+ if (!*two_byte_p) /* 1-byte font */
*char2b = BUILD_WCHAR_T (0, ccl->reg[1]);
-#if 0
else
*char2b = BUILD_WCHAR_T (ccl->reg[1], ccl->reg[2]);
-#endif
}
else if (font_info->encoding[charset])
{
temp[0] = BYTE1 (*char2b);
temp[1] = BYTE2 (*char2b);
temp[2] = '\0';
- if (temp[0])
- MultiByteToWideChar (codepage, 0, temp, 2, char2b, 1);
- else
- MultiByteToWideChar (codepage, 0, temp+1, 1, char2b, 1);
- }
+ 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;
}
struct font_info *font_info
= FONT_INFO_FROM_ID (f, face->font_info_id);
if (font_info)
- x_encode_char (c, char2b, font_info);
+ w32_encode_char (c, char2b, font_info, &multibyte_p);
}
}
}
-/* Determine if a font is double byte. */
-int w32_font_is_double_byte (XFontStruct *font)
-{
- /* NTEMACS_TODO: Determine this properly using GetFontLanguageInfo
- or similar. Returning 1 might work, as we use Unicode anyway. */
- return 1;
-}
-
-
/* Get face and two-byte form of character glyph GLYPH on frame F.
The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
a pointer to a realized face that is ready for display. */
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)
{
= FONT_INFO_FROM_ID (f, face->font_info_id);
if (font_info)
{
- x_encode_char (glyph->u.ch, char2b, font_info);
- if (two_byte_p)
- *two_byte_p = w32_font_is_double_byte (font_info->font);
+ glyph->w32_font_type
+ = w32_encode_char (glyph->u.ch, char2b, font_info, two_byte_p);
}
}
}
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
- /* Play it safe. If sub-structures of the glyph are not all the
- same size, it otherwise be that some bits stay set. This
- would prevent a comparison with GLYPH_EQUAL_P. */
- glyph->u.val = 0;
-
- glyph->type = CHAR_GLYPH;
- glyph->pixel_width = it->pixel_width;
- glyph->u.ch = it->char_to_display;
- glyph->face_id = it->face_id;
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
- glyph->left_box_line_p = it->start_of_box_run_p;
- glyph->right_box_line_p = it->end_of_box_run_p;
+ 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];
}
}
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
- /* Play it safe. If sub-structures of the glyph are not all the
- same size, it otherwise be that some bits stay set. This
- would prevent a comparison with GLYPH_EQUAL_P. */
- glyph->u.val = 0;
-
- glyph->type = COMPOSITE_GLYPH;
- glyph->pixel_width = it->pixel_width;
- glyph->u.cmp_id = it->cmp_id;
- glyph->face_id = it->face_id;
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
- glyph->left_box_line_p = it->start_of_box_run_p;
- glyph->right_box_line_p = it->end_of_box_run_p;
+ 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];
}
}
PREPARE_FACE_FOR_DISPLAY (it->f, face);
prepare_image_for_display (it->f, img);
- it->ascent = it->phys_ascent = IMAGE_ASCENT (img);
- it->descent = it->phys_descent = img->height + 2 * img->margin - it->ascent;
- it->pixel_width = img->width + 2 * img->margin;
+ 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;
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
- glyph->type = IMAGE_GLYPH;
- glyph->u.img_id = img->id;
- glyph->face_id = it->face_id;
- glyph->pixel_width = it->pixel_width;
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
- glyph->left_box_line_p = it->start_of_box_run_p;
- glyph->right_box_line_p = it->end_of_box_run_p;
+ 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];
}
}
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
- glyph->type = STRETCH_GLYPH;
- glyph->u.stretch.ascent = height * ascent;
- glyph->u.stretch.height = height;
- glyph->face_id = it->face_id;
- glyph->pixel_width = width;
glyph->charpos = CHARPOS (it->position);
glyph->object = object;
- glyph->left_box_line_p = it->start_of_box_run_p;
- glyph->right_box_line_p = it->end_of_box_run_p;
+ glyph->pixel_width = width;
glyph->voffset = it->voffset;
+ glyph->type = STRETCH_GLYPH;
glyph->multibyte_p = it->multibyte_p;
- ++it->glyph_row->used[area];
- }
-}
+ 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];
+ }
+}
/* Produce a stretch glyph for iterator IT. IT->object is the value
struct it *it;
{
/* (space :width WIDTH :height HEIGHT. */
- extern Lisp_Object QCwidth, QCheight, QCascent, Qspace;
+#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;
*/
#define VCENTER_BASELINE_OFFSET(FONT, F) \
- (FONT_DESCENT (FONT) \
- + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT))) / 2 \
- - (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (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)))
/* Produce glyphs/get display metrics for the display element IT is
loaded with. See the description of struct display_iterator in
int font_not_found_p;
struct font_info *font_info;
int boff; /* baseline offset */
- HDC hdc;
-
- hdc = get_frame_dc (it->f);
+ /* We may change it->multibyte_p upon unibyte<->multibyte
+ conversion. So, save the current value now and restore it
+ later.
+
+ Note: It seems that we don't have to record multibyte_p in
+ struct glyph because the character code itself tells if or
+ not the character is multibyte. Thus, in the future, we must
+ consider eliminating the field `multibyte_p' in the struct
+ glyph.
+ */
+ int saved_multibyte_p = it->multibyte_p;
/* Maybe translate single-byte characters to multibyte, or the
other way. */
|| !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);
}
&& !it->multibyte_p)
{
it->char_to_display = multibyte_char_to_unibyte (it->c, Qnil);
+ it->multibyte_p = 0;
it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
face = FACE_FROM_ID (it->f, it->face_id);
}
boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
}
- if (font->hfont)
- SelectObject (hdc, font->hfont);
-
if (it->char_to_display >= ' '
&& (!it->multibyte_p || it->char_to_display < 128))
{
it->nglyphs = 1;
- pcm = w32_per_char_metric (hdc, font, &char2b, 0);
+ 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;
- it->phys_ascent = pcm->ascent + boff;
- it->phys_descent = pcm->descent - boff;
- it->pixel_width = pcm->width;
+ 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);
+ }
+
/* If this is a space inside a region of text with
`space-width' property, change its width. */
stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
/* If characters with lbearing or rbearing are displayed
in this line, record that fact in a flag of the
glyph row. This is used to optimize X output code. */
- if (pcm->lbearing < 0
- || pcm->rbearing > pcm->width)
+ if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
it->glyph_row->contains_overlapping_glyphs_p = 1;
- xfree (pcm);
}
}
else if (it->char_to_display == '\n')
else if (it->char_to_display == '\t')
{
int tab_width = it->tab_width * CANON_X_UNIT (it->f);
- int x = (it->current_x
- - it->prompt_width
- + it->continuation_lines_width);
+ int x = it->current_x + it->continuation_lines_width;
int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
+ /* If the distance from the current position to the next tab
+ stop is less than a canonical character width, use the
+ tab stop after that. */
+ 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;
default font and calculate the width of the character
from the charset width; this is what old redisplay code
did. */
- pcm = w32_per_char_metric (hdc, font, &char2b, 1);
+ 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)
{
}
else
{
+ it->pixel_width = pcm->width;
it->phys_ascent = pcm->ascent + boff;
it->phys_descent = pcm->descent - boff;
if (it->glyph_row
|| 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 (it->glyph_row)
x_append_glyph (it);
-
- xfree (pcm);
}
- release_frame_dc (it->f, hdc);
+ it->multibyte_p = saved_multibyte_p;
}
else if (it->what == IT_COMPOSITION)
{
- /* NTEMACS_TODO: Composite glyphs. */
+ /* Note: A composition is represented as one glyph in the
+ glyph matrix. There are no padding glyphs. */
+ 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; /* baseline offset */
+ struct composition *cmp = composition_table[it->cmp_id];
+
+ /* Maybe translate single-byte characters to multibyte. */
+ 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);
+ }
+
+ /* Get face and font to use. Encode IT->char_to_display. */
+ 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;
+
+ /* When no suitable font found, use the default 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;
+ }
+
+ /* There are no padding glyphs, so there is only one glyph to
+ produce for the composition. Important is that pixel_width,
+ ascent and descent are the values of what is drawn by
+ draw_glyphs (i.e. the values of the overall glyphs composed). */
+ it->nglyphs = 1;
+
+ /* If we have not yet calculated pixel size data of glyphs of
+ the composition for the current face font, calculate them
+ now. Theoretically, we have to check all fonts for the
+ glyphs, but that requires much time and memory space. So,
+ here we check only the font of the first glyph. This leads
+ to incorrect display very rarely, and C-l (recenter) can
+ correct the display anyway. */
+ if (cmp->font != (void *) font)
+ {
+ /* Ascent and descent of the font of the first character of
+ this composition (adjusted by baseline offset). Ascent
+ and descent of overall glyphs should not be less than
+ them respectively. */
+ int font_ascent = FONT_BASE (font) + boff;
+ int font_descent = FONT_DESCENT (font) - boff;
+ /* Bounding box of the overall glyphs. */
+ 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;
+
+ /* Initialize the bounding box. */
+ 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;
+
+ /* Draw the first glyph at the normal position. It may be
+ shifted to right later if some other glyphs are drawn at
+ the left. */
+ cmp->offsets[0] = 0;
+ cmp->offsets[1] = boff;
+
+ /* Set cmp->offsets for the remaining glyphs. */
+ 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)
+ {
+ /* Relative composition with or without
+ alternate chars. */
+ 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)
+ /* One extra pixel between two glyphs. */
+ btm = highest + 1;
+ else if (ascent <= 0)
+ /* One extra pixel between two glyphs. */
+ btm = lowest - 1 - ascent - descent;
+ }
+ }
+ else
+ {
+ /* A composition rule is specified by an integer
+ value that encodes global and new reference
+ points (GREF and NREF). GREF and NREF are
+ specified by numbers as below:
+
+ 0---1---2 -- ascent
+ | |
+ | |
+ | |
+ 9--10--11 -- center
+ | |
+ ---3---4---5--- baseline
+ | |
+ 6---7---8 -- descent
+ */
+ 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;
+
+ /* Update the bounding box of the overall glyphs. */
+ 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 there are glyphs whose x-offsets are negative,
+ shift all glyphs to the right and make all x-offsets
+ non-negative. */
+ 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;
+ it->ascent += thick;
+ it->descent += 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 has an overline, add the height of the overline
+ (1 pixel) and a 1 pixel margin to the character height. */
+ 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);
- /* Accumulate dimensions. */
- xassert (it->ascent >= 0 && it->descent > 0);
+ /* Accumulate dimensions. Note: can't assume that it->descent > 0
+ because this isn't true for images with `:ascent 100'. */
+ 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);
struct frame *f;
enum face_id face_id;
{
- int height = 1;
+ int height = FONT_HEIGHT (FRAME_FONT (f));
/* This function is called so early when Emacs starts that the face
cache and mode line face are not yet initialized. */
if (FRAME_FACE_CACHE (f))
{
struct face *face = FACE_FROM_ID (f, face_id);
- if (face && face->font)
- height = FONT_HEIGHT (face->font) + 2 * face->box_line_width;
+ if (face)
+ {
+ if (face->font)
+ height = FONT_HEIGHT (face->font);
+ height += 2 * face->box_line_width;
+ }
}
return height;
}
-\f
-/* Get the Windows codepage corresponding to the specified font. The
- charset info in the font name is used to look up
- w32-charset-to-codepage-alist. */
-int
-w32_codepage_for_font (char *fontname)
-{
- Lisp_Object codepage;
- char charset_str[20], *charset, *end;
-
- /* Extract charset part of font string. */
- if (sscanf (fontname,
- "-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%19s",
- charset_str) == EOF)
- return CP_DEFAULT;
-
- /* Remove leading "*-". */
- if (strncmp ("*-", charset_str, 2) == 0)
- charset = charset_str + 2;
- else
- charset = charset_str;
-
- /* Stop match at wildcard (including preceding '-'). */
- if (end = strchr (charset, '*'))
- {
- if (end > charset && *(end-1) == '-')
- end--;
- *end = '\0';
- }
-
- codepage = Fcdr (Fcdr (Fassoc (build_string(charset),
- Vw32_charset_info_alist)));
- if (INTEGERP (codepage))
- return XINT (codepage);
- else
- return CP_DEFAULT;
-}
-
-BOOL
-w32_use_unicode_for_codepage (codepage)
- int codepage;
-{
- /* If the current codepage is supported, use Unicode for output. */
- return (w32_enable_unicode_output
- && codepage != CP_DEFAULT && IsValidCodePage (codepage));
-}
-
\f
/***********************************************************************
Glyph display
};
-/* Encapsulate the different ways of printing text under W32. */
+/* Encapsulate the different ways of displaying text under W32. */
-void W32_TEXTOUT(s, x, y,chars,nchars)
+void W32_TEXTOUT (s, x, y,chars,nchars)
struct glyph_string * s;
int x, y;
wchar_t * chars;
int nchars;
{
- /* NTEMACS_TODO: Find way to figure out charset_dim. */
- /* int charset_dim = CHARSET_DIMENSION (s->charset); */
+ 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, 1 /* charset_dim */, nchars, 0);
- else if (s->two_byte_p)
+ 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);
+ nchars * charset_dim, NULL);
}
#if 0
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 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));
+ 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 *, int *, int));
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_underline P_ ((struct glyph_string *));
-static void x_draw_glyph_string_underline 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_mouse_face_gc P_ ((struct glyph_string *));
static void w32_get_glyph_overhangs P_ ((HDC hdc, struct glyph *,
struct frame *,
- int *, int *, int));
+ 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 *,
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
/* Append the list of glyph strings with head H and tail T to the list
int face_id;
struct face *face;
- /* What face has to be used for the mouse face? */
+ /* What face has to be used last for the mouse face? */
face_id = FRAME_W32_DISPLAY_INFO (s->f)->mouse_face_face_id;
face = FACE_FROM_ID (s->f, face_id);
- face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
+ 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);
struct glyph_string *s;
{
s->gc = s->face->gc;
- xassert (s->gc != 0);
}
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;
x_compute_glyph_string_overhangs (s)
struct glyph_string *s;
{
- if (s->cmp == NULL
- && s->first_glyph->type == CHAR_GLYPH)
- {
- XCharStruct cs;
- int direction, font_ascent, font_descent;
- XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
- &font_ascent, &font_descent, &cs);
- s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
- s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
- }
+ /* TODO: Windows does not appear to have a method for
+ getting this info without getting the ABC widths for each
+ individual character and working it out manually. */
}
assumed to be zero. */
static void
-w32_get_glyph_overhangs (hdc, glyph, f, left, right, unicode_p)
+w32_get_glyph_overhangs (hdc, glyph, f, left, right)
HDC hdc;
struct glyph *glyph;
struct frame *f;
- int *left, *right, unicode_p;
+ int *left, *right;
{
- int c;
-
*left = *right = 0;
if (glyph->type == CHAR_GLYPH)
{
XFontStruct *font;
struct face *face;
- struct font_info *font_info;
wchar_t char2b;
XCharStruct *pcm;
face = x_get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
font = face->font;
- font_info = FONT_INFO_FROM_ID (f, face->font_info_id);
+
if (font
- && (pcm = w32_per_char_metric (hdc, font, &char2b, unicode_p)))
+ && (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;
- xfree (pcm);
}
}
}
int *left, *right;
{
HDC hdc = get_frame_dc (f);
- w32_get_glyph_overhangs (hdc, glyph, f, left, right, glyph->multibyte_p);
+ /* Convert to unicode! */
+ w32_get_glyph_overhangs (hdc, glyph, f, left, right);
release_frame_dc (f, hdc);
}
for (i = first - 1; i >= 0; --i)
{
int left, right;
- w32_get_glyph_overhangs (s->hdc, glyphs + i, s->f, &left,
- &right, s->two_byte_p);
+ w32_get_glyph_overhangs (s->hdc, glyphs + i, s->f, &left, &right);
if (x + right > 0)
k = i;
x -= glyphs[i].pixel_width;
for (i = first; i < end; ++i)
{
int left, right;
- w32_get_glyph_overhangs (s->hdc, glyphs + i, s->f, &left,
- &right, s->two_byte_p);
+ w32_get_glyph_overhangs (s->hdc, glyphs + i, s->f, &left, &right);
if (x - left < 0)
k = i;
x += glyphs[i].pixel_width;
shouldn't be drawn in the first place. */
if (!s->background_filled_p)
{
-#if 0 /* NTEMACS_TODO: stipple */
+#if 0 /* TODO: stipple */
if (s->stippled_p)
{
/* Fill background with a stipple pattern. */
if (FONT_HEIGHT (s->font) < s->height - 2 * s->face->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 + s->face->box_line_width,
struct glyph_string *s;
{
int i, x;
+ HFONT old_font;
/* If first glyph of S has a left box line, start drawing the text
of S to the right of that box line. */
SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
if (s->font && s->font->hfont)
- SelectObject (s->hdc, s->font->hfont);
+ old_font = SelectObject (s->hdc, s->font->hfont);
/* Draw characters of S as rectangles if S's font could not be
loaded. */
/* Draw text with TextOut and friends. */
W32_TEXTOUT (s, x, s->ybase - boff, s->char2b, s->nchars);
}
+ if (s->font && s->font->hfont)
+ SelectObject (s->hdc, old_font);
}
/* Draw the foreground of composite glyph string S. */
struct glyph_string *s;
{
int i, x;
+ HFONT old_font;
/* If first glyph of S has a left box line, start drawing the text
of S to the right of that box line. */
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);
+
/* Draw a rectangle for the composition if the font for the very
first character of the composition could not be loaded. */
if (s->font_not_found_p)
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);
+ 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);
}
+
+/* Brightness beyond which a color won't have its highlight brightness
+ boosted.
+
+ Nominally, highlight colors for `3d' faces are calculated by
+ brightening an object's color by a constant scale factor, but this
+ doesn't yield good results for dark colors, so for colors who's
+ brightness is less than this value (on a scale of 0-255) have to
+ use an additional additive factor.
+
+ The value here is set so that the default menu-bar/mode-line color
+ (grey75) will not have its highlights changed at all. */
+#define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
+
+
/* Allocate a color which is lighter or darker than *COLOR by FACTOR
or DELTA. Try a color with RGB values multiplied by FACTOR first.
If this produces the same color as COLOR, try a color where all RGB
int delta;
{
COLORREF new;
+ long bright;
+
+ /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
+ delta /= 256;
/* Change RGB values by specified FACTOR. Avoid overflow! */
xassert (factor >= 0);
new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
min (0xff, factor * GetGValue (*color)),
min (0xff, factor * GetBValue (*color)));
+
+ /* Calculate brightness of COLOR. */
+ bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
+ + GetBValue (*color)) / 6;
+
+ /* We only boost colors that are darker than
+ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
+ if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
+ /* Make an additive adjustment to NEW, because it's dark enough so
+ that scaling by FACTOR alone isn't enough. */
+ {
+ /* How far below the limit this color is (0 - 1, 1 being darker). */
+ double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
+ /* The additive adjustment. */
+ 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))));
- /* NTEMACS_TODO: Map to palette and retry with delta if same? */
- /* NTEMACS_TODO: Free colors (if using palette)? */
+ /* TODO: Map to palette and retry with delta if same? */
+ /* TODO: Free colors (if using palette)? */
if (new == *color)
return 0;
COLORREF background = di->relief_background;
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
- /* NTEMACS_TODO: Free colors (if using palette)? */
+ /* TODO: Free colors (if using palette)? */
/* Allocate new color. */
xgcv.foreground = default_pixel;
if (relief->gc == 0)
{
-#if 0 /* NTEMACS_TODO: stipple */
+#if 0 /* TODO: stipple */
xgcv.stipple = dpyinfo->gray;
mask |= GCStipple;
#endif
HDC hdc = get_frame_dc (f);
if (raised_p)
- gc.foreground = PALETTERGB (255, 255, 255);
+ gc.foreground = f->output_data.w32->white_relief.gc->foreground;
else
- gc.foreground = PALETTERGB (0, 0, 0);
+ gc.foreground = f->output_data.w32->black_relief.gc->foreground;
w32_set_clip_rectangle (hdc, clip_rect);
w32_set_clip_rectangle (hdc, NULL);
if (raised_p)
- gc.foreground = PALETTERGB (0, 0, 0);
+ gc.foreground = f->output_data.w32->black_relief.gc->foreground;
else
- gc.foreground = PALETTERGB (255, 255, 255);
+ gc.foreground = f->output_data.w32->white_relief.gc->foreground;
+
w32_set_clip_rectangle (hdc, clip_rect);
/* Top. */
w32_fill_area (s->f, s->hdc, s->face->box_color,
- left_x, top_y, right_x - left_x, width);
+ left_x, top_y, right_x - left_x + 1, width);
/* Left. */
if (left_p)
{
w32_fill_area (s->f, s->hdc, s->face->box_color,
- left_x, top_y, width, bottom_y - top_y);
+ left_x, top_y, width, bottom_y - top_y + 1);
}
/* Bottom. */
w32_fill_area (s->f, s->hdc, s->face->box_color,
- left_x, bottom_y - width, right_x - left_x, width);
+ left_x, bottom_y - width + 1, right_x - left_x + 1, width);
/* Right. */
if (right_p)
{
w32_fill_area (s->f, s->hdc, s->face->box_color,
- right_x - width, top_y, width, bottom_y - top_y);
+ right_x - width + 1, top_y, width, bottom_y - top_y + 1);
}
w32_set_clip_rectangle (s->hdc, NULL);
struct glyph_string *s;
{
int x;
- int y = s->ybase - IMAGE_ASCENT (s->img);
+ int y = s->ybase - image_ascent (s->img, s->face);
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
- if (s->img->margin)
- {
- x += s->img->margin;
- y += s->img->margin;
- }
+ x += s->img->hmargin;
+ y += s->img->vmargin;
SaveDC (s->hdc);
if (s->img->pixmap)
{
-#if 0 /* NTEMACS_TODO: image mask */
+#if 0 /* TODO: image mask */
if (s->img->mask)
{
/* We can't set both a clip mask and use XSetClipRectangles
image_rect.y = y;
image_rect.width = s->img->width;
image_rect.height = s->img->height;
- if (w32_intersect_rectangles (&clip_rect, &image_rect, &r))
+ 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);
}
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 /* From w32bdf.c (which is from Meadow). */
BitBlt (s->hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, SRCCOPY);
-#else
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);
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
int x0, y0, x1, y1, thick, raised_p;
RECT r;
int x;
- int y = s->ybase - IMAGE_ASCENT (s->img);
-
+ int y = s->ybase - image_ascent (s->img, s->face);
+
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
if (s->face->box != FACE_NO_BOX
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
- if (s->img->margin)
- {
- x += s->img->margin;
- y += s->img->margin;
- }
+ x += s->img->hmargin;
+ y += s->img->vmargin;
if (s->hl == DRAW_IMAGE_SUNKEN
|| s->hl == DRAW_IMAGE_RAISED)
HDC hdc = CreateCompatibleDC (s->hdc);
HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap);
int x;
- int y = s->ybase - s->y - IMAGE_ASCENT (s->img);
+ int y = s->ybase - s->y - image_ascent (s->img, s->face);
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
- if (s->img->margin)
- {
- x += s->img->margin;
- y += s->img->margin;
- }
+ x += s->img->hmargin;
+ y += s->img->vmargin;
if (s->img->pixmap)
{
-#if 0 /* NTEMACS_TODO: image mask */
+#if 0 /* TODO: image mask */
if (s->img->mask)
{
/* We can't set both a clip mask and use XSetClipRectangles
#if 0 /* From w32bdf.c (which is from Meadow). */
BitBlt (hdc, x, y, s->img->width, s->img->height,
compat_hdc, 0, 0, SRCCOPY);
-#else
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);
struct glyph_string *s;
int x, y, w, h;
{
-#if 0 /* NTEMACS_TODO: stipple */
+#if 0 /* TODO: stipple */
if (s->stippled_p)
{
/* Fill background with a stipple pattern. */
| s->face->box
|
| +-------------------------
- | | s->img->margin
+ | | s->img->vmargin
| |
| | +-------------------
| | | the image
{
int x, y;
int box_line_width = s->face->box_line_width;
- int margin = s->img->margin;
int height;
HBITMAP pixmap = 0;
flickering. */
s->stippled_p = s->face->stipple != 0;
if (height > s->img->height
- || margin
-#if 0 /* NTEMACS_TODO: image mask */
+ || s->img->hmargin
+ || s->img->vmargin
+#if 0 /* TODO: image mask */
|| s->img->mask
#endif
|| s->img->pixmap == 0
x = s->x;
y = s->y + box_line_width;
-#if 0 /* NTEMACS_TODO: image mask */
+#if 0 /* TODO: image mask */
if (s->img->mask)
{
- /* Create a pixmap as large as the glyph string Fill it with
- the background color. Copy the image to it, using its
- mask. Copy the temporary pixmap to the display. */
+ /* Create a pixmap as large as the glyph string. Fill it
+ with the background color. Copy the image to it, using
+ its mask. Copy the temporary pixmap to the display. */
Screen *screen = FRAME_X_SCREEN (s->f);
int depth = DefaultDepthOfScreen (screen);
}
else
#endif
- /* Implementation idea: Is it possible to construct a mask?
- We could look at the color at the margins of the image, and
- say that this color is probably the background color of the
- image. */
x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
s->background_filled_p = 1;
#if 0 /* From w32bdf.c (which is from Meadow). */
BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
compat_hdc, 0, 0, SRCCOPY);
-#else
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);
w32_get_glyph_string_clip_rect (s, &r);
w32_set_clip_rectangle (hdc, &r);
-#if 0 /* NTEMACS_TODO: stipple */
+#if 0 /* TODO: stipple */
if (s->face->stipple)
{
/* Fill background with a stipple pattern. */
if (!s->for_overlaps_p)
{
/* Draw underline. */
- if (s->face->underline_p && (!s->font->bdf && !s->font->tm.tmUnderlined))
+ if (s->face->underline_p
+ && (s->font->bdf || !s->font->tm.tmUnderlined))
{
unsigned long h = 1;
unsigned long dy = s->height - h;
}
/* Draw strike-through. */
- if (s->face->strike_through_p && (!s->font->bdf &&!s->font->tm.tmStruckOut))
+ if (s->face->strike_through_p
+ && (s->font->bdf || !s->font->tm.tmStruckOut))
{
unsigned long h = 1;
unsigned long dy = (s->height - h) / 2;
struct face **, int));
-/* Load glyph string S with a composition components specified by S->cmp.
+/* Fill glyph string S with composition components specified by S->cmp.
+
FACES is an array of faces for all components of this composition.
S->gidx is the index of the first component for S.
OVERLAPS_P non-zero means S should draw the foreground only, and
- use its lines physical height for clipping.
+ use its physical height for clipping.
Value is the index of a component not in S. */
}
-/* Load glyph string S with a sequence of characters.
+/* Fill glyph string S from a sequence of character glyphs.
+
FACE_ID is the face id of the string. START is the index of the
first glyph to consider, END is the index of the last + 1.
OVERLAPS_P non-zero means S should draw the foreground only, and
- use its lines physical height for clipping.
+ use its physical height for clipping.
Value is the index of the first glyph not in S. */
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;
}
-/* Fill glyph string S from stretch glyph S->first_glyph. */
+/* Fill glyph string S from a sequence of stretch glyphs.
-static void
-x_fill_stretch_glyph_string (s)
+ ROW is the glyph row in which the glyphs are found, AREA is the
+ area within the row. START is the index of the first glyph to
+ consider, END is the index of the last + 1.
+
+ Value is the index of the first glyph not in S. */
+
+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);
- s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
+
+ 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->width = s->first_glyph->pixel_width;
+ 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;
/* Adjust base line for subscript/superscript text. */
- s->ybase += s->first_glyph->voffset;
+ s->ybase += voffset;
+
+ xassert (s->face && s->face->gc);
+ return glyph - s->row->glyphs[s->area];
}
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
- x_fill_stretch_glyph_string (s); \
+ START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
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, charset, face_id; \
+ 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); \
s = first_s; \
} while (0)
+
/* Build a list of glyph strings between HEAD and TAIL for the glyphs
of AREA of glyph row ROW on window W between indices START and END.
HL overrides the face for drawing glyph strings, e.g. it is
HDC hdc = get_frame_dc (XFRAME (WINDOW_FRAME (w)));
/* Let's rather be paranoid than getting a SEGV. */
- start = max (0, start);
end = min (end, row->used[area]);
+ start = max (0, start);
+ start = min (end, start);
if (real_start)
*real_start = start;
if (real_end)
end of the drawing area. */
if (row->full_width_p)
{
- struct frame *f = XFRAME (WINDOW_FRAME (w));
-
/* X is relative to the left edge of W, without scroll bars
or flag areas. */
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
/* int width = FRAME_FLAGS_AREA_WIDTH (f); */
int window_left_x = WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f);
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
/* If there are any glyphs with lbearing < 0 or rbearing > width in
the row, redraw some glyphs in front or following the glyph
strings built above. */
- if (!overlaps_p && row->contains_overlapping_glyphs_p)
+ if (head && !overlaps_p && row->contains_overlapping_glyphs_p)
{
int dummy_x = 0;
struct glyph_string *h, *t;
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;
if (real_start)
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);
if (real_end)
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_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 ();
}
else
f = SELECTED_FRAME ();
+ if (! FRAME_W32_P (f))
+ return;
+
/* Clearing the frame will erase any cursor, so mark them all as no
longer visible. */
mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
static void
w32_ring_bell (void)
{
+ struct frame *f;
+
+ f = SELECTED_FRAME ();
+
BLOCK_INPUT;
- if (visible_bell)
+ if (FRAME_W32_P (f) && visible_bell)
{
int i;
HWND hwnd = FRAME_W32_WINDOW (SELECTED_FRAME ());
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 ();
}
release_frame_dc (f, hdc);
}
+
\f
/***********************************************************************
Exposure Events
window_rect.right = window_x + window_width;
window_rect.bottom = window_y + window_height;
- if (w32_intersect_rectangles (&r, &window_rect, &intersection_rect))
+ if (IntersectRect (&intersection_rect, &r, &window_rect))
expose_window (w, &intersection_rect);
}
}
window_rect.bottom = window_rect.top
+ window_height + CURRENT_MODE_LINE_HEIGHT (w);
- if (w32_intersect_rectangles (r, &window_rect, &intersection_rect))
+ if (IntersectRect (&intersection_rect, r, &window_rect))
expose_window (w, &intersection_rect);
}
RECT *r;
enum glyph_row_area area;
{
- int x;
struct glyph *first = row->glyphs[area];
struct glyph *end = row->glyphs[area] + row->used[area];
struct glyph *last;
- int first_x;
-
- /* Set x to the window-relative start position for drawing glyphs of
- AREA. The first glyph of the text area can be partially visible.
- The first glyphs of other areas cannot. */
- 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));
+ int first_x, start_x, x;
if (area == TEXT_AREA && row->fill_line_p)
/* If row extends face to end of line write the whole line. */
- x_draw_glyphs (w, x, row, area,
+ x_draw_glyphs (w, 0, row, area,
0, row->used[area],
row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
NULL, NULL, 0);
else
{
+ /* Set START_X to the window-relative start position for drawing glyphs of
+ AREA. The first glyph of the text area can be partially visible.
+ The first glyphs of other areas cannot. */
+ 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;
+
/* Find the first glyph that must be redrawn. */
while (first < end
&& x + first->pixel_width < r->left)
x += last->pixel_width;
++last;
}
-
+
/* Repaint. */
if (last > first)
- x_draw_glyphs (w, first_x, row, area,
+ 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,
cr.top = w->phys_cursor.y;
cr.right = cr.left + cursor_glyph->pixel_width;
cr.bottom = cr.top + w->phys_cursor_height;
- return w32_intersect_rectangles (&cr, r, &result);
+ return IntersectRect (&result, &cr, r);
}
else
return 0;
happen when toolkit scroll bars are used and a window is split.
Reconfiguring the scroll bar will generate an expose for a newly
created window. */
- if (w->current_matrix == NULL)
+ if (w->current_matrix == NULL || w == updated_window)
return;
TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
}
}
-
-/* Determine the intersection of two rectangles R1 and R2. Return
- the intersection in *RESULT. Value is non-zero if RESULT is not
- empty. */
-
-static int
-w32_intersect_rectangles (r1, r2, result)
- RECT *r1, *r2, *result;
-{
- RECT *left, *right;
- RECT *upper, *lower;
- int intersection_p = 0;
-
- /* Arrange so that left is the left-most rectangle. */
- if (r1->left < r2->left)
- left = r1, right = r2;
- else
- left = r2, right = r1;
-
- /* X0 of the intersection is right.x0, if this is inside R1,
- otherwise there is no intersection. */
- if (right->left <= left->right)
- {
- result->left = right->left;
-
- /* The right end of the intersection is the minimum of the
- the right ends of left and right. */
- result->right = min (left->right, right->right);
-
- /* Same game for Y. */
- if (r1->top < r2->top)
- upper = r1, lower = r2;
- else
- upper = r2, lower = r1;
-
- /* The upper end of the intersection is lower.y0, if this is inside
- of upper. Otherwise, there is no intersection. */
- if (lower->top <= upper->bottom)
- {
- result->top = lower->top;
-
- /* The lower end of the intersection is the minimum of the lower
- ends of upper and lower. */
- result->bottom = min (lower->bottom, upper->bottom);
- intersection_p = 1;
- }
- }
-
- return intersection_p;
-}
-
\f
static void
frame_highlight (f)
x_update_cursor (f, 1);
}
-
/* The focus has changed. Update the frames as necessary to reflect
the new situation. Note that we can't change the selected frame
here, because the Lisp code we are interrupting might become confused.
Each event gets marked with the frame in which it occurred, so the
Lisp code can tell when the switch took place by examining the events. */
-void
+static void
x_new_focus_frame (dpyinfo, frame)
struct w32_display_info *dpyinfo;
struct frame *frame;
/* The focus has changed, or we have redirected a frame's focus to
another frame (this happens when a frame uses a surrogate
- minibuffer frame). Shift the highlight as appropriate.
+ mini-buffer frame). Shift the highlight as appropriate.
The FRAME argument doesn't necessarily have anything to do with which
- frame is being highlighted or unhighlighted; we only use it to find
- the appropriate display info. */
+ frame is being highlighted or un-highlighted; we only use it to find
+ the appropriate X display info. */
+
static void
w32_frame_rehighlight (frame)
struct frame *frame;
{
+ if (! FRAME_W32_P (frame))
+ return;
x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame));
}
static char value[100];
BLOCK_INPUT;
- GetKeyNameText(keysym, value, 100);
+ GetKeyNameText (keysym, value, 100);
UNBLOCK_INPUT;
return value;
}
+
+
\f
/* Mouse clicks and mouse movement. Rah. */
-/* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
- glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
- that the glyph at X, Y occupies, if BOUNDS != 0.
- If NOCLIP is nonzero, do not force the value into range. */
+/* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
+ co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
+ glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
+ not force the value into range. */
void
pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
/* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
even for negative values. */
if (pix_x < 0)
- pix_x -= FONT_WIDTH ((f)->output_data.w32->font) - 1;
+ pix_x -= FONT_WIDTH (FRAME_FONT (f)) - 1;
if (pix_y < 0)
pix_y -= (f)->output_data.w32->line_height - 1;
{
bounds->left = CHAR_TO_PIXEL_COL (f, pix_x);
bounds->top = CHAR_TO_PIXEL_ROW (f, pix_y);
- bounds->right = bounds->left + FONT_WIDTH (f->output_data.w32->font) - 1;
+ bounds->right = bounds->left + FONT_WIDTH (FRAME_FONT (f)) - 1;
bounds->bottom = bounds->top + f->output_data.w32->line_height - 1;
}
{
if (pix_x < 0)
pix_x = 0;
- else if (pix_x > f->width)
- pix_x = f->width;
+ else if (pix_x > FRAME_WINDOW_WIDTH (f))
+ pix_x = FRAME_WINDOW_WIDTH (f);
if (pix_y < 0)
pix_y = 0;
If the event is a button press, then note that we have grabbed
the mouse. */
-static void
+static Lisp_Object
construct_mouse_click (result, msg, f)
struct input_event *result;
W32Msg *msg;
? up_modifier
: down_modifier));
- {
- int row, column;
-
- XSETINT (result->x, LOWORD (msg->msg.lParam));
- XSETINT (result->y, HIWORD (msg->msg.lParam));
- XSETFRAME (result->frame_or_window, f);
- }
+ 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 void
+static Lisp_Object
construct_mouse_wheel (result, msg, f)
struct input_event *result;
W32Msg *msg;
result->modifiers = msg->dwModifiers;
p.x = LOWORD (msg->msg.lParam);
p.y = HIWORD (msg->msg.lParam);
- ScreenToClient(msg->msg.hwnd, &p);
+ 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 void
+static Lisp_Object
construct_drag_n_drop (result, msg, f)
struct input_event *result;
W32Msg *msg;
XSETFRAME (frame, f);
result->frame_or_window = Fcons (frame, files);
+ result->arg = Qnil;
+ return Qnil;
}
\f
{
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
-
note_mouse_highlight (frame, LOWORD (msg->lParam), HIWORD (msg->lParam));
}
}
/* This is used for debugging, to turn off note_mouse_highlight. */
+
int disable_mouse_highlight;
int *hpos, *vpos, *area;
{
struct glyph *glyph, *end;
- struct glyph_row *row;
+ struct glyph_row *row = NULL;
int x0, i, left_area_width;
/* Find row containing Y. Give up if some row is not enabled. */
}
-/* Take proper action when mouse has moved to the mode or top line of
+/* Take proper action when mouse has moved to the mode or header line of
window W, x-position X. MODE_LINE_P non-zero means mouse is on the
mode line. X is relative to the start of the text display area of
W, so the width of bitmap areas and scroll bars must be subtracted
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)
{
setting the global variable help_echo to the help string. */
help = Fget_text_property (make_number (glyph->charpos),
Qhelp_echo, glyph->object);
- if (STRINGP (help))
- help_echo = help;
+ if (!NILP (help))
+ {
+ help_echo = help;
+ XSETWINDOW (help_echo_window, w);
+ help_echo_object = glyph->object;
+ help_echo_pos = glyph->charpos;
+ }
/* Change the mouse pointer according to what is under X/Y. */
map = Fget_text_property (make_number (glyph->charpos),
Qlocal_map, glyph->object);
- if (!NILP (Fkeymapp (map)))
+ 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 /* NTEMACS_TODO: mouse cursor */
+
+#if 0 /* TODO: mouse cursor */
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
#endif
}
-/* Take proper action when the mouse has moved to position X, Y on frame F
- as regards highlighting characters that have mouse-face properties.
- Also dehighlighting chars where the mouse was before.
+
+/* Take proper action when the mouse has moved to position X, Y on
+ frame F as regards highlighting characters that have mouse-face
+ properties. Also de-highlighting chars where the mouse was before.
X and Y can be negative or out of range. */
static void
note_mouse_highlight (f, x, y)
- FRAME_PTR f;
+ struct frame *f;
int x, y;
{
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
if (popup_activated ())
return;
- if (disable_mouse_highlight || !f->glyphs_initialized_p)
+ if (disable_mouse_highlight
+ || !f->glyphs_initialized_p)
return;
dpyinfo->mouse_face_mouse_x = x;
note_mode_line_highlight (w, x, portion == 1);
return;
}
-#if 0 /* NTEMACS_TODO: mouse cursor */
+#if 0 /* TODO: mouse cursor */
+ 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);
/* Are we in a window whose display is up to date?
And verify the buffer's text has not changed. */
- if (/* Within the text portion of the window. */
+ if (/* Within text portion of the window. */
portion == 0
&& EQ (w->window_end_valid, w->buffer)
- && w->last_modified == BUF_MODIFF (XBUFFER (w->buffer))
- && w->last_overlay_modified == BUF_OVERLAY_MODIFF (XBUFFER (w->buffer)))
+ && XFASTINT (w->last_modified) == BUF_MODIFF (XBUFFER (w->buffer))
+ && (XFASTINT (w->last_overlay_modified)
+ == BUF_OVERLAY_MODIFF (XBUFFER (w->buffer))))
{
int hpos, vpos, pos, i, area;
struct glyph *glyph;
enough space for all, and try again. */
len = 10;
overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
- noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL);
+ 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);
+ noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL,0);
}
+ /* Sort overlays into increasing priority order. */
noverlays = sort_overlays (overlay_vec, noverlays, w);
/* Check mouse-face highlighting. */
/* Find the highest priority overlay that has a mouse-face prop. */
overlay = Qnil;
- for (i = 0; i < noverlays; i++)
+ for (i = noverlays - 1; i >= 0; --i)
{
mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
if (!NILP (mouse_face))
/* Look for a `help-echo' property. */
{
- Lisp_Object help;
+ Lisp_Object help, overlay;
/* Check overlays first. */
- help = Qnil;
- for (i = 0; i < noverlays && !STRINGP (help); ++i)
- help = Foverlay_get (overlay_vec[i], Qhelp_echo);
-
- /* Try text properties. */
- if (!STRINGP (help)
- && ((STRINGP (glyph->object)
+ 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
+ {
+ /* Try text properties. */
+ if ((STRINGP (glyph->object)
&& glyph->charpos >= 0
&& glyph->charpos < XSTRING (glyph->object)->size)
|| (BUFFERP (glyph->object)
&& glyph->charpos >= BEGV
- && glyph->charpos < ZV)))
- help = Fget_text_property (make_number (glyph->charpos),
- Qhelp_echo, glyph->object);
+ && glyph->charpos < ZV))
+ help = Fget_text_property (make_number (glyph->charpos),
+ Qhelp_echo, glyph->object);
- if (STRINGP (help))
- help_echo = help;
+ if (!NILP (help))
+ {
+ help_echo = help;
+ help_echo_window = window;
+ help_echo_object = glyph->object;
+ help_echo_pos = glyph->charpos;
+ }
+ }
}
BEGV = obegv;
}
}
-\f
static void
redo_mouse_highlight ()
{
Return in *GLYPH a pointer to the glyph of the tool-bar item in
the current matrix of the tool-bar window of F, or NULL if not
on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
- item in F->current_tool_bar_items. Value is
+ item in F->tool_bar_items. Value is
-1 if X/Y is not on a tool-bar item
0 if X/Y is on the same item that was highlighted before.
return -1;
/* Get the start of this tool-bar item's properties in
- f->current_tool_bar_items. */
+ f->tool_bar_items. */
if (!tool_bar_item_info (f, *glyph, prop_idx))
return -1;
}
-/* Handle mouse button event on the tool_bar of frame F, at
+/* Handle mouse button event on the tool-bar of frame F, at
frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
or ButtonRelase. */
return;
/* If item is disabled, do nothing. */
- enabled_p = (XVECTOR (f->current_tool_bar_items)
- ->contents[prop_idx + TOOL_BAR_ITEM_ENABLED_P]);
+ enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
if (NILP (enabled_p))
return;
show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
- key = (XVECTOR (f->current_tool_bar_items)
- ->contents[prop_idx + TOOL_BAR_ITEM_KEY]);
+ key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
XSETFRAME (frame, f);
event.kind = TOOL_BAR_EVENT;
- event.frame_or_window = Fcons (frame, Fcons (Qtool_bar, Qnil));
+ event.frame_or_window = frame;
+ event.arg = frame;
kbd_buffer_store_event (&event);
event.kind = TOOL_BAR_EVENT;
- event.frame_or_window = Fcons (frame, key);
+ event.frame_or_window = frame;
+ event.arg = key;
event.modifiers = button_event->modifiers;
kbd_buffer_store_event (&event);
last_tool_bar_item = -1;
}
-/* Possibly highlight a tool_bar item on frame F when mouse moves to
+/* Possibly highlight a tool-bar item on frame F when mouse moves to
tool-bar window-relative coordinates X/Y. Called from
note_mouse_highlight. */
draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
/* If tool-bar item is not enabled, don't highlight it. */
- enabled_p = (XVECTOR (f->current_tool_bar_items)
- ->contents[prop_idx + TOOL_BAR_ITEM_ENABLED_P]);
+ enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
if (!NILP (enabled_p))
{
/* Compute the x-position of the glyph. In front and past the
/* Set help_echo to a help string.to display for this tool-bar item.
w32_read_socket does the rest. */
- help_echo = (XVECTOR (f->current_tool_bar_items)
- ->contents[prop_idx + TOOL_BAR_ITEM_HELP]);
- if (!STRINGP (help_echo))
- help_echo = (XVECTOR (f->current_tool_bar_items)
- ->contents[prop_idx + TOOL_BAR_ITEM_CAPTION]);
+ 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);
}
+
\f
/* Find the glyph matrix position of buffer position POS in window W.
*HPOS, *VPOS, *X, and *Y are set to the positions found. W's
best_row_vpos = row_vpos;
}
+ if (row->y + row->height >= yb)
+ break;
+
++row;
++row_vpos;
}
}
if (end_hpos > start_hpos)
- x_draw_glyphs (w, start_x, row, TEXT_AREA,
- start_hpos, end_hpos, draw, NULL, NULL, 0);
+ {
+ row->mouse_face_p = draw == DRAW_MOUSE_FACE;
+ x_draw_glyphs (w, start_x, row, TEXT_AREA,
+ start_hpos, end_hpos, draw, NULL, NULL, 0);
+ }
}
/* If we turned the cursor off, turn it back on. */
output_cursor = saved_cursor;
set_x_cursor:
-#if 0 /* NTEMACS_TODO: mouse cursor */
+#if 0 /* TODO: mouse cursor */
/* Change the mouse cursor. */
if (draw == DRAW_NORMAL_TEXT)
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
;
}
-
/* Clear out the mouse-highlighted active region.
- Redraw it unhighlighted first. */
+ Redraw it un-highlighted first. */
void
clear_mouse_face (dpyinfo)
struct w32_display_info *dpyinfo;
{
- if (tip_frame)
+#if 0 /* This prevents redrawing tool bar items when changing from one
+ to another while a tooltip is open, so don't do it. */
+ if (!NILP (tip_frame))
return;
+#endif
if (! NILP (dpyinfo->mouse_face_window))
show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
dpyinfo->mouse_face_window = Qnil;
}
+
+/* Clear any mouse-face on window W. This function is part of the
+ redisplay interface, and is called from try_window_id and similar
+ functions to ensure the mouse-highlight is off. */
+
+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;
+}
+
+
/* Just discard the mouse face information for frame F, if any.
This is used when the size of F is changed. */
}
}
\f
-struct scroll_bar *x_window_to_scroll_bar ();
+static struct scroll_bar *x_window_to_scroll_bar ();
static void x_scroll_bar_report_motion ();
/* Return the current position of the mouse.
mouse is on, *bar_window to nil, and *x and *y to the character cell
the mouse is over.
- Set *time to the server timestamp for the time at which the mouse
+ Set *time to the server time-stamp for the time at which the mouse
was at this position.
Don't store anything if we don't have a valid set of values to report.
This clears the mouse_moved flag, so we can wait for the next mouse
- movement. This also calls XQueryPointer, which will cause the
- server to give us another MotionNotify when the mouse moves
- again. */
+ movement. */
static void
w32_mouse_position (fp, insist, bar_window, part, x, y, time)
BLOCK_INPUT;
if (! NILP (last_mouse_scroll_bar) && insist == 0)
- /* This is never called at the moment. */
x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
else
{
else
{
/* Is window under mouse one of our frames? */
- f1 = x_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp), WindowFromPoint(pt));
+ f1 = x_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp),
+ WindowFromPoint (pt));
}
/* If not, is it one of our scroll bars? */
if (! f1)
{
- struct scroll_bar *bar = x_window_to_scroll_bar (WindowFromPoint(pt));
+ struct scroll_bar *bar
+ = x_window_to_scroll_bar (WindowFromPoint (pt));
if (bar)
{
\f
/* Scroll bar support. */
-/* Given an window ID, find the struct scroll_bar which manages it.
+/* Given a window ID, find the struct scroll_bar which manages it.
This can be called in GC, so we have to make sure to strip off mark
bits. */
-struct scroll_bar *
+
+static struct scroll_bar *
x_window_to_scroll_bar (window_id)
Window window_id;
{
#endif
}
-BOOL
+void
my_set_focus (f, hwnd)
struct frame * f;
HWND hwnd;
(WPARAM) hwnd, 0);
}
-BOOL
+void
my_set_foreground_window (hwnd)
HWND hwnd;
{
{
struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar;
- int top, left, sb_left, width, sb_width, height;
+ int top, height, left, sb_left, width, sb_width;
int window_x, window_y, window_width, window_height;
/* Get window dimensions. */
/* Arrange for all scroll bars on FRAME to be removed at the next call
to `*judge_scroll_bars_hook'. A scroll bar may be spared if
- `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
+ `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
+
static void
w32_condemn_scroll_bars (frame)
FRAME_PTR frame;
}
}
-/* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
+
+/* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
Note that WINDOW isn't necessarily condemned at all. */
+
static void
w32_redeem_scroll_bar (window)
struct window *window;
{
struct scroll_bar *bar;
+ struct frame *f;
/* We can't redeem this window's scroll bar if it doesn't have one. */
if (NILP (window->vertical_scroll_bar))
bar = XSCROLL_BAR (window->vertical_scroll_bar);
/* Unlink it from the condemned list. */
- {
- FRAME_PTR f = XFRAME (WINDOW_FRAME (window));
-
- if (NILP (bar->prev))
- {
- /* If the prev pointer is nil, it must be the first in one of
- the lists. */
- if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
- /* It's not condemned. Everything's fine. */
- return;
- else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
- window->vertical_scroll_bar))
- FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
- else
- /* If its prev pointer is nil, it must be at the front of
- one or the other! */
- abort ();
- }
- else
- XSCROLL_BAR (bar->prev)->next = bar->next;
+ f = XFRAME (WINDOW_FRAME (window));
+ if (NILP (bar->prev))
+ {
+ /* If the prev pointer is nil, it must be the first in one of
+ the lists. */
+ if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
+ /* It's not condemned. Everything's fine. */
+ return;
+ else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
+ window->vertical_scroll_bar))
+ FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
+ else
+ /* If its prev pointer is nil, it must be at the front of
+ one or the other! */
+ abort ();
+ }
+ else
+ XSCROLL_BAR (bar->prev)->next = bar->next;
- if (! NILP (bar->next))
- XSCROLL_BAR (bar->next)->prev = bar->prev;
+ 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);
- }
+ 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);
}
/* Remove all scroll bars on FRAME that haven't been saved since the
last call to `*condemn_scroll_bars_hook'. */
+
static void
w32_judge_scroll_bars (f)
FRAME_PTR f;
mark bits. */
static int
-x_scroll_bar_handle_click (bar, msg, emacs_event)
+w32_scroll_bar_handle_click (bar, msg, emacs_event)
struct scroll_bar *bar;
W32Msg *msg;
struct input_event *emacs_event;
/* not really meaningful to distinguish up/down */
emacs_event->modifiers = msg->dwModifiers;
emacs_event->frame_or_window = bar->window;
+ emacs_event->arg = Qnil;
emacs_event->timestamp = msg->msg.time;
{
bar->dragging = Qnil;
+
+ last_mouse_scroll_bar_pos = msg->msg.wParam;
+
switch (LOWORD (msg->msg.wParam))
{
case SB_LINEDOWN:
/* Return information to the user about the current position of the mouse
on the scroll bar. */
+
static void
x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
FRAME_PTR *fp;
break;
}
- XSETINT(*x, pos);
- XSETINT(*y, top_range);
+ XSETINT (*x, pos);
+ XSETINT (*y, top_range);
f->mouse_moved = 0;
last_mouse_scroll_bar = Qnil;
UNBLOCK_INPUT;
}
+
/* The screen has been cleared so we may have changed foreground or
background colors, and the scroll bars may need to be redrawn.
Clear out the scroll bars, and ask for expose events, so we can
redraw them. */
+
void
x_scroll_bar_clear (f)
- struct frame *f;
+ FRAME_PTR f;
{
Lisp_Object bar;
- 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;
-
- /* Hide scroll bar until ready to repaint. x_scroll_bar_move
- arranges to refresh the scroll bar if hidden. */
- my_show_window (f, window, SW_HIDE);
-
- GetClientRect (window, &rect);
- select_palette (f, hdc);
- w32_clear_rect (f, hdc, &rect);
- deselect_palette (f, hdc);
+ /* We can have scroll bars even if this is 0,
+ if we just turned off scroll bar mode.
+ But in that case we should not clear them. */
+ 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;
- ReleaseDC (window, hdc);
- }
-}
+ /* Hide scroll bar until ready to repaint. x_scroll_bar_move
+ arranges to refresh the scroll bar if hidden. */
+ my_show_window (f, window, SW_HIDE);
-show_scroll_bars (f, how)
- FRAME_PTR f;
- int how;
-{
- Lisp_Object bar;
+ GetClientRect (window, &rect);
+ select_palette (f, hdc);
+ w32_clear_rect (f, hdc, &rect);
+ deselect_palette (f, hdc);
- for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
- bar = XSCROLL_BAR (bar)->next)
- {
- HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
- my_show_window (f, window, how);
- }
+ ReleaseDC (window, hdc);
+ }
}
\f
/* The main W32 event-reading loop - w32_read_socket. */
-/* Timestamp of enter window event. This is only used by w32_read_socket,
+/* Time stamp of enter window event. This is only used by w32_read_socket,
but we have to put it out here, since static variables within functions
sometimes don't work. */
+
static Time enter_timestamp;
/* Record the last 100 characters stored
to help debug the loss-of-chars-during-GC problem. */
-int temp_index;
-short temp_buffer[100];
+
+static int temp_index;
+static short temp_buffer[100];
/* Read events coming from the W32 shell.
int
w32_read_socket (sd, bufp, numchars, expected)
register int sd;
- register struct input_event *bufp;
- register int numchars;
+ /* register */ struct input_event *bufp;
+ /* register */ int numchars;
int expected;
{
int count = 0;
if (numchars <= 0)
abort (); /* Don't think this happens. */
- /* NTEMACS_TODO: tooltips, tool-bars, ghostscript integration, mouse
+ /* TODO: tooltips, tool-bars, ghostscript integration, mouse
cursors. */
while (get_next_msg (&msg, FALSE))
{
{
bufp->kind = deiconify_event;
XSETFRAME (bufp->frame_or_window, f);
+ bufp->arg = Qnil;
bufp++;
count++;
numchars--;
}
- else if (! NILP(Vframe_list)
+ else if (! NILP (Vframe_list)
&& ! NILP (XCDR (Vframe_list)))
/* Force a redisplay sooner or later to update the
frame titles in case this is the second frame. */
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++;
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--;
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--;
case WM_MOUSEMOVE:
previous_help_echo = help_echo;
- help_echo = Qnil;
+ 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))
/* If the contents of the global variable help_echo
has changed, generate a HELP_EVENT. */
- if (STRINGP (help_echo)
- || STRINGP (previous_help_echo))
+ if (!NILP (help_echo)
+ || !NILP (previous_help_echo))
{
Lisp_Object frame;
+ int n;
if (f)
XSETFRAME (frame, f);
frame = Qnil;
any_help_event_p = 1;
- bufp->kind = HELP_EVENT;
- bufp->frame_or_window = Fcons (frame, help_echo);
- ++bufp, ++count, --numchars;
+ 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;
&& XFASTINT (XWINDOW (f->tool_bar_window)->height))
{
Lisp_Object window;
- int p, x, y;
+ int p;
/* Set x and y. */
window = window_from_coordinates (f,
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;
if (bar && numchars >= 1)
{
- if (x_scroll_bar_handle_click (bar, &msg, bufp))
+ if (w32_scroll_bar_handle_click (bar, &msg, bufp))
{
bufp++;
count++;
bufp->kind = iconify_event;
XSETFRAME (bufp->frame_or_window, f);
+ bufp->arg = Qnil;
bufp++;
count++;
numchars--;
bufp->kind = deiconify_event;
XSETFRAME (bufp->frame_or_window, f);
+ bufp->arg = Qnil;
bufp++;
count++;
numchars--;
}
- else
+ else if (! NILP (Vframe_list)
+ && ! NILP (XCDR (Vframe_list)))
/* Force a redisplay sooner or later
to update the frame titles
in case this is the second frame. */
int width;
int height;
- GetClientRect(msg.msg.hwnd, &rect);
+ GetClientRect (msg.msg.hwnd, &rect);
height = rect.bottom - rect.top;
width = rect.right - rect.left;
break;
case WM_KILLFOCUS:
- /* NTEMACS_TODO: some of this belongs in MOUSE_LEAVE */
+ /* TODO: some of this belongs in MOUSE_LEAVE */
f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
if (f)
{
- Lisp_Object frame;
-
if (f == dpyinfo->w32_focus_event_frame)
dpyinfo->w32_focus_event_frame = 0;
clear_mouse_face (dpyinfo);
dpyinfo->mouse_face_mouse_frame = 0;
}
+
/* Generate a nil HELP_EVENT to cancel a help-echo.
Do it only if there's something to cancel.
Otherwise, the startup message is cleared when
the mouse leaves the frame. */
if (any_help_event_p)
{
+ Lisp_Object frame;
+ int n;
+
XSETFRAME (frame, f);
- bufp->kind = HELP_EVENT;
- bufp->frame_or_window = Fcons (frame, Qnil);
- ++bufp, ++count, --numchars;
+ help_echo = Qnil;
+ n = gen_help_event (bufp, numchars,
+ Qnil, frame, Qnil, Qnil, 0);
+ bufp += n, count += n, numchars -=n;
}
}
bufp->kind = delete_window_event;
XSETFRAME (bufp->frame_or_window, f);
+ bufp->arg = Qnil;
bufp++;
count++;
numchars--;
bufp->kind = menu_bar_activate_event;
XSETFRAME (bufp->frame_or_window, f);
+ bufp->arg = Qnil;
bufp++;
count++;
numchars--;
return count;
}
+
+
\f
/***********************************************************************
Text Cursor
clip_rect.bottom = clip_rect.top + row->visible_height;
/* If clipping to the whole line, including trunc marks, extend
- the rectangle to the left and right. */
+ the rectangle to the left and increase its width. */
if (whole_line_p)
{
clip_rect.left -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
struct glyph_row *row;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
- HDC hdc = get_frame_dc (f);
+ HDC hdc;
RECT rect;
int wd;
struct glyph *cursor_glyph;
wd = min (CANON_X_UNIT (f), wd);
rect.right = rect.left + wd;
-
+ hdc = get_frame_dc (f);
FrameRect (hdc, &rect, hb);
DeleteObject (hb);
--gerd. */
static void
-x_draw_bar_cursor (w, row)
+x_draw_bar_cursor (w, row, width)
struct window *w;
struct glyph_row *row;
+ int width;
{
- /* If cursor hpos is out of bounds, don't draw garbage. This can
- happen in mini-buffer windows when switching between echo area
- glyphs and mini-buffer. */
- if (w->phys_cursor.hpos < row->used[TEXT_AREA])
- {
- struct frame *f = XFRAME (w->frame);
- struct glyph *cursor_glyph;
- int x;
- HDC hdc;
+ 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 is out of bounds, don't draw garbage. This can happen
+ in mini-buffer windows when switching between echo area glyphs
+ and mini-buffer. */
+ cursor_glyph = get_phys_cursor_glyph (w);
+ if (cursor_glyph == NULL)
+ return;
- x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
+ /* If on an image, draw like a normal cursor. That's usually better
+ visible than drawing a bar, esp. if the image is large so that
+ the bar might not be in the window. */
+ 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
+ {
+ if (width < 0)
+ width = f->output_data.w32->cursor_width;
+ 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, f->output_data.w32->cursor_pixel,
x,
WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
- min (cursor_glyph->pixel_width,
- f->output_data.w32->cursor_width),
+ min (cursor_glyph->pixel_width, width),
row->height);
release_frame_dc (f, hdc);
}
/* If the cursor is in the mouse face area, redisplay that when
we clear the cursor. */
- if (w == XWINDOW (dpyinfo->mouse_face_window)
+ 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))
{
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;
the cursor type given by the frame parameter. If explicitly
marked off, draw no cursor. In all other cases, we want a hollow
box cursor. */
+ new_cursor_width = -1;
if (cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f)
&& EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
{
extern int cursor_in_non_selected_windows;
- if (MINI_WINDOW_P (w) || !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
- new_cursor_type = FRAME_DESIRED_CURSOR (f);
+ {
+ 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 cursor is currently being shown and we don't want it to be or
break;
case BAR_CURSOR:
- x_draw_bar_cursor (w, glyph_row);
+ x_draw_bar_cursor (w, glyph_row, new_cursor_width);
break;
case NO_CURSOR:
struct window *w;
int on;
{
- 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;
+ /* Don't update cursor in windows whose frame is in the process
+ of being deleted. */
+ 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;
+ }
}
+
\f
/* Icons. */
struct frame *f;
Lisp_Object icon;
{
- int mask, bitmap_id;
- Window icon_window;
HANDLE hicon;
if (FRAME_W32_WINDOW (f) == 0)
return 0;
}
+\f
+/************************************************************************
+ Handling X errors
+ ************************************************************************/
+
+/* Display Error Handling functions not used on W32. Listing them here
+ helps diff stay in step when comparing w32term.c with xterm.c.
+
+x_error_catcher (display, error)
+x_catch_errors (dpy)
+x_catch_errors_unwind (old_val)
+x_check_errors (dpy, format)
+x_had_errors_p (dpy)
+x_clear_errors (dpy)
+x_uncatch_errors (dpy, count)
+x_trace_wire ()
+x_connection_signal (signalnum)
+x_connection_closed (dpy, error_message)
+x_error_quitter (display, error)
+x_error_handler (display, error)
+x_io_error_quitter (display)
+
+ */
+
\f
/* Changing the font of the frame. */
/* Compute the scroll bar width in character columns. */
if (f->scroll_bar_pixel_width > 0)
{
- int wid = FONT_WIDTH (f->output_data.w32->font);
+ int wid = FONT_WIDTH (FRAME_FONT (f));
f->scroll_bar_cols = (f->scroll_bar_pixel_width + wid-1) / wid;
}
else
- f->scroll_bar_cols = 2;
+ {
+ int wid = FONT_WIDTH (FRAME_FONT (f));
+ f->scroll_bar_cols = (14 + wid - 1) / wid;
+ }
/* Now make the frame display the given font. */
if (FRAME_W32_WINDOW (f) != 0)
else
/* If we are setting a new frame's font for the first time,
there are no faces yet, so this font's height is the line height. */
- f->output_data.w32->line_height = FONT_HEIGHT (f->output_data.w32->font);
+ f->output_data.w32->line_height = FONT_HEIGHT (FRAME_FONT (f));
return build_string (fontp->full_name);
}
{
int fontset = fs_query_fontset (build_string (fontsetname), 0);
Lisp_Object result;
- char *fontname;
if (fontset < 0)
return Qnil;
return build_string (fontsetname);
}
+\f
+/***********************************************************************
+ TODO: W32 Input Methods
+ ***********************************************************************/
+/* Listing missing functions from xterm.c helps diff stay in step.
-#if GLYPH_DEBUG
-
-/* Check that FONT is valid on frame F. It is if it can be found in F's
- font table. */
-
-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 /* GLYPH_DEBUG != 0 */
-
-/* Set *W to the minimum width, *H to the minimum font height of FONT.
- Note: There are (broken) X fonts out there with invalid XFontStruct
- min_bounds contents. For example, handa@etl.go.jp reports that
- "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
- have font->min_bounds.width == 0. */
-
-static INLINE void
-x_font_min_bounds (font, w, h)
- XFontStruct *font;
- int *w, *h;
-{
- *h = FONT_HEIGHT (font);
- *w = FONT_WIDTH (font);
-#if 0 /* NTEMACS_TODO: min/max bounds of Windows fonts */
- *w = font->min_bounds.width;
-
- /* Try to handle the case where FONT->min_bounds has invalid
- contents. Since the only font known to have invalid min_bounds
- is fixed-width, use max_bounds if min_bounds seems to be invalid. */
- if (*w <= 0)
- *w = font->max_bounds.width;
-#endif
-}
-
-
-/* Compute the smallest character width and smallest font height over
- all fonts available on frame F. Set the members smallest_char_width
- and smallest_font_height in F's x_display_info structure to
- the values computed. Value is non-zero if smallest_font_height or
- smallest_char_width become smaller than they were before. */
-
-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);
+xim_destroy_callback (xim, client_data, call_data)
+xim_open_dpy (dpyinfo, resource_name)
+struct xim_inst_t
+xim_instantiate_callback (display, client_data, call_data)
+xim_initialize (dpyinfo, resource_name)
+xim_close_dpy (dpyinfo)
- return (dpyinfo->n_fonts == 1
- || dpyinfo->smallest_char_width < old_width
- || dpyinfo->smallest_font_height < old_height);
-}
+ */
\f
/* Calculate the absolute position in frame F
from its current recorded position values and gravity. */
+void
x_calc_absolute_position (f)
struct frame *f;
{
- Window child;
POINT pt;
int flags = f->output_data.w32->size_hint_flags;
pt.x = pt.y = 0;
/* Find the position of the outside upper-left corner of
- the inner window, with respect to the outer window. */
+ the inner window, with respect to the outer window.
+ But do this only if we will need the results. */
if (f->output_data.w32->parent_desc != FRAME_W32_DISPLAY_INFO (f)->root_window)
{
BLOCK_INPUT;
- 2 * f->output_data.w32->border_width - pt.x
- PIXEL_WIDTH (f)
+ f->output_data.w32->left_pos);
- /* NTEMACS_TODO: Subtract menubar height? */
+
if (flags & YNegative)
f->output_data.w32->top_pos = (FRAME_W32_DISPLAY_INFO (f)->height
- 2 * f->output_data.w32->border_width - pt.y
position values). It is -1 when calling from x_set_frame_parameters,
which means, do adjust for borders but don't change the gravity. */
+void
x_set_offset (f, xoff, yoff, change_gravity)
struct frame *f;
register int xoff, yoff;
BLOCK_INPUT;
x_wm_set_size_hint (f, (long) 0, 0);
- /* It is a mystery why we need to add the border_width here
- when the frame is already visible, but experiment says we do. */
modified_left = f->output_data.w32->left_pos;
modified_top = f->output_data.w32->top_pos;
-#ifndef HAVE_NTGUI
- /* Do not add in border widths under W32. */
- if (change_gravity != 0)
- {
- modified_left += f->output_data.w32->border_width;
- modified_top += f->output_data.w32->border_width;
- }
-#endif
my_set_window_pos (FRAME_W32_WINDOW (f),
NULL,
If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
for this size change and subsequent size changes.
Otherwise we leave the window gravity unchanged. */
+
void
x_set_window_size (f, change_gravity, cols, rows)
struct frame *f;
We could just not bother storing any of this information here,
and let the ConfigureNotify event set everything up, but that
- might be kind of confusing to the lisp code, since size changes
+ might be kind of confusing to the Lisp code, since size changes
wouldn't be reported in the frame parameters until some random
point in the future when the ConfigureNotify event arrives.
\f
/* Mouse warping. */
+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;
UNBLOCK_INPUT;
}
-void
-x_set_mouse_position (f, x, y)
- struct frame *f;
- int x, y;
-{
- int pix_x, pix_y;
-
- pix_x = CHAR_TO_PIXEL_COL (f, x) + FONT_WIDTH (f->output_data.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);
-}
\f
/* focus shifting, raising and lowering. */
+void
x_focus_on_frame (f)
struct frame *f;
{
UNBLOCK_INPUT;
}
+void
x_unfocus_frame (f)
struct frame *f;
{
}
static void
-w32_frame_raise_lower (f, raise)
+w32_frame_raise_lower (f, raise_flag)
FRAME_PTR f;
- int raise;
+ int raise_flag;
{
- if (raise)
+ if (! FRAME_W32_P (f))
+ return;
+
+ if (raise_flag)
x_raise_frame (f);
else
x_lower_frame (f);
but it will become visible later when the window manager
finishes with it. */
+void
x_make_frame_visible (f)
struct frame *f;
{
input_signal_count < count && !FRAME_VISIBLE_P (f);)
{
/* Force processing of queued events. */
- /* NTEMACS_TODO: x_sync equivalent? */
+ /* TODO: x_sync equivalent? */
/* Machines that do polling rather than SIGIO have been observed
to go into a busy-wait here. So we'll fake an alarm signal
x_iconify_frame (f)
struct frame *f;
{
- int result;
Lisp_Object type;
/* Don't keep the highlight on an invisible frame. */
UNBLOCK_INPUT;
}
+
\f
-/* Destroy the window of frame F. */
+/* Free X resources of frame F. */
-x_destroy_window (f)
+void
+x_free_frame_resources (f)
struct frame *f;
{
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
BLOCK_INPUT;
- my_destroy_window (f, FRAME_W32_WINDOW (f));
+ if (FRAME_W32_WINDOW (f))
+ my_destroy_window (f, FRAME_W32_WINDOW (f));
+
free_frame_menubar (f);
- free_frame_faces (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 = 0;
+ f->output_data.w32 = NULL;
+
if (f == dpyinfo->w32_focus_frame)
dpyinfo->w32_focus_frame = 0;
if (f == dpyinfo->w32_focus_event_frame)
if (f == dpyinfo->w32_highlight_frame)
dpyinfo->w32_highlight_frame = 0;
- dpyinfo->reference_count--;
-
if (f == dpyinfo->mouse_face_mouse_frame)
{
dpyinfo->mouse_face_beg_row
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;
}
+
+
+/* Destroy the window of frame F. */
+
+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--;
+}
+
\f
/* Setting window manager hints. */
#endif
}
+\f
+/***********************************************************************
+ Fonts
+ ***********************************************************************/
+
+/* The following functions are listed here to help diff stay in step
+ with xterm.c. See w32fns.c for definitions.
+
+x_get_font_info (f, font_idx)
+x_list_fonts (f, pattern, size, maxnames)
+
+ */
+
+#if GLYPH_DEBUG
+
+/* Check that FONT is valid on frame F. It is if it can be found in F's
+ font table. */
+
+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 /* GLYPH_DEBUG != 0 */
+
+/* Set *W to the minimum width, *H to the minimum font height of FONT.
+ Note: There are (broken) X fonts out there with invalid XFontStruct
+ min_bounds contents. For example, handa@etl.go.jp reports that
+ "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
+ have font->min_bounds.width == 0. */
+
+static INLINE void
+x_font_min_bounds (font, w, h)
+ XFontStruct *font;
+ int *w, *h;
+{
+ /*
+ * TODO: Windows does not appear to offer min bound, only
+ * average and maximum width, and maximum height.
+ */
+ *h = FONT_HEIGHT (font);
+ *w = FONT_WIDTH (font);
+}
+
+
+/* Compute the smallest character width and smallest font height over
+ all fonts available on frame F. Set the members smallest_char_width
+ and smallest_font_height in F's x_display_info structure to
+ the values computed. Value is non-zero if smallest_font_height or
+ smallest_char_width become smaller than they were before. */
+
+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);
+}
+
+/* The following functions are listed here to help diff stay in step
+ with xterm.c. See w32fns.c for definitions.
+
+x_load_font (f, fontname, size)
+x_query_font (f, fontname)
+x_find_ccl_program (fontp)
+
+*/
\f
/***********************************************************************
Initialization
dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
dpyinfo->mouse_face_window = Qnil;
- /* NTEMACS_TODO: dpyinfo->gray */
+ /* TODO: dpyinfo->gray */
}
{
struct w32_palette_entry * pentry = plist;
plist = plist->next;
- xfree(pentry);
+ xfree (pentry);
}
dpyinfo->color_list = NULL;
if (dpyinfo->palette)
x_update_window_end,
w32_cursor_to,
x_flush,
+ x_clear_mouse_face,
x_get_glyph_overhangs,
x_fix_overlapping_area
};
/* MSVC does not type K&R functions with no arguments correctly, and
so we must explicitly cast them. */
clear_frame_hook = (void (*)(void)) x_clear_frame;
- ins_del_lines_hook = x_ins_del_lines;
- change_line_highlight_hook = x_change_line_highlight;
- delete_glyphs_hook = x_delete_glyphs;
ring_bell_hook = (void (*)(void)) w32_ring_bell;
- reset_terminal_modes_hook = (void (*)(void)) w32_reset_terminal_modes;
- set_terminal_modes_hook = (void (*)(void)) w32_set_terminal_modes;
update_begin_hook = x_update_begin;
update_end_hook = x_update_end;
- set_terminal_window_hook = w32_set_terminal_window;
+
read_socket_hook = w32_read_socket;
+
frame_up_to_date_hook = w32_frame_up_to_date;
- reassert_line_highlight_hook = w32_reassert_line_highlight;
+
mouse_position_hook = w32_mouse_position;
frame_rehighlight_hook = w32_frame_rehighlight;
frame_raise_lower_hook = w32_frame_raise_lower;
#define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
/* New proportional scroll bar functions. */
- LOAD_PROC( SetScrollInfo );
- LOAD_PROC( GetScrollInfo );
+ LOAD_PROC (SetScrollInfo);
+ LOAD_PROC (GetScrollInfo);
#undef LOAD_PROC
void
syms_of_w32term ()
{
- Lisp_Object codepage;
-
staticpro (&w32_display_name_list);
w32_display_name_list = Qnil;
affect on NT machines.");
w32_enable_unicode_output = 1;
-/* VIETNAMESE_CHARSET is not defined in some versions of MSVC. */
-#ifndef VIETNAMESE_CHARSET
-#define VIETNAMESE_CHARSET 163
-#endif
-
- DEFVAR_LISP ("w32-charset-info-alist",
- &Vw32_charset_info_alist,
- "Alist linking Emacs character sets to Windows fonts\n\
-and codepages. Each entry should be of the form:\n\
-\n\
- (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE))\n\
-\n\
-where CHARSET_NAME is a string used in font names to identify the charset,\n\
-WINDOWS_CHARSET is a symbol that can be one of:\n\
-w32-charset-ansi, w32-charset-default, w32-charset-symbol,\n\
-w32-charset-shiftjis, w32-charset-hangul, w32-charset-gb2312,\n\
-w32-charset-chinesebig5, "
-#ifdef JOHAB_CHARSET
-"w32-charset-johab, w32-charset-hebrew,\n\
-w32-charset-arabic, w32-charset-greek, w32-charset-turkish,\n\
-w32-charset-vietnamese, w32-charset-thai, w32-charset-easteurope,\n\
-w32-charset-russian, w32-charset-mac, w32-charset-baltic,\n"
-#endif
-#ifdef UNICODE_CHARSET
-"w32-charset-unicode, "
-#endif
-"or w32-charset-oem.\n\
-CODEPAGE should be an integer specifying the codepage that should be used\n\
-to display the character set, t to do no translation and output as Unicode,\n\
-or nil to do no translation and output as 8 bit (or multibyte on far-east\n\
-versions of Windows) characters.");
- Vw32_charset_info_alist = Qnil;
-
- staticpro (&Qw32_charset_ansi);
- Qw32_charset_ansi = intern ("w32-charset-ansi");
- staticpro (&Qw32_charset_symbol);
- Qw32_charset_symbol = intern ("w32-charset-symbol");
- staticpro (&Qw32_charset_shiftjis);
- Qw32_charset_shiftjis = intern ("w32-charset-shiftjis");
- staticpro (&Qw32_charset_hangul);
- Qw32_charset_hangul = intern ("w32-charset-hangul");
- staticpro (&Qw32_charset_chinesebig5);
- Qw32_charset_chinesebig5 = intern ("w32-charset-chinesebig5");
- staticpro (&Qw32_charset_gb2312);
- Qw32_charset_gb2312 = intern ("w32-charset-gb2312");
- staticpro (&Qw32_charset_oem);
- Qw32_charset_oem = intern ("w32-charset-oem");
-
-#ifdef JOHAB_CHARSET
- {
- static int w32_extra_charsets_defined = 1;
- DEFVAR_BOOL ("w32-extra-charsets-defined", w32_extra_charsets_defined, "");
-
- staticpro (&Qw32_charset_johab);
- Qw32_charset_johab = intern ("w32-charset-johab");
- staticpro (&Qw32_charset_easteurope);
- Qw32_charset_easteurope = intern ("w32-charset-easteurope");
- staticpro (&Qw32_charset_turkish);
- Qw32_charset_turkish = intern ("w32-charset-turkish");
- staticpro (&Qw32_charset_baltic);
- Qw32_charset_baltic = intern ("w32-charset-baltic");
- staticpro (&Qw32_charset_russian);
- Qw32_charset_russian = intern ("w32-charset-russian");
- staticpro (&Qw32_charset_arabic);
- Qw32_charset_arabic = intern ("w32-charset-arabic");
- staticpro (&Qw32_charset_greek);
- Qw32_charset_greek = intern ("w32-charset-greek");
- staticpro (&Qw32_charset_hebrew);
- Qw32_charset_hebrew = intern ("w32-charset-hebrew");
- staticpro (&Qw32_charset_thai);
- Qw32_charset_thai = intern ("w32-charset-thai");
- staticpro (&Qw32_charset_mac);
- Qw32_charset_mac = intern ("w32-charset-mac");
- }
-#endif
-
-#ifdef UNICODE_CHARSET
- {
- static int w32_unicode_charset_defined = 1;
- DEFVAR_BOOL ("w32-unicode-charset-defined",
- w32_unicode_charset_defined, "");
-
- staticpro (&Qw32_charset_unicode);
- Qw32_charset_unicode = intern ("w32-charset-unicode");
-#endif
-
- staticpro (&help_echo);
help_echo = Qnil;
- staticpro (&previous_help_echo);
+ 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\
wide as that tab on the display.");
x_stretch_cursor_p = 0;
- DEFVAR_BOOL ("x-toolkit-scroll-bars-p", &x_toolkit_scroll_bars_p,
+ DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
"If not nil, Emacs uses toolkit scroll bars.");
- x_toolkit_scroll_bars_p = 1;
+ Vx_toolkit_scroll_bars = Qt;
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;