scrollutils.c File Reference

#include "precomp.h"

Include dependency graph for scrollutils.c:

Go to the source code of this file.

Functions
void	OnKeyScroll (HWND hWnd, WPARAM wParam, LPARAM lParam, LPSCROLLSTATE state)
void	OnMouseScroll (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LPSCROLLSTATE state)
void	OnScroll (HWND hWnd, INT nBar, WPARAM wParam, INT iDelta, LPSCROLLSTATE state)
void	UpdateLinesToScroll (LPSCROLLSTATE state)
void	UpdateWindowScrollState (HWND hWnd, INT nMaxWidth, INT nMaxHeight, LPSCROLLSTATE lpState)

Function Documentation

OnKeyScroll()

void OnKeyScroll	(	HWND	hWnd,
		WPARAM	wParam,
		LPARAM	lParam,
		LPSCROLLSTATE	state
	)

Definition at line 11 of file scrollutils.c.

{
    // NOTE: Windows uses an offset of 16 pixels
    switch (wParam)
    {
        case VK_UP:
            OnScroll(hWnd, SB_VERT, MAKELONG(SB_LINEUP, 0), 5, state);
            break;
 
        case VK_DOWN:
            OnScroll(hWnd, SB_VERT, MAKELONG(SB_LINEDOWN, 0), 5, state);
            break;
 
        case VK_LEFT:
            OnScroll(hWnd, SB_HORZ, MAKELONG(SB_LINELEFT, 0), 5, state);
            break;
 
        case VK_RIGHT:
            OnScroll(hWnd, SB_HORZ, MAKELONG(SB_LINERIGHT, 0), 5, state);
            break;
 
        case VK_PRIOR:
            OnScroll(hWnd, SB_VERT, MAKELONG(SB_PAGEUP, 0), state->nPageY, state);
            break;
 
        case VK_NEXT:
            OnScroll(hWnd, SB_VERT, MAKELONG(SB_PAGEDOWN, 0), state->nPageY, state);
            break;
 
        case VK_HOME:
        {
            OnScroll(hWnd, SB_HORZ, MAKELONG(SB_LEFT, 0), 0, state);
            if (GetKeyState(VK_CONTROL) & 0x8000)
                OnScroll(hWnd, SB_VERT, MAKELONG(SB_TOP, 0), 0, state);
            break;
        }
 
        case VK_END:
        {
            OnScroll(hWnd, SB_HORZ, MAKELONG(SB_RIGHT, 0), 0, state);
            if (GetKeyState(VK_CONTROL) & 0x8000)
                OnScroll(hWnd, SB_VERT, MAKELONG(SB_BOTTOM, 0), 0, state);
            break;
        }
 
        default:
            break;
    }
}

Referenced by MainWndProc().

OnMouseScroll()

void OnMouseScroll	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		LPSCROLLSTATE	state
	)

Definition at line 61 of file scrollutils.c.

{
    INT nBar;
    INT nPage;
    INT iDelta;
    UINT uLinesToScroll = state->uLinesToScroll;
    INT zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
    WORD sbCode;
 
    assert(uMsg == WM_MOUSEWHEEL || uMsg == WM_MOUSEHWHEEL);
 
    if (uMsg == WM_MOUSEWHEEL)
    {
        nBar = SB_VERT;
        nPage = state->nPageY;
 
        /* Accumulate wheel rotation ticks */
        zDelta += state->iWheelCarryoverY;
        state->iWheelCarryoverY = zDelta % WHEEL_DELTA;
    }
    else // if (uMsg == WM_MOUSEHWHEEL)
    {
        nBar = SB_HORZ;
        nPage = state->nPageX;
 
        /* Accumulate wheel rotation ticks */
        zDelta += state->iWheelCarryoverX;
        state->iWheelCarryoverX = zDelta % WHEEL_DELTA;
    }
 
    /*
     * If the user specified scrolling by pages, do so.
     * Due to a bug on Windows where, if the window height is
     * less than the scroll lines delta default value (== 3),
     * several lines would be skipped when scrolling if we
     * used the WHEEL_PAGESCROLL value. Instead of this, use
     * the number of lines per page as the limiting value.
     * See https://www.strchr.com/corrections_to_raymond_chen_s_wheel_scrolling_code
     * for more details.
     */
    if (uLinesToScroll > nPage) // (uLinesToScroll == WHEEL_PAGESCROLL)
        uLinesToScroll = nPage;
    /* If the user specified no wheel scrolling, don't do anything */
    else if (uLinesToScroll == 0)
        return;
 
    /* Compute the scroll direction and the absolute delta value */
    if (zDelta > 0)
    {
        sbCode = SB_LINEUP;
    }
    else
    {
        sbCode = SB_LINEDOWN;
        zDelta = -zDelta;
    }
 
    /* Compute how many lines we should scroll (in absolute value) */
    iDelta = (INT)uLinesToScroll * zDelta / WHEEL_DELTA;
 
    OnScroll(hWnd, nBar, MAKELONG(sbCode, 0), iDelta, state);
}

Referenced by MainWndProc().

OnScroll()

void OnScroll	(	HWND	hWnd,
		INT	nBar,
		WPARAM	wParam,
		INT	iDelta,
		LPSCROLLSTATE	state
	)

Definition at line 124 of file scrollutils.c.

{
    SCROLLINFO si;
    PINT pCurrent;
    INT Maximum;
    INT NewPos;
    INT OldX, OldY;
 
    assert(nBar == SB_HORZ || nBar == SB_VERT);
 
    if (Globals.uDisplayFormat == CF_OWNERDISPLAY)
    {
        if (nBar == SB_HORZ)
        {
            SendClipboardOwnerMessage(TRUE, WM_HSCROLLCLIPBOARD,
                                      (WPARAM)hWnd, (LPARAM)wParam);
        }
        else // if (nBar == SB_VERT)
        {
            SendClipboardOwnerMessage(TRUE, WM_VSCROLLCLIPBOARD,
                                      (WPARAM)hWnd, (LPARAM)wParam);
        }
        return;
    }
 
    if (nBar == SB_HORZ)
    {
        pCurrent = &state->CurrentX;
        Maximum = state->MaxX;
    }
    else // if (nBar == SB_VERT)
    {
        pCurrent = &state->CurrentY;
        Maximum = state->MaxY;
    }
 
    ZeroMemory(&si, sizeof(si));
    si.cbSize = sizeof(si);
    si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS;
    GetScrollInfo(hWnd, nBar, &si);
 
    switch (LOWORD(wParam))
    {
        case SB_THUMBPOSITION:
        case SB_THUMBTRACK:
        {
            NewPos = si.nTrackPos;
            break;
        }
 
        case SB_LINEUP:     // SB_LINELEFT:
        {
            NewPos = si.nPos - iDelta;
            break;
        }
 
        case SB_LINEDOWN:   // SB_LINERIGHT:
        {
            NewPos = si.nPos + iDelta;
            break;
        }
 
        case SB_PAGEUP:     // SB_PAGELEFT:
        {
            NewPos = si.nPos - si.nPage;
            break;
        }
 
        case SB_PAGEDOWN:   // SB_PAGERIGHT:
        {
            NewPos = si.nPos + si.nPage;
            break;
        }
 
        case SB_TOP:        // SB_LEFT:
        {
            NewPos = si.nMin;
            break;
        }
 
        case SB_BOTTOM:     // SB_RIGHT:
        {
            NewPos = si.nMax;
            break;
        }
 
        default:
        {
            NewPos = si.nPos;
            break;
        }
    }
 
    NewPos = min(max(NewPos, 0), Maximum);
 
    if (si.nPos == NewPos)
        return;
 
    OldX = state->CurrentX;
    OldY = state->CurrentY;
    *pCurrent = NewPos;
 
    ScrollWindowEx(hWnd,
                   OldX - state->CurrentX,
                   OldY - state->CurrentY,
                   NULL,
                   NULL,
                   NULL,
                   NULL,
                   SW_ERASE | SW_INVALIDATE);
    UpdateWindow(hWnd);
 
    si.fMask = SIF_POS;
    si.nPos = NewPos;
    SetScrollInfo(hWnd, nBar, &si, TRUE);
}

Referenced by MainWndProc(), OnKeyScroll(), and OnMouseScroll().

UpdateLinesToScroll()

void UpdateLinesToScroll

(

LPSCROLLSTATE

state

)

Definition at line 241 of file scrollutils.c.

{
    UINT uLinesToScroll;
 
    if (!SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &uLinesToScroll, 0))
    {
        /* Default value on Windows */
        state->uLinesToScroll = 3;
    }
    else
    {
        state->uLinesToScroll = uLinesToScroll;
    }
}

Referenced by MainWndProc().

UpdateWindowScrollState()

void UpdateWindowScrollState	(	HWND	hWnd,
		INT	nMaxWidth,
		INT	nMaxHeight,
		LPSCROLLSTATE	lpState
	)

Definition at line 256 of file scrollutils.c.

{
    RECT rc;
    SCROLLINFO si;
 
    if (!GetClientRect(hWnd, &rc))
        SetRectEmpty(&rc);
 
    ZeroMemory(&si, sizeof(si));
    si.cbSize = sizeof(si);
    si.fMask  = SIF_RANGE | SIF_PAGE | SIF_POS | SIF_DISABLENOSCROLL;
 
    lpState->nMaxWidth = nMaxWidth;
    lpState->MaxX = max(nMaxWidth - rc.right, 0);
    lpState->CurrentX = min(lpState->CurrentX, lpState->MaxX);
    lpState->nPageX = rc.right;
    si.nMin  = 0;
    si.nMax  = nMaxWidth;
    si.nPage = lpState->nPageX;
    si.nPos  = lpState->CurrentX;
    SetScrollInfo(hWnd, SB_HORZ, &si, TRUE);
 
    lpState->nMaxHeight = nMaxHeight;
    lpState->MaxY = max(nMaxHeight - rc.bottom, 0);
    lpState->CurrentY = min(lpState->CurrentY, lpState->MaxY);
    lpState->nPageY = rc.bottom;
    si.nMin  = 0;
    si.nMax  = nMaxHeight;
    si.nPage = lpState->nPageY;
    si.nPos  = lpState->CurrentY;
    SetScrollInfo(hWnd, SB_VERT, &si, TRUE);
}

Referenced by MainWndProc(), and SetDisplayFormat().