/* Implementation of GUI terminal on the Microsoft W32 API.
- Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ 2006, 2007 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
(Not yet supported, see TODO in x_draw_glyph_string.) */
int x_use_underline_position_properties;
+/* Non-zero means to draw the underline at the same place as the descent line. */
+
+int x_underline_at_descent_line;
+
extern unsigned int msh_mousewheel;
extern void free_frame_menubar ();
DWORD dwMainThreadId = 0;
HANDLE hMainThread = NULL;
-#ifndef SIF_ALL
-/* These definitions are new with Windows 95. */
-#define SIF_RANGE 0x0001
-#define SIF_PAGE 0x0002
-#define SIF_POS 0x0004
-#define SIF_DISABLENOSCROLL 0x0008
-#define SIF_TRACKPOS 0x0010
-#define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
-
-typedef struct tagSCROLLINFO
-{
- UINT cbSize;
- UINT fMask;
- int nMin;
- int nMax;
- UINT nPage;
- int nPos;
- int nTrackPos;
-} SCROLLINFO, FAR *LPSCROLLINFO;
-typedef SCROLLINFO CONST FAR *LPCSCROLLINFO;
-#endif /* SIF_ALL */
-
-/* Dynamic linking to new proportional scroll bar functions. */
-int (PASCAL *pfnSetScrollInfo) (HWND hwnd, int fnBar, LPSCROLLINFO lpsi, BOOL fRedraw);
-BOOL (PASCAL *pfnGetScrollInfo) (HWND hwnd, int fnBar, LPSCROLLINFO lpsi);
-
int vertical_scroll_bar_min_handle;
int vertical_scroll_bar_top_border;
int vertical_scroll_bar_bottom_border;
/* Where the mouse was last time we reported a mouse event. */
static RECT last_mouse_glyph;
+static FRAME_PTR last_mouse_glyph_frame;
static Lisp_Object last_mouse_press_frame;
int w32_num_mouse_buttons;
extern EMACS_INT extra_keyboard_modifiers;
static void x_update_window_end P_ ((struct window *, int, int));
-void w32_delete_display P_ ((struct w32_display_info *));
static void w32_handle_tool_bar_click P_ ((struct frame *,
struct input_event *));
-void w32_define_cursor P_ ((Window, Cursor));
+static void w32_define_cursor P_ ((Window, Cursor));
void x_lower_frame P_ ((struct frame *));
void x_scroll_bar_clear P_ ((struct frame *));
void x_set_window_size P_ ((struct frame *, int, int, int));
void x_wm_set_window_state P_ ((struct frame *, int));
void x_wm_set_icon_pixmap P_ ((struct frame *, int));
-void w32_initialize P_ ((void));
+static void w32_initialize P_ ((void));
static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
int x_compute_min_glyph_bounds P_ ((struct frame *));
static void x_update_end P_ ((struct frame *));
hdc = get_frame_dc (f);
+ if (!p->overlay_p)
+ {
+ int bx = p->bx, by = p->by, nx = p->nx, ny = p->ny;
+
+ /* If the fringe is adjacent to the left (right) scroll bar of a
+ leftmost (rightmost, respectively) window, then extend its
+ background to the gap between the fringe and the bar. */
+ if ((WINDOW_LEFTMOST_P (w)
+ && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
+ || (WINDOW_RIGHTMOST_P (w)
+ && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
+ {
+ int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
+
+ if (sb_width > 0)
+ {
+ int left = WINDOW_SCROLL_BAR_AREA_X (w);
+ int width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
+ * FRAME_COLUMN_WIDTH (f));
+
+ if (bx < 0)
+ {
+ /* Bitmap fills the fringe. */
+ if (left + width == p->x)
+ bx = left + sb_width;
+ else if (p->x + p->wd == left)
+ bx = left;
+ if (bx >= 0)
+ {
+ int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
+
+ nx = width - sb_width;
+ by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
+ row->y));
+ ny = row->visible_height;
+ }
+ }
+ else
+ {
+ if (left + width == bx)
+ {
+ bx = left + sb_width;
+ nx += width - sb_width;
+ }
+ else if (bx + nx == left)
+ nx += width - sb_width;
+ }
+ }
+ }
+
+ if (bx >= 0 && nx > 0)
+ w32_fill_area (f, hdc, face->background, bx, by, nx, ny);
+ }
+
/* Must clip because of partially visible lines. */
rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
if (p->y < rowY)
else
w32_clip_to_row (w, row, -1, hdc);
- if (p->bx >= 0 && !p->overlay_p)
- {
- w32_fill_area (f, hdc, face->background,
- p->bx, p->by, p->nx, p->ny);
- }
-
if (p->which && p->which < max_fringe_bmp)
{
HBITMAP pixmap = fringe_bmp[p->which];
{
/* For overstriking (to simulate bold-face), draw the
characters again shifted to the right by one pixel. */
+ int old_BkMode = SetBkMode (s->hdc, TRANSPARENT);
w32_text_out (s, x + 1, s->ybase - boff, s->char2b, s->nchars);
+ if (old_BkMode && old_BkMode != TRANSPARENT)
+ SetBkMode (s->hdc, old_BkMode);
}
}
if (s->font && s->font->hfont)
{
/* If `x-stretch-block-cursor' is nil, don't draw a block cursor
as wide as the stretch glyph. */
- int width = min (FRAME_COLUMN_WIDTH (s->f), s->background_width);
+ int width, background_width = s->background_width;
+ int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
+
+ if (x < left_x)
+ {
+ background_width -= left_x - x;
+ x = left_x;
+ }
+ width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
/* Draw cursor. */
- x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
+ x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
/* Clear rest using the GC of the original non-cursor face. */
- if (width < s->background_width)
+ if (width < background_width)
{
XGCValues *gc = s->face->gc;
- int x = s->x + width, y = s->y;
- int w = s->background_width - width, h = s->height;
+ int y = s->y;
+ int w = background_width - width, h = s->height;
RECT r;
HDC hdc = s->hdc;
+ x += width;
if (s->row->mouse_face_p
&& cursor_in_mouse_face_p (s->w))
{
}
}
else if (!s->background_filled_p)
- x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
- s->height);
+ {
+ int background_width = s->background_width;
+ int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
+
+ /* Don't draw into left margin, fringe or scrollbar area
+ except for header line and mode line. */
+ if (x < left_x && !s->row->mode_line_p)
+ {
+ background_width -= left_x - x;
+ x = left_x;
+ }
+ if (background_width > 0)
+ x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
+ }
s->background_filled_p = 1;
}
&& (s->font->bdf || !s->font->tm.tmUnderlined))
{
unsigned long h = 1;
- unsigned long dy = s->height - h;
+ unsigned long dy = 0;
- /* TODO: Use font information for positioning and thickness
- of underline. See OUTLINETEXTMETRIC, and xterm.c.
- Note: If you make this work, don't forget to change the
- doc string of x-use-underline-position-properties below. */
+ if (x_underline_at_descent_line)
+ dy = s->height - h;
+ else
+ {
+ /* TODO: Use font information for positioning and thickness of
+ underline. See OUTLINETEXTMETRIC, and xterm.c. Note: If
+ you make this work, don't forget to change the doc string of
+ x-use-underline-position-properties below. */
+ dy = s->height - h;
+ }
if (s->face->underline_defaulted_p)
{
w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
- s->y + dy, s->width, 1);
+ s->y + dy, s->background_width, 1);
}
else
{
w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
- s->y + dy, s->width, 1);
+ s->y + dy, s->background_width, 1);
}
}
if (s->face->overline_color_defaulted_p)
{
w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
- s->y + dy, s->width, h);
+ s->y + dy, s->background_width, h);
}
else
{
w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x,
- s->y + dy, s->width, h);
+ s->y + dy, s->background_width, h);
}
}
result->modifiers = (msg->dwModifiers
| ((delta < 0 ) ? down_modifier : up_modifier));
- p.x = LOWORD (msg->msg.lParam);
- p.y = HIWORD (msg->msg.lParam);
+ /* With multiple monitors, we can legitimately get negative
+ coordinates, so cast to short to interpret them correctly. */
+ p.x = (short) LOWORD (msg->msg.lParam);
+ p.y = (short) HIWORD (msg->msg.lParam);
ScreenToClient (msg->msg.hwnd, &p);
XSETINT (result->x, p.x);
XSETINT (result->y, p.y);
frame->mouse_moved = 1;
last_mouse_scroll_bar = Qnil;
note_mouse_highlight (frame, -1, -1);
+ last_mouse_glyph_frame = 0;
return 1;
}
/* Has the mouse moved off the glyph it was on at the last sighting? */
- if (mouse_x < last_mouse_glyph.left
+ if (frame != last_mouse_glyph_frame
+ || mouse_x < last_mouse_glyph.left
|| mouse_x >= last_mouse_glyph.right
|| mouse_y < last_mouse_glyph.top
|| mouse_y >= last_mouse_glyph.bottom)
to keep track of the mouse for help_echo and highlighting at
other times. */
remember_mouse_glyph (frame, mouse_x, mouse_y, &last_mouse_glyph);
+ last_mouse_glyph_frame = frame;
return 1;
}
HIWORD (last_mouse_motion_event.lParam));
}
-void
+static void
w32_define_cursor (window, cursor)
Window window;
Cursor cursor;
on it, i.e. into the same rectangles that matrices on
the frame are divided into. */
-#if OLD_REDISPLAY_CODE
- int ignore1, ignore2;
-
- ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
-
- pixel_to_glyph_coords (f1, pt.x, pt.y, &ignore1, &ignore2,
- &last_mouse_glyph,
- FRAME_W32_DISPLAY_INFO (f1)->grabbed
- || insist);
-#else
ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
remember_mouse_glyph (f1, pt.x, pt.y, &last_mouse_glyph);
-#endif
+ last_mouse_glyph_frame = f1;
*bar_window = Qnil;
*part = 0;
int portion, position, whole;
{
Window w = SCROLL_BAR_W32_WINDOW (bar);
- double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
+ /* We use the whole scroll-bar height in the calculations below, to
+ avoid strange effects like scrolling backwards when just clicking
+ on the handle (without moving it). */
+ double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height))
+ + VERTICAL_SCROLL_BAR_MIN_HANDLE;
int sb_page, sb_pos;
BOOL draggingp = !NILP (bar->dragging) ? TRUE : FALSE;
+ SCROLLINFO si;
+
+ /* We used to change the nPage setting while dragging the handle,
+ but that had very strange effects (such as scrolling backwards
+ while dragging downwards).
+
+ Now, we don't change the nPage setting while dragging unless we
+ get near to the end of the buffer, in which case we often have to
+ resize the handle to "go all the way". */
+
+ if (draggingp)
+ {
+ int near_bottom_p;
+ BLOCK_INPUT;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_POS | SIF_PAGE;
+ GetScrollInfo(w, SB_CTL, &si);
+ near_bottom_p = si.nPos + si.nPage >= range;
+ UNBLOCK_INPUT;
+ if (!near_bottom_p)
+ return;
+ }
if (whole)
{
/* Position scroll bar at rock bottom if the bottom of the
buffer is visible. This avoids shinking the thumb away
to nothing if it is held at the bottom of the buffer. */
- if (position + portion >= whole)
- {
- sb_page = range * (whole - position) / whole
- + VERTICAL_SCROLL_BAR_MIN_HANDLE;
- sb_pos = range;
- }
-
- sb_page = portion * range / whole + VERTICAL_SCROLL_BAR_MIN_HANDLE;
- sb_pos = position * range / whole;
+ if (position + portion >= whole && !draggingp)
+ {
+ sb_page = range * (whole - position) / whole;
+ sb_pos = range;
+ }
+ else
+ {
+ sb_pos = position * range / whole;
+ sb_page = (min (portion, (whole - position)) * range) / whole;
+ }
}
else
{
sb_pos = 0;
}
- BLOCK_INPUT;
+ sb_page = max (sb_page, VERTICAL_SCROLL_BAR_MIN_HANDLE);
- if (pfnSetScrollInfo)
- {
- SCROLLINFO si;
+ BLOCK_INPUT;
- si.cbSize = sizeof (si);
- /* Only update page size if currently dragging, to reduce
- flicker effects. */
- if (draggingp)
- si.fMask = SIF_PAGE;
- else
- si.fMask = SIF_PAGE | SIF_POS;
- si.nPage = sb_page;
- si.nPos = sb_pos;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_PAGE | SIF_POS;
+ si.nPage = sb_page;
+ si.nPos = sb_pos;
- pfnSetScrollInfo (w, SB_CTL, &si, !draggingp);
- }
- else
- SetScrollPos (w, SB_CTL, sb_pos, !draggingp);
+ SetScrollInfo (w, SB_CTL, &si, TRUE);
UNBLOCK_INPUT;
}
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
HWND hwnd;
+ SCROLLINFO si;
struct scroll_bar *bar
= XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
XSETINT (bar->start, 0);
XSETINT (bar->end, 0);
bar->dragging = Qnil;
+ bar->fringe_extended_p = Qnil;
/* Requires geometry to be set before call to create the real window */
hwnd = my_create_scrollbar (f, bar);
- if (pfnSetScrollInfo)
- {
- SCROLLINFO si;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_ALL;
+ si.nMin = 0;
+ si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
+ + VERTICAL_SCROLL_BAR_MIN_HANDLE;
+ si.nPage = si.nMax;
+ si.nPos = 0;
- si.cbSize = sizeof (si);
- si.fMask = SIF_ALL;
- si.nMin = 0;
- si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
- + VERTICAL_SCROLL_BAR_MIN_HANDLE;
- si.nPage = si.nMax;
- si.nPos = 0;
-
- pfnSetScrollInfo (hwnd, SB_CTL, &si, FALSE);
- }
- else
- {
- SetScrollRange (hwnd, SB_CTL, 0,
- VERTICAL_SCROLL_BAR_TOP_RANGE (f, height), FALSE);
- SetScrollPos (hwnd, SB_CTL, 0, FALSE);
- }
+ SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
struct scroll_bar *bar;
int top, height, left, sb_left, width, sb_width;
int window_y, window_height;
+ int fringe_extended_p;
/* Get window dimensions. */
window_box (w, -1, 0, &window_y, 0, &window_height);
/* Compute the left edge of the scroll bar. */
if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
- sb_left = left + width - sb_width - (width - sb_width) / 2;
+ sb_left = left + (WINDOW_RIGHTMOST_P (w) ? width - sb_width : 0);
+ else
+ sb_left = left + (WINDOW_LEFTMOST_P (w) ? 0 : width - sb_width);
+
+ if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
+ fringe_extended_p = (WINDOW_LEFTMOST_P (w)
+ && WINDOW_LEFT_FRINGE_WIDTH (w)
+ && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+ || WINDOW_LEFT_MARGIN_COLS (w) == 0));
else
- sb_left = left + (width - sb_width) / 2;
+ fringe_extended_p = (WINDOW_RIGHTMOST_P (w)
+ && WINDOW_RIGHT_FRINGE_WIDTH (w)
+ && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+ || WINDOW_RIGHT_MARGIN_COLS (w) == 0));
/* Does the scroll bar exist yet? */
if (NILP (w->vertical_scroll_bar))
if (width > 0 && height > 0)
{
hdc = get_frame_dc (f);
- w32_clear_area (f, hdc, left, top, width, height);
+ if (fringe_extended_p)
+ w32_clear_area (f, hdc, sb_left, top, sb_width, height);
+ else
+ w32_clear_area (f, hdc, left, top, width, height);
release_frame_dc (f, hdc);
}
UNBLOCK_INPUT;
if ( XINT (bar->left) == sb_left
&& XINT (bar->top) == top
&& XINT (bar->width) == sb_width
- && XINT (bar->height) == height )
+ && XINT (bar->height) == height
+ && !NILP (bar->fringe_extended_p) == fringe_extended_p )
{
/* Redraw after clear_frame. */
if (!my_show_window (f, hwnd, SW_NORMAL))
else
{
HDC hdc;
+ SCROLLINFO si;
+
BLOCK_INPUT;
if (width && height)
{
hdc = get_frame_dc (f);
/* Since Windows scroll bars are smaller than the space reserved
for them on the frame, we have to clear "under" them. */
- w32_clear_area (f, hdc,
- left,
- top,
- width,
- height);
+ if (fringe_extended_p)
+ w32_clear_area (f, hdc, sb_left, top, sb_width, height);
+ else
+ w32_clear_area (f, hdc, left, top, width, height);
release_frame_dc (f, hdc);
}
/* Make sure scroll bar is "visible" before moving, to ensure the
MoveWindow (hwnd, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
top, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
max (height, 1), TRUE);
- if (pfnSetScrollInfo)
- {
- SCROLLINFO si;
- si.cbSize = sizeof (si);
- si.fMask = SIF_RANGE;
- si.nMin = 0;
- si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
- + VERTICAL_SCROLL_BAR_MIN_HANDLE;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_RANGE;
+ si.nMin = 0;
+ si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
+ + VERTICAL_SCROLL_BAR_MIN_HANDLE;
+
+ SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
- pfnSetScrollInfo (hwnd, SB_CTL, &si, FALSE);
- }
- else
- SetScrollRange (hwnd, SB_CTL, 0,
- VERTICAL_SCROLL_BAR_TOP_RANGE (f, height), FALSE);
my_show_window (f, hwnd, SW_NORMAL);
/* InvalidateRect (w, NULL, FALSE); */
UNBLOCK_INPUT;
}
}
+ bar->fringe_extended_p = fringe_extended_p ? Qt : Qnil;
+
w32_set_scroll_bar_thumb (bar, portion, position, whole);
XSETVECTOR (w->vertical_scroll_bar, bar);
int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
int y;
int dragging = !NILP (bar->dragging);
+ SCROLLINFO si;
- if (pfnGetScrollInfo)
- {
- SCROLLINFO si;
-
- si.cbSize = sizeof (si);
- si.fMask = SIF_POS;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_POS;
- pfnGetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
- y = si.nPos;
- }
- else
- y = GetScrollPos ((HWND) msg->msg.lParam, SB_CTL);
+ GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
+ y = si.nPos;
bar->dragging = Qnil;
emacs_event->part = scroll_bar_handle;
/* "Silently" update current position. */
- if (pfnSetScrollInfo)
- {
- SCROLLINFO si;
+ {
+ SCROLLINFO si;
- si.cbSize = sizeof (si);
- si.fMask = SIF_POS;
- si.nPos = y;
- /* Remember apparent position (we actually lag behind the real
- position, so don't set that directly. */
- last_scroll_bar_drag_pos = y;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_POS;
+ si.nPos = y;
+ /* Remember apparent position (we actually lag behind the real
+ position, so don't set that directly. */
+ last_scroll_bar_drag_pos = y;
- pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
- }
- else
- SetScrollPos (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, y, FALSE);
+ SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
+ }
break;
case SB_ENDSCROLL:
/* If this is the end of a drag sequence, then reset the scroll
nothing. */
if (dragging)
{
- if (pfnSetScrollInfo)
- {
- SCROLLINFO si;
- int start = XINT (bar->start);
- int end = XINT (bar->end);
-
- si.cbSize = sizeof (si);
- si.fMask = SIF_PAGE | SIF_POS;
- si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
- si.nPos = last_scroll_bar_drag_pos;
- pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
- }
- else
- SetScrollPos (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, y, TRUE);
+ SCROLLINFO si;
+ int start = XINT (bar->start);
+ int end = XINT (bar->end);
+
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_PAGE | SIF_POS;
+ si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
+ si.nPos = last_scroll_bar_drag_pos;
+ SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
}
/* fall through */
default:
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
int pos;
int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
+ SCROLLINFO si;
BLOCK_INPUT;
*fp = f;
*bar_window = bar->window;
- if (pfnGetScrollInfo)
- {
- SCROLLINFO si;
-
- si.cbSize = sizeof (si);
- si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
+ si.cbSize = sizeof (si);
+ si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
- pfnGetScrollInfo (w, SB_CTL, &si);
- pos = si.nPos;
- top_range = si.nMax - si.nPage + 1;
- }
- else
- pos = GetScrollPos (w, SB_CTL);
+ GetScrollInfo (w, SB_CTL, &si);
+ pos = si.nPos;
+ top_range = si.nMax - si.nPage + 1;
switch (LOWORD (last_mouse_scroll_bar_pos))
{
if (f && !f->iconified)
{
- if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
+ if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
+ && !EQ (f->tool_bar_window, dpyinfo->mouse_face_window))
{
clear_mouse_face (dpyinfo);
dpyinfo->mouse_face_hidden = 1;
if (f && !f->iconified)
{
- if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
+ if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
+ && !EQ (f->tool_bar_window, dpyinfo->mouse_face_window))
{
clear_mouse_face (dpyinfo);
dpyinfo->mouse_face_hidden = 1;
if (f)
{
/* Generate SELECT_WINDOW_EVENTs when needed. */
- if (mouse_autoselect_window)
+ if (!NILP (Vmouse_autoselect_window))
{
Lisp_Object window;
int x = LOWORD (msg.msg.lParam);
/* Window will be selected only when it is not
selected now and last mouse movement event was
not in it. Minibuffer window will be selected
- iff it is active. */
+ only when it is active. */
if (WINDOWP(window)
&& !EQ (window, last_window)
&& !EQ (window, selected_window))
/* Ignore any mouse motion that happened before this
event; any subsequent mouse-movement Emacs events
should reflect only motion after the
- ButtonPress. */
+ ButtonPress. */
f->mouse_moved = 0;
}
last_mouse_frame = f;
struct frame *f = XFRAME (WINDOW_FRAME (w));
HDC hdc;
RECT rect;
- int h;
+ int left, top, h;
struct glyph *cursor_glyph;
HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
return;
/* Compute frame-relative coordinates for phys cursor. */
- rect.left = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
- rect.top = get_phys_cursor_geometry (w, row, cursor_glyph, &h);
+ get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h);
+ rect.left = left;
+ rect.top = top;
rect.bottom = rect.top + h;
rect.right = rect.left + w->phys_cursor_width;
{
int flags = f->size_hint_flags;
- /* Treat negative positions as relative to the leftmost bottommost
+ /* The sum of the widths of the frame's left and right borders, and
+ the sum of the heights of the frame's top and bottom borders (in
+ pixels) drawn by Windows. */
+ unsigned int left_right_borders_width, top_bottom_borders_height;
+
+ /* Try to get the actual values of these two variables. We compute
+ the border width (height) by subtracting the width (height) of
+ the frame's client area from the width (height) of the frame's
+ entire window. */
+ WINDOWPLACEMENT wp = { 0 };
+ RECT client_rect = { 0 };
+
+ if (GetWindowPlacement (FRAME_W32_WINDOW (f), &wp)
+ && GetClientRect (FRAME_W32_WINDOW (f), &client_rect))
+ {
+ left_right_borders_width =
+ (wp.rcNormalPosition.right - wp.rcNormalPosition.left) -
+ (client_rect.right - client_rect.left);
+
+ top_bottom_borders_height =
+ (wp.rcNormalPosition.bottom - wp.rcNormalPosition.top) -
+ (client_rect.bottom - client_rect.top);
+ }
+ else
+ {
+ /* Use sensible default values. */
+ left_right_borders_width = 8;
+ top_bottom_borders_height = 32;
+ }
+
+ /* Treat negative positions as relative to the rightmost bottommost
position that fits on the screen. */
if (flags & XNegative)
f->left_pos = (FRAME_W32_DISPLAY_INFO (f)->width
- FRAME_PIXEL_WIDTH (f)
- + f->left_pos);
+ + f->left_pos
+ - (left_right_borders_width - 1));
if (flags & YNegative)
f->top_pos = (FRAME_W32_DISPLAY_INFO (f)->height
- FRAME_PIXEL_HEIGHT (f)
- + f->top_pos);
- /* The left_pos and top_pos
- are now relative to the top and left screen edges,
- so the flags should correspond. */
+ + f->top_pos
+ - (top_bottom_borders_height - 1));
+
+ /* The left_pos and top_pos are now relative to the top and left
+ screen edges, so the flags should correspond. */
f->size_hint_flags &= ~ (XNegative | YNegative);
}
before the window gets really visible. */
if (! FRAME_ICONIFIED_P (f)
&& ! f->output_data.w32->asked_for_visible)
- x_set_offset (f, f->left_pos, f->top_pos, 0);
+ {
+ RECT workarea_rect;
+ RECT window_rect;
+
+ /* Adjust vertical window position in order to avoid being
+ covered by a task bar placed at the bottom of the desktop. */
+ SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea_rect, 0);
+ GetWindowRect(FRAME_W32_WINDOW(f), &window_rect);
+ if (window_rect.bottom > workarea_rect.bottom
+ && window_rect.top > workarea_rect.top)
+ f->top_pos = max (window_rect.top
+ - window_rect.bottom + workarea_rect.bottom,
+ workarea_rect.top);
+
+ x_set_offset (f, f->left_pos, f->top_pos, 0);
+ }
f->output_data.w32->asked_for_visible = 1;
\f
/* Set up use of W32. */
-DWORD w32_msg_worker ();
+DWORD WINAPI w32_msg_worker (void * arg);
void
x_flush (struct frame * f)
w32_shift_glyphs_for_insert
};
-void
+static void
w32_initialize ()
{
rif = &w32_redisplay_interface;
PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
hWindowsThread = CreateThread (NULL, 0,
- (LPTHREAD_START_ROUTINE) w32_msg_worker,
- 0, 0, &dwWindowsThreadId);
+ w32_msg_worker,
+ 0, 0, &dwWindowsThreadId);
GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
}
AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
#endif
- /* Dynamically link to optional system components. */
+ /* Load system settings. */
{
- HANDLE user_lib = LoadLibrary ("user32.dll");
UINT smoothing_type;
BOOL smoothing_enabled;
-#define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
-
- /* New proportional scroll bar functions. */
- LOAD_PROC (SetScrollInfo);
- LOAD_PROC (GetScrollInfo);
-
-#undef LOAD_PROC
-
- FreeLibrary (user_lib);
-
/* If using proportional scroll bars, ensure handle is at least 5 pixels;
otherwise use the fixed height. */
- vertical_scroll_bar_min_handle = (pfnSetScrollInfo != NULL) ? 5 :
- GetSystemMetrics (SM_CYVTHUMB);
+ vertical_scroll_bar_min_handle = 5;
/* For either kind of scroll bar, take account of the arrows; these
effectively form the border of the main scroll bar range. */
DEFVAR_BOOL ("x-use-underline-position-properties",
&x_use_underline_position_properties,
doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
-nil means ignore them. If you encounter fonts with bogus
+A value of nil means ignore them. If you encounter fonts with bogus
UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
to 4.1, set this to nil.
NOTE: Not supported on MS-Windows yet. */);
x_use_underline_position_properties = 0;
+ DEFVAR_BOOL ("x-underline-at-descent-line",
+ &x_underline_at_descent_line,
+ doc: /* *Non-nil means to draw the underline at the same place as the descent line.
+A value of nil means to draw the underline according to the value of the
+variable `x-use-underline-position-properties', which is usually at the
+baseline level. The default value is nil. */);
+ x_underline_at_descent_line = 0;
+
DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
doc: /* If not nil, Emacs uses toolkit scroll bars. */);
Vx_toolkit_scroll_bars = Qt;