/* scrollbar implementation -- mswindows interface.
Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
- Copyright (C) 1994 Amdhal Corporation.
+ Copyright (C) 1994 Amdahl Corporation.
Copyright (C) 1995 Sun Microsystems, Inc.
Copyright (C) 1995 Darrell Kindred <dkindred+@cmu.edu>.
#include "specifier.h"
#include "window.h"
-/* This has really different semantics in Windows than in Motif.
- There's no corresponding method; we just do not change slider
- size while dragging. It makes the scrollbar look smother and
- prevents some weird behavior when scrolled near the bottom */
-static int inhibit_slider_size_change = 0;
+/* We use a similar sort of vertical scrollbar drag hack for mswindows
+ * scrollbars as is used for Motif or Lucid scrollbars under X.
+ * We do character-based instead of line-based scrolling, which can mean that
+ * without the hack it is impossible to drag to the end of a buffer. */
+#define VERTICAL_SCROLLBAR_DRAG_HACK
+
+static int vertical_drag_in_progress = 0;
static void
mswindows_create_scrollbar_instance (struct frame *f, int vertical,
struct scrollbar_instance *sb)
{
int orientation;
-
+
sb->scrollbar_data = xnew_and_zero (struct mswindows_scrollbar_data);
-
+
if (vertical)
orientation = SBS_VERT;
else
orientation = SBS_HORZ;
-
+
SCROLLBAR_MSW_HANDLE (sb) =
CreateWindowEx(0, "SCROLLBAR", 0, orientation|WS_CHILD,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
FRAME_MSWINDOWS_HANDLE (f),
NULL, NULL, NULL);
+ SCROLLBAR_MSW_INFO (sb).cbSize = sizeof(SCROLLINFO);
SCROLLBAR_MSW_INFO (sb).fMask = SIF_ALL;
GetScrollInfo(SCROLLBAR_MSW_HANDLE (sb), SB_CTL,
&SCROLLBAR_MSW_INFO (sb));
mswindows_free_scrollbar_instance (struct scrollbar_instance *sb)
{
DestroyWindow (SCROLLBAR_MSW_HANDLE (sb));
- if (sb->scrollbar_data)
+ if (sb->scrollbar_data)
xfree (sb->scrollbar_data);
}
int new_scrollbar_x,
int new_scrollbar_y)
{
- struct frame *f;
int pos_changed = 0;
-
- f = XFRAME (w->frame);
+ int vert = GetWindowLong (SCROLLBAR_MSW_HANDLE (sb), GWL_STYLE) & SBS_VERT;
#if 0
stderr_out ("[%d, %d], page = %d, pos = %d, inhibit = %d\n", new_minimum, new_maximum,
/* These might be optimized, but since at least one will change at each
call, it's probably not worth it. */
- SCROLLBAR_MSW_INFO (sb).cbSize = sizeof(SCROLLINFO);
SCROLLBAR_MSW_INFO (sb).nMin = new_minimum;
SCROLLBAR_MSW_INFO (sb).nMax = new_maximum;
- SCROLLBAR_MSW_INFO (sb).nPage = new_slider_size + 1; /* for DISABLENOSCROLL */
+ SCROLLBAR_MSW_INFO (sb).nPage = new_slider_size + 1; /* +1 for DISABLENOSCROLL */
SCROLLBAR_MSW_INFO (sb).nPos = new_slider_position;
- SCROLLBAR_MSW_INFO (sb).fMask = (inhibit_slider_size_change
+#ifndef VERTICAL_SCROLLBAR_DRAG_HACK
+ SCROLLBAR_MSW_INFO (sb).fMask = ((vert && vertical_drag_in_progress)
? SIF_RANGE | SIF_POS
: SIF_ALL | SIF_DISABLENOSCROLL);
-
- SetScrollInfo(SCROLLBAR_MSW_HANDLE (sb), SB_CTL, &SCROLLBAR_MSW_INFO (sb),
- !pos_changed);
+#else
+ SCROLLBAR_MSW_INFO (sb).fMask = SIF_ALL | SIF_DISABLENOSCROLL;
+
+ /* Ignore XEmacs' requests to update the thumb position and size; they don't
+ * bear any relation to reality because we're reporting made-up positions */
+ if (!(vert && vertical_drag_in_progress))
+#endif
+ SetScrollInfo (SCROLLBAR_MSW_HANDLE (sb), SB_CTL, &SCROLLBAR_MSW_INFO (sb),
+ TRUE);
UPDATE_POS_FIELD (scrollbar_x);
UPDATE_POS_FIELD (scrollbar_y);
UPDATE_POS_FIELD (scrollbar_width);
UPDATE_POS_FIELD (scrollbar_height);
- if (pos_changed)
+ if (pos_changed)
{
MoveWindow(SCROLLBAR_MSW_HANDLE (sb),
new_scrollbar_x, new_scrollbar_y,
struct scrollbar_instance *sb;
SCROLLINFO scrollinfo;
int vert = GetWindowLong (hwnd, GWL_STYLE) & SBS_VERT;
+ int value;
sb = (struct scrollbar_instance *)GetWindowLong (hwnd, GWL_USERDATA);
win = real_window (sb->mirror, 1);
frame = XWINDOW (win)->frame;
f = XFRAME (frame);
- inhibit_slider_size_change = code == SB_THUMBTRACK;
-
/* SB_LINEDOWN == SB_CHARLEFT etc. This is the way they will
- always be - any Windows is binary compatible backward with
+ always be - any Windows is binary compatible backward with
old programs */
switch (code)
mswindows_enqueue_misc_user_event
(frame, vert ? Qscrollbar_line_down : Qscrollbar_char_right, win);
break;
-
+
case SB_LINEUP:
mswindows_enqueue_misc_user_event
(frame, vert ? Qscrollbar_line_up : Qscrollbar_char_left, win);
break;
-
+
case SB_PAGEDOWN:
mswindows_enqueue_misc_user_event
(win, vert ? Qscrollbar_page_down : Qscrollbar_page_right,
vert ? Qscrollbar_page_up : Qscrollbar_page_left,
vert ? Fcons (win, Qnil) : win);
break;
-
+
case SB_BOTTOM:
mswindows_enqueue_misc_user_event
(frame, vert ? Qscrollbar_to_bottom : Qscrollbar_to_right, win);
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
scrollinfo.cbSize = sizeof(SCROLLINFO);
- scrollinfo.fMask = SIF_TRACKPOS;
+ scrollinfo.fMask = SIF_ALL;
GetScrollInfo (hwnd, SB_CTL, &scrollinfo);
+ vertical_drag_in_progress = vert;
+#ifdef VERTICAL_SCROLLBAR_DRAG_HACK
+ if (vert && (scrollinfo.nTrackPos > scrollinfo.nPos))
+ /* new buffer position =
+ * buffer position at start of drag +
+ * ((text remaining in buffer at start of drag) *
+ * (amount that the thumb has been moved) /
+ * (space that remained past end of the thumb at start of drag)) */
+ value = (int)
+ (scrollinfo.nPos
+ + (((double)
+ (scrollinfo.nMax - scrollinfo.nPos)
+ * (scrollinfo.nTrackPos - scrollinfo.nPos))
+ / (scrollinfo.nMax - scrollinfo.nPage - scrollinfo.nPos)))
+ - 2; /* ensure that the last line doesn't disappear off screen */
+ else
+#endif
+ value = scrollinfo.nTrackPos;
mswindows_enqueue_misc_user_event
(frame,
vert ? Qscrollbar_vertical_drag : Qscrollbar_horizontal_drag,
- Fcons (win, make_int (scrollinfo.nTrackPos)));
+ Fcons (win, make_int (value)));
+ break;
+
+ case SB_ENDSCROLL:
+#ifdef VERTICAL_SCROLLBAR_DRAG_HACK
+ if (vertical_drag_in_progress)
+ /* User has just dropped the thumb - finally update it */
+ SetScrollInfo (SCROLLBAR_MSW_HANDLE (sb), SB_CTL,
+ &SCROLLBAR_MSW_INFO (sb), TRUE);
+#endif
+ vertical_drag_in_progress = 0;
break;
}
}
+static int
+can_scroll(struct scrollbar_instance* scrollbar)
+{
+ return scrollbar != NULL
+ && IsWindowVisible (SCROLLBAR_MSW_HANDLE (scrollbar))
+ && IsWindowEnabled (SCROLLBAR_MSW_HANDLE (scrollbar));
+}
+
+int
+mswindows_handle_mousewheel_event (Lisp_Object frame, int keys, int delta)
+{
+ int hasVertBar, hasHorzBar; /* Indicates presence of scroll bars */
+ unsigned wheelScrollLines = 0; /* Number of lines per wheel notch */
+
+ /* Find the currently selected window */
+ Lisp_Object win = FRAME_SELECTED_WINDOW (XFRAME (frame));
+ struct window* w = XWINDOW (win);
+ struct window_mirror* mirror = find_window_mirror (w);
+
+ /* Check that there is something to scroll */
+ hasVertBar = can_scroll (mirror->scrollbar_vertical_instance);
+ hasHorzBar = can_scroll (mirror->scrollbar_horizontal_instance);
+ if (!hasVertBar && !hasHorzBar)
+ return FALSE;
+
+ /* No support for panning and zooming, so ignore */
+ if (keys & (MK_SHIFT | MK_CONTROL))
+ return FALSE;
+
+ /* Get the number of lines per wheel delta */
+ SystemParametersInfo (SPI_GETWHEELSCROLLLINES, 0, &wheelScrollLines, 0);
+
+ /* Calculate the amount to scroll */
+ if (wheelScrollLines == WHEEL_PAGESCROLL)
+ {
+ /* Scroll by a page */
+ Lisp_Object function;
+ if (hasVertBar)
+ function = delta > 0 ? Qscrollbar_page_up : Qscrollbar_page_down;
+ else
+ function = delta > 0 ? Qscrollbar_page_left : Qscrollbar_page_right;
+ mswindows_enqueue_misc_user_event (frame, function, Fcons (win, Qnil));
+ }
+ else /* Scroll by a number of lines */
+ {
+ /* Calc the number of lines to scroll */
+ int toScroll = MulDiv (delta, wheelScrollLines, WHEEL_DELTA);
+
+ /* Do the scroll */
+ Lisp_Object function;
+ if (hasVertBar)
+ function = delta > 0 ? Qscrollbar_line_up : Qscrollbar_line_down;
+ else
+ function = delta > 0 ? Qscrollbar_char_left : Qscrollbar_char_right;
+ if (toScroll < 0)
+ toScroll = -toScroll;
+ while (toScroll--)
+ mswindows_enqueue_misc_user_event (frame, function, win);
+ }
+
+ return TRUE;
+}
+
#ifdef MEMORY_USAGE_STATS
static int