reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-30 07:00:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6b8a8d75e2
wine/dlls/comctl32/pager.c

1371 lines
40 KiB
C
Raw Blame History

/*
* Pager control
*
* Copyright 1998, 1999 Eric Kohl
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* NOTES
*
* This code was audited for completeness against the documented features
* of Comctl32.dll version 6.0 on Sep. 18, 2004, by Robert Shearman.
*
* Unless otherwise noted, we believe this code to be complete, as per
* the specification mentioned above.
* If you discover missing features or bugs please note them below.
*
* TODO:
* Implement repetitive button press.
* Adjust arrow size relative to size of button.
* Allow border size changes.
* Styles:
* PGS_DRAGNDROP
* Notifications:
* PGN_HOTITEMCHANGE
* Messages:
* WM_PRINT and/or WM_PRINTCLIENT
*
* TESTING:
* Tested primarily with the controlspy Pager application.
* Susan Farley (susan@codeweavers.com)
*
* IMPLEMENTATION NOTES:
* This control uses WM_NCPAINT instead of WM_PAINT to paint itself
* as we need to scroll a child window. In order to do this we move
* the child window in the control's client area, using the clipping
* region that is automatically set around the client area. As the
* entire client area now consists of the child window, we must
* allocate space (WM_NCCALCSIZE) for the buttons and draw them as
* a non-client area (WM_NCPAINT).
* Robert Shearman <rob@codeweavers.com>
*/
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "commctrl.h"
#include "comctl32.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(pager);
typedef struct
{
HWND hwndSelf; /* handle of the control wnd */
HWND hwndChild; /* handle of the contained wnd */
HWND hwndNotify; /* handle of the parent wnd */
DWORD dwStyle; /* styles for this control */
COLORREF clrBk; /* background color */
INT nBorder; /* border size for the control */
INT nButtonSize;/* size of the pager btns */
INT nPos; /* scroll position */
INT nWidth; /* from child wnd's response to PGN_CALCSIZE */
INT nHeight; /* from child wnd's response to PGN_CALCSIZE */
BOOL bForward; /* forward WM_MOUSEMOVE msgs to the contained wnd */
BOOL bCapture; /* we have captured the mouse */
INT TLbtnState; /* state of top or left btn */
INT BRbtnState; /* state of bottom or right btn */
INT direction; /* direction of the scroll, (e.g. PGF_SCROLLUP) */
} PAGER_INFO;
#define MIN_ARROW_WIDTH 8
#define MIN_ARROW_HEIGHT 5
#define TIMERID1 1
#define TIMERID2 2
#define INITIAL_DELAY 500
#define REPEAT_DELAY 50
static void
PAGER_GetButtonRects(const PAGER_INFO* infoPtr, RECT* prcTopLeft, RECT* prcBottomRight, BOOL bClientCoords)
{
RECT rcWindow;
GetWindowRect (infoPtr->hwndSelf, &rcWindow);
if (bClientCoords)
MapWindowPoints( 0, infoPtr->hwndSelf, (POINT *)&rcWindow, 2 );
else
OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top);
*prcTopLeft = *prcBottomRight = rcWindow;
if (infoPtr->dwStyle & PGS_HORZ)
{
prcTopLeft->right = prcTopLeft->left + infoPtr->nButtonSize;
prcBottomRight->left = prcBottomRight->right - infoPtr->nButtonSize;
}
else
{
prcTopLeft->bottom = prcTopLeft->top + infoPtr->nButtonSize;
prcBottomRight->top = prcBottomRight->bottom - infoPtr->nButtonSize;
}
}
/* the horizontal arrows are:
*
* 01234 01234
* 1 * *
* 2 ** **
* 3*** ***
* 4*** ***
* 5 ** **
* 6 * *
* 7
*
*/
static void
PAGER_DrawHorzArrow (HDC hdc, RECT r, INT colorRef, BOOL left)
{
INT x, y, w, h;
HPEN hPen, hOldPen;
w = r.right - r.left + 1;
h = r.bottom - r.top + 1;
if ((h < MIN_ARROW_WIDTH) || (w < MIN_ARROW_HEIGHT))
return; /* refuse to draw partial arrow */
if (!(hPen = CreatePen( PS_SOLID, 1, GetSysColor( colorRef )))) return;
hOldPen = SelectObject ( hdc, hPen );
if (left)
{
x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 3;
y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 1;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x--, y+5); y++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x--, y+3); y++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x, y+1);
}
else
{
x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 1;
y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 1;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x++, y+5); y++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x++, y+3); y++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x, y+1);
}
SelectObject( hdc, hOldPen );
DeleteObject( hPen );
}
/* the vertical arrows are:
*
* 01234567 01234567
* 1****** **
* 2 **** ****
* 3 ** ******
* 4
*
*/
static void
PAGER_DrawVertArrow (HDC hdc, RECT r, INT colorRef, BOOL up)
{
INT x, y, w, h;
HPEN hPen, hOldPen;
w = r.right - r.left + 1;
h = r.bottom - r.top + 1;
if ((h < MIN_ARROW_WIDTH) || (w < MIN_ARROW_HEIGHT))
return; /* refuse to draw partial arrow */
if (!(hPen = CreatePen( PS_SOLID, 1, GetSysColor( colorRef )))) return;
hOldPen = SelectObject ( hdc, hPen );
if (up)
{
x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 1;
y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 3;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x+5, y--); x++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x+3, y--); x++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x+1, y);
}
else
{
x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 1;
y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 1;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x+5, y++); x++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x+3, y++); x++;
MoveToEx (hdc, x, y, NULL);
LineTo (hdc, x+1, y);
}
SelectObject( hdc, hOldPen );
DeleteObject( hPen );
}
static void
PAGER_DrawButton(HDC hdc, COLORREF clrBk, RECT arrowRect,
BOOL horz, BOOL topLeft, INT btnState)
{
HBRUSH hBrush, hOldBrush;
RECT rc = arrowRect;
TRACE("arrowRect = %s, btnState = %d\n", wine_dbgstr_rect(&arrowRect), btnState);
if (btnState == PGF_INVISIBLE)
return;
if ((rc.right - rc.left <= 0) || (rc.bottom - rc.top <= 0))
return;
hBrush = CreateSolidBrush(clrBk);
hOldBrush = SelectObject(hdc, hBrush);
FillRect(hdc, &rc, hBrush);
if (btnState == PGF_HOT)
{
DrawEdge( hdc, &rc, BDR_RAISEDINNER, BF_RECT);
if (horz)
PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
else
PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
}
else if (btnState == PGF_NORMAL)
{
DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT);
if (horz)
PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
else
PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
}
else if (btnState == PGF_DEPRESSED)
{
DrawEdge( hdc, &rc, BDR_SUNKENOUTER, BF_RECT);
if (horz)
PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
else
PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
}
else if (btnState == PGF_GRAYED)
{
DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT);
if (horz)
{
PAGER_DrawHorzArrow(hdc, rc, COLOR_3DHIGHLIGHT, topLeft);
rc.left++, rc.top++; rc.right++, rc.bottom++;
PAGER_DrawHorzArrow(hdc, rc, COLOR_3DSHADOW, topLeft);
}
else
{
PAGER_DrawVertArrow(hdc, rc, COLOR_3DHIGHLIGHT, topLeft);
rc.left++, rc.top++; rc.right++, rc.bottom++;
PAGER_DrawVertArrow(hdc, rc, COLOR_3DSHADOW, topLeft);
}
}
SelectObject( hdc, hOldBrush );
DeleteObject(hBrush);
}
/* << PAGER_GetDropTarget >> */
static inline LRESULT
PAGER_ForwardMouse (PAGER_INFO* infoPtr, BOOL bFwd)
{
TRACE("[%p]\n", infoPtr->hwndSelf);
infoPtr->bForward = bFwd;
return 0;
}
static inline LRESULT
PAGER_GetButtonState (const PAGER_INFO* infoPtr, INT btn)
{
LRESULT btnState = PGF_INVISIBLE;
TRACE("[%p]\n", infoPtr->hwndSelf);
if (btn == PGB_TOPORLEFT)
btnState = infoPtr->TLbtnState;
else if (btn == PGB_BOTTOMORRIGHT)
btnState = infoPtr->BRbtnState;
return btnState;
}
static inline INT
PAGER_GetPos(const PAGER_INFO *infoPtr)
{
TRACE("[%p] returns %d\n", infoPtr->hwndSelf, infoPtr->nPos);
return infoPtr->nPos;
}
static inline INT
PAGER_GetButtonSize(const PAGER_INFO *infoPtr)
{
TRACE("[%p] returns %d\n", infoPtr->hwndSelf, infoPtr->nButtonSize);
return infoPtr->nButtonSize;
}
static inline INT
PAGER_GetBorder(const PAGER_INFO *infoPtr)
{
TRACE("[%p] returns %d\n", infoPtr->hwndSelf, infoPtr->nBorder);
return infoPtr->nBorder;
}
static inline COLORREF
PAGER_GetBkColor(const PAGER_INFO *infoPtr)
{
TRACE("[%p] returns %06x\n", infoPtr->hwndSelf, infoPtr->clrBk);
return infoPtr->clrBk;
}
static void
PAGER_CalcSize (const PAGER_INFO *infoPtr, INT* size, BOOL getWidth)
{
NMPGCALCSIZE nmpgcs;
ZeroMemory (&nmpgcs, sizeof (NMPGCALCSIZE));
nmpgcs.hdr.hwndFrom = infoPtr->hwndSelf;
nmpgcs.hdr.idFrom = GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_ID);
nmpgcs.hdr.code = PGN_CALCSIZE;
nmpgcs.dwFlag = getWidth ? PGF_CALCWIDTH : PGF_CALCHEIGHT;
nmpgcs.iWidth = getWidth ? *size : 0;
nmpgcs.iHeight = getWidth ? 0 : *size;
SendMessageW (infoPtr->hwndNotify, WM_NOTIFY, nmpgcs.hdr.idFrom, (LPARAM)&nmpgcs);
*size = getWidth ? nmpgcs.iWidth : nmpgcs.iHeight;
TRACE("[%p] PGN_CALCSIZE returns %s=%d\n", infoPtr->hwndSelf,
getWidth ? "width" : "height", *size);
}
static void
PAGER_PositionChildWnd(PAGER_INFO* infoPtr)
{
if (infoPtr->hwndChild)
{
RECT rcClient;
int nPos = infoPtr->nPos;
/* compensate for a grayed btn, which will soon become invisible */
if (infoPtr->TLbtnState == PGF_GRAYED)
nPos += infoPtr->nButtonSize;
GetClientRect(infoPtr->hwndSelf, &rcClient);
if (infoPtr->dwStyle & PGS_HORZ)
{
int wndSize = max(0, rcClient.right - rcClient.left);
if (infoPtr->nWidth < wndSize)
infoPtr->nWidth = wndSize;
TRACE("[%p] SWP %dx%d at (%d,%d)\n", infoPtr->hwndSelf,
infoPtr->nWidth, infoPtr->nHeight,
-nPos, 0);
SetWindowPos(infoPtr->hwndChild, 0,
-nPos, 0,
infoPtr->nWidth, infoPtr->nHeight,
SWP_NOZORDER);
}
else
{
int wndSize = max(0, rcClient.bottom - rcClient.top);
if (infoPtr->nHeight < wndSize)
infoPtr->nHeight = wndSize;
TRACE("[%p] SWP %dx%d at (%d,%d)\n", infoPtr->hwndSelf,
infoPtr->nWidth, infoPtr->nHeight,
0, -nPos);
SetWindowPos(infoPtr->hwndChild, 0,
0, -nPos,
infoPtr->nWidth, infoPtr->nHeight,
SWP_NOZORDER);
}
InvalidateRect(infoPtr->hwndChild, NULL, TRUE);
}
}
static INT
PAGER_GetScrollRange(PAGER_INFO* infoPtr)
{
INT scrollRange = 0;
if (infoPtr->hwndChild)
{
INT wndSize, childSize;
RECT wndRect;
GetWindowRect(infoPtr->hwndSelf, &wndRect);
if (infoPtr->dwStyle & PGS_HORZ)
{
wndSize = wndRect.right - wndRect.left;
PAGER_CalcSize(infoPtr, &infoPtr->nWidth, TRUE);
childSize = infoPtr->nWidth;
}
else
{
wndSize = wndRect.bottom - wndRect.top;
PAGER_CalcSize(infoPtr, &infoPtr->nHeight, FALSE);
childSize = infoPtr->nHeight;
}
TRACE("childSize = %d, wndSize = %d\n", childSize, wndSize);
if (childSize > wndSize)
scrollRange = childSize - wndSize + infoPtr->nButtonSize;
}
TRACE("[%p] returns %d\n", infoPtr->hwndSelf, scrollRange);
return scrollRange;
}
static void
PAGER_UpdateBtns(PAGER_INFO *infoPtr, INT scrollRange, BOOL hideGrayBtns)
{
BOOL resizeClient;
BOOL repaintBtns;
INT oldTLbtnState = infoPtr->TLbtnState;
INT oldBRbtnState = infoPtr->BRbtnState;
POINT pt;
RECT rcTopLeft, rcBottomRight;
/* get button rects */
PAGER_GetButtonRects(infoPtr, &rcTopLeft, &rcBottomRight, FALSE);
GetCursorPos(&pt);
/* update states based on scroll position */
if (infoPtr->nPos > 0)
{
if (infoPtr->TLbtnState == PGF_INVISIBLE || infoPtr->TLbtnState == PGF_GRAYED)
infoPtr->TLbtnState = PGF_NORMAL;
}
else if (PtInRect(&rcTopLeft, pt))
infoPtr->TLbtnState = PGF_GRAYED;
else
infoPtr->TLbtnState = PGF_INVISIBLE;
if (scrollRange <= 0)
{
infoPtr->TLbtnState = PGF_INVISIBLE;
infoPtr->BRbtnState = PGF_INVISIBLE;
}
else if (infoPtr->nPos < scrollRange)
{
if (infoPtr->BRbtnState == PGF_INVISIBLE || infoPtr->BRbtnState == PGF_GRAYED)
infoPtr->BRbtnState = PGF_NORMAL;
}
else if (PtInRect(&rcBottomRight, pt))
infoPtr->BRbtnState = PGF_GRAYED;
else
infoPtr->BRbtnState = PGF_INVISIBLE;
/* only need to resize when entering or leaving PGF_INVISIBLE state */
resizeClient =
((oldTLbtnState == PGF_INVISIBLE) != (infoPtr->TLbtnState == PGF_INVISIBLE)) ||
((oldBRbtnState == PGF_INVISIBLE) != (infoPtr->BRbtnState == PGF_INVISIBLE));
/* initiate NCCalcSize to resize client wnd if necessary */
if (resizeClient)
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
/* repaint when changing any state */
repaintBtns = (oldTLbtnState != infoPtr->TLbtnState) ||
(oldBRbtnState != infoPtr->BRbtnState);
if (repaintBtns)
SendMessageW(infoPtr->hwndSelf, WM_NCPAINT, 0, 0);
}
static LRESULT
PAGER_SetPos(PAGER_INFO* infoPtr, INT newPos, BOOL fromBtnPress)
{
INT scrollRange = PAGER_GetScrollRange(infoPtr);
INT oldPos = infoPtr->nPos;
if ((scrollRange <= 0) || (newPos < 0))
infoPtr->nPos = 0;
else if (newPos > scrollRange)
infoPtr->nPos = scrollRange;
else
infoPtr->nPos = newPos;
TRACE("[%p] pos=%d, oldpos=%d\n", infoPtr->hwndSelf, infoPtr->nPos, oldPos);
if (infoPtr->nPos != oldPos)
{
/* gray and restore btns, and if from WM_SETPOS, hide the gray btns */
PAGER_UpdateBtns(infoPtr, scrollRange, !fromBtnPress);
PAGER_PositionChildWnd(infoPtr);
}
return 0;
}
static LRESULT
PAGER_WindowPosChanging(PAGER_INFO* infoPtr, WINDOWPOS *winpos)
{
if ((infoPtr->dwStyle & CCS_NORESIZE) && !(winpos->flags & SWP_NOSIZE))
{
/* don't let the app resize the nonscrollable dimension of a control
* that was created with CCS_NORESIZE style
* (i.e. height for a horizontal pager, or width for a vertical one) */
/* except if the current dimension is 0 and app is setting for
* first time, then save amount as dimension. - GA 8/01 */
if (infoPtr->dwStyle & PGS_HORZ)
if (!infoPtr->nHeight && winpos->cy)
infoPtr->nHeight = winpos->cy;
else
winpos->cy = infoPtr->nHeight;
else
if (!infoPtr->nWidth && winpos->cx)
infoPtr->nWidth = winpos->cx;
else
winpos->cx = infoPtr->nWidth;
return 0;
}
return DefWindowProcW (infoPtr->hwndSelf, WM_WINDOWPOSCHANGING, 0, (LPARAM)winpos);
}
static INT
PAGER_SetFixedWidth(PAGER_INFO* infoPtr)
{
/* Must set the non-scrollable dimension to be less than the full height/width
* so that NCCalcSize is called. The Microsoft docs mention 3/4 factor for button
* size, and experimentation shows that the effect is almost right. */
RECT wndRect;
INT delta, h;
GetWindowRect(infoPtr->hwndSelf, &wndRect);
/* see what the app says for btn width */
PAGER_CalcSize(infoPtr, &infoPtr->nWidth, TRUE);
if (infoPtr->dwStyle & CCS_NORESIZE)
{
delta = wndRect.right - wndRect.left - infoPtr->nWidth;
if (delta > infoPtr->nButtonSize)
infoPtr->nWidth += 4 * infoPtr->nButtonSize / 3;
else if (delta > 0)
infoPtr->nWidth += infoPtr->nButtonSize / 3;
}
h = wndRect.bottom - wndRect.top + infoPtr->nButtonSize;
TRACE("[%p] infoPtr->nWidth set to %d\n",
infoPtr->hwndSelf, infoPtr->nWidth);
return h;
}
static INT
PAGER_SetFixedHeight(PAGER_INFO* infoPtr)
{
/* Must set the non-scrollable dimension to be less than the full height/width
* so that NCCalcSize is called. The Microsoft docs mention 3/4 factor for button
* size, and experimentation shows that the effect is almost right. */
RECT wndRect;
INT delta, w;
GetWindowRect(infoPtr->hwndSelf, &wndRect);
/* see what the app says for btn height */
PAGER_CalcSize(infoPtr, &infoPtr->nHeight, FALSE);
if (infoPtr->dwStyle & CCS_NORESIZE)
{
delta = wndRect.bottom - wndRect.top - infoPtr->nHeight;
if (delta > infoPtr->nButtonSize)
infoPtr->nHeight += infoPtr->nButtonSize;
else if (delta > 0)
infoPtr->nHeight += infoPtr->nButtonSize / 3;
}
w = wndRect.right - wndRect.left + infoPtr->nButtonSize;
TRACE("[%p] infoPtr->nHeight set to %d\n",
infoPtr->hwndSelf, infoPtr->nHeight);
return w;
}
/******************************************************************
* For the PGM_RECALCSIZE message (but not the other uses in *
* this module), the native control does only the following: *
* *
* if (some condition) *
* PostMessageW(hwnd, EM_FMTLINES, 0, 0); *
* return DefWindowProcW(hwnd, PGM_RECALCSIZE, 0, 0); *
* *
* When we figure out what the "some condition" is we will *
* implement that for the message processing. *
******************************************************************/
static LRESULT
PAGER_RecalcSize(PAGER_INFO *infoPtr)
{
TRACE("[%p]\n", infoPtr->hwndSelf);
if (infoPtr->hwndChild)
{
INT scrollRange = PAGER_GetScrollRange(infoPtr);
if (scrollRange <= 0)
{
infoPtr->nPos = -1;
PAGER_SetPos(infoPtr, 0, FALSE);
}
else
PAGER_PositionChildWnd(infoPtr);
}
return 1;
}
static COLORREF
PAGER_SetBkColor (PAGER_INFO* infoPtr, COLORREF clrBk)
{
COLORREF clrTemp = infoPtr->clrBk;
infoPtr->clrBk = clrBk;
TRACE("[%p] %06x\n", infoPtr->hwndSelf, infoPtr->clrBk);
/* the native control seems to do things this way */
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
RedrawWindow(infoPtr->hwndSelf, 0, 0, RDW_ERASE | RDW_INVALIDATE);
return clrTemp;
}
static INT
PAGER_SetBorder (PAGER_INFO* infoPtr, INT iBorder)
{
INT nTemp = infoPtr->nBorder;
infoPtr->nBorder = iBorder;
TRACE("[%p] %d\n", infoPtr->hwndSelf, infoPtr->nBorder);
PAGER_RecalcSize(infoPtr);
return nTemp;
}
static INT
PAGER_SetButtonSize (PAGER_INFO* infoPtr, INT iButtonSize)
{
INT nTemp = infoPtr->nButtonSize;
infoPtr->nButtonSize = iButtonSize;
TRACE("[%p] %d\n", infoPtr->hwndSelf, infoPtr->nButtonSize);
PAGER_RecalcSize(infoPtr);
return nTemp;
}
static LRESULT
PAGER_SetChild (PAGER_INFO* infoPtr, HWND hwndChild)
{
INT hw;
infoPtr->hwndChild = IsWindow (hwndChild) ? hwndChild : 0;
if (infoPtr->hwndChild)
{
TRACE("[%p] hwndChild=%p\n", infoPtr->hwndSelf, infoPtr->hwndChild);
if (infoPtr->dwStyle & PGS_HORZ) {
hw = PAGER_SetFixedHeight(infoPtr);
/* adjust non-scrollable dimension to fit the child */
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, hw, infoPtr->nHeight,
SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER |
SWP_NOSIZE | SWP_NOACTIVATE);
}
else {
hw = PAGER_SetFixedWidth(infoPtr);
/* adjust non-scrollable dimension to fit the child */
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, infoPtr->nWidth, hw,
SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER |
SWP_NOSIZE | SWP_NOACTIVATE);
}
/* position child within the page scroller */
SetWindowPos(infoPtr->hwndChild, HWND_TOP,
0,0,0,0,
SWP_SHOWWINDOW | SWP_NOSIZE); /* native is 0 */
infoPtr->nPos = -1;
PAGER_SetPos(infoPtr, 0, FALSE);
}
return 0;
}
static void
PAGER_Scroll(PAGER_INFO* infoPtr, INT dir)
{
NMPGSCROLL nmpgScroll;
RECT rcWnd;
if (infoPtr->hwndChild)
{
ZeroMemory (&nmpgScroll, sizeof (NMPGSCROLL));
nmpgScroll.hdr.hwndFrom = infoPtr->hwndSelf;
nmpgScroll.hdr.idFrom = GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_ID);
nmpgScroll.hdr.code = PGN_SCROLL;
GetWindowRect(infoPtr->hwndSelf, &rcWnd);
GetClientRect(infoPtr->hwndSelf, &nmpgScroll.rcParent);
nmpgScroll.iXpos = nmpgScroll.iYpos = 0;
nmpgScroll.iDir = dir;
if (infoPtr->dwStyle & PGS_HORZ)
{
nmpgScroll.iScroll = rcWnd.right - rcWnd.left;
nmpgScroll.iXpos = infoPtr->nPos;
}
else
{
nmpgScroll.iScroll = rcWnd.bottom - rcWnd.top;
nmpgScroll.iYpos = infoPtr->nPos;
}
nmpgScroll.iScroll -= 2*infoPtr->nButtonSize;
SendMessageW (infoPtr->hwndNotify, WM_NOTIFY, nmpgScroll.hdr.idFrom, (LPARAM)&nmpgScroll);
TRACE("[%p] PGN_SCROLL returns iScroll=%d\n", infoPtr->hwndSelf, nmpgScroll.iScroll);
if (nmpgScroll.iScroll > 0)
{
infoPtr->direction = dir;
if (dir == PGF_SCROLLLEFT || dir == PGF_SCROLLUP)
PAGER_SetPos(infoPtr, infoPtr->nPos - nmpgScroll.iScroll, TRUE);
else
PAGER_SetPos(infoPtr, infoPtr->nPos + nmpgScroll.iScroll, TRUE);
}
else
infoPtr->direction = -1;
}
}
static LRESULT
PAGER_FmtLines(const PAGER_INFO *infoPtr)
{
/* initiate NCCalcSize to resize client wnd and get size */
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
SetWindowPos(infoPtr->hwndChild, 0,
0,0,infoPtr->nWidth,infoPtr->nHeight,
0);
return DefWindowProcW (infoPtr->hwndSelf, EM_FMTLINES, 0, 0);
}
static LRESULT
PAGER_Create (HWND hwnd, const CREATESTRUCTW *lpcs)
{
PAGER_INFO *infoPtr;
/* allocate memory for info structure */
infoPtr = Alloc (sizeof(PAGER_INFO));
if (!infoPtr) return -1;
SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
/* set default settings */
infoPtr->hwndSelf = hwnd;
infoPtr->hwndChild = NULL;
infoPtr->hwndNotify = lpcs->hwndParent;
infoPtr->dwStyle = lpcs->style;
infoPtr->clrBk = GetSysColor(COLOR_BTNFACE);
infoPtr->nBorder = 0;
infoPtr->nButtonSize = 12;
infoPtr->nPos = 0;
infoPtr->nWidth = 0;
infoPtr->nHeight = 0;
infoPtr->bForward = FALSE;
infoPtr->bCapture = FALSE;
infoPtr->TLbtnState = PGF_INVISIBLE;
infoPtr->BRbtnState = PGF_INVISIBLE;
infoPtr->direction = -1;
if (infoPtr->dwStyle & PGS_DRAGNDROP)
FIXME("[%p] Drag and Drop style is not implemented yet.\n", infoPtr->hwndSelf);
return 0;
}
static LRESULT
PAGER_Destroy (PAGER_INFO *infoPtr)
{
SetWindowLongPtrW (infoPtr->hwndSelf, 0, 0);
Free (infoPtr); /* free pager info data */
return 0;
}
static LRESULT
PAGER_NCCalcSize(PAGER_INFO* infoPtr, WPARAM wParam, LPRECT lpRect)
{
RECT rcChild, rcWindow;
/*
* lpRect points to a RECT struct. On entry, the struct
* contains the proposed wnd rectangle for the window.
* On exit, the struct should contain the screen
* coordinates of the corresponding window's client area.
*/
DefWindowProcW (infoPtr->hwndSelf, WM_NCCALCSIZE, wParam, (LPARAM)lpRect);
TRACE("orig rect=%s\n", wine_dbgstr_rect(lpRect));
GetWindowRect (infoPtr->hwndChild, &rcChild);
MapWindowPoints (0, infoPtr->hwndSelf, (LPPOINT)&rcChild, 2); /* FIXME: RECT != 2 POINTS */
GetWindowRect (infoPtr->hwndSelf, &rcWindow);
if (infoPtr->dwStyle & PGS_HORZ)
{
infoPtr->nWidth = lpRect->right - lpRect->left;
PAGER_CalcSize (infoPtr, &infoPtr->nWidth, TRUE);
if (infoPtr->TLbtnState && (lpRect->left + infoPtr->nButtonSize < lpRect->right))
lpRect->left += infoPtr->nButtonSize;
if (infoPtr->BRbtnState && (lpRect->right - infoPtr->nButtonSize > lpRect->left))
lpRect->right -= infoPtr->nButtonSize;
}
else
{
infoPtr->nHeight = lpRect->bottom - lpRect->top;
PAGER_CalcSize (infoPtr, &infoPtr->nHeight, FALSE);
if (infoPtr->TLbtnState && (lpRect->top + infoPtr->nButtonSize < lpRect->bottom))
lpRect->top += infoPtr->nButtonSize;
if (infoPtr->BRbtnState && (lpRect->bottom - infoPtr->nButtonSize > lpRect->top))
lpRect->bottom -= infoPtr->nButtonSize;
}
TRACE("nPos=%d, nHeight=%d, window=%s\n",
infoPtr->nPos, infoPtr->nHeight,
wine_dbgstr_rect(&rcWindow));
TRACE("[%p] client rect set to %dx%d at (%d,%d) BtnState[%d,%d]\n",
infoPtr->hwndSelf, lpRect->right-lpRect->left, lpRect->bottom-lpRect->top,
lpRect->left, lpRect->top,
infoPtr->TLbtnState, infoPtr->BRbtnState);
return 0;
}
static LRESULT
PAGER_NCPaint (const PAGER_INFO* infoPtr, HRGN hRgn)
{
RECT rcBottomRight, rcTopLeft;
HDC hdc;
if (infoPtr->dwStyle & WS_MINIMIZE)
return 0;
DefWindowProcW (infoPtr->hwndSelf, WM_NCPAINT, (WPARAM)hRgn, 0);
if (!(hdc = GetDCEx (infoPtr->hwndSelf, 0, DCX_USESTYLE | DCX_WINDOW)))
return 0;
PAGER_GetButtonRects(infoPtr, &rcTopLeft, &rcBottomRight, FALSE);
PAGER_DrawButton(hdc, infoPtr->clrBk, rcTopLeft,
infoPtr->dwStyle & PGS_HORZ, TRUE, infoPtr->TLbtnState);
PAGER_DrawButton(hdc, infoPtr->clrBk, rcBottomRight,
infoPtr->dwStyle & PGS_HORZ, FALSE, infoPtr->BRbtnState);
ReleaseDC( infoPtr->hwndSelf, hdc );
return 0;
}
static INT
PAGER_HitTest (const PAGER_INFO* infoPtr, const POINT * pt)
{
RECT clientRect, rcTopLeft, rcBottomRight;
POINT ptWindow;
GetClientRect (infoPtr->hwndSelf, &clientRect);
if (PtInRect(&clientRect, *pt))
{
TRACE("child\n");
return -1;
}
ptWindow = *pt;
PAGER_GetButtonRects(infoPtr, &rcTopLeft, &rcBottomRight, TRUE);
if ((infoPtr->TLbtnState != PGF_INVISIBLE) && PtInRect(&rcTopLeft, ptWindow))
{
TRACE("PGB_TOPORLEFT\n");
return PGB_TOPORLEFT;
}
else if ((infoPtr->BRbtnState != PGF_INVISIBLE) && PtInRect(&rcBottomRight, ptWindow))
{
TRACE("PGB_BOTTOMORRIGHT\n");
return PGB_BOTTOMORRIGHT;
}
TRACE("nowhere\n");
return -1;
}
static LRESULT
PAGER_NCHitTest (const PAGER_INFO* infoPtr, INT x, INT y)
{
POINT pt;
INT nHit;
pt.x = x;
pt.y = y;
ScreenToClient (infoPtr->hwndSelf, &pt);
nHit = PAGER_HitTest(infoPtr, &pt);
return (nHit < 0) ? HTTRANSPARENT : HTCLIENT;
}
static LRESULT
PAGER_MouseMove (PAGER_INFO* infoPtr, INT keys, INT x, INT y)
{
POINT clpt, pt;
RECT wnrect, *btnrect = NULL;
BOOL topLeft = FALSE;
INT btnstate = 0;
INT hit;
HDC hdc;
pt.x = x;
pt.y = y;
TRACE("[%p] to (%d,%d)\n", infoPtr->hwndSelf, x, y);
ClientToScreen(infoPtr->hwndSelf, &pt);
GetWindowRect(infoPtr->hwndSelf, &wnrect);
if (PtInRect(&wnrect, pt)) {
RECT TLbtnrect, BRbtnrect;
PAGER_GetButtonRects(infoPtr, &TLbtnrect, &BRbtnrect, FALSE);
clpt = pt;
MapWindowPoints(0, infoPtr->hwndSelf, &clpt, 1);
hit = PAGER_HitTest(infoPtr, &clpt);
if ((hit == PGB_TOPORLEFT) && (infoPtr->TLbtnState == PGF_NORMAL))
{
topLeft = TRUE;
btnrect = &TLbtnrect;
infoPtr->TLbtnState = PGF_HOT;
btnstate = infoPtr->TLbtnState;
}
else if ((hit == PGB_BOTTOMORRIGHT) && (infoPtr->BRbtnState == PGF_NORMAL))
{
topLeft = FALSE;
btnrect = &BRbtnrect;
infoPtr->BRbtnState = PGF_HOT;
btnstate = infoPtr->BRbtnState;
}
/* If in one of the buttons the capture and draw buttons */
if (btnrect)
{
TRACE("[%p] draw btn (%s), Capture %s, style %08x\n",
infoPtr->hwndSelf, wine_dbgstr_rect(btnrect),
(infoPtr->bCapture) ? "TRUE" : "FALSE",
infoPtr->dwStyle);
if (!infoPtr->bCapture)
{
TRACE("[%p] SetCapture\n", infoPtr->hwndSelf);
SetCapture(infoPtr->hwndSelf);
infoPtr->bCapture = TRUE;
}
if (infoPtr->dwStyle & PGS_AUTOSCROLL)
SetTimer(infoPtr->hwndSelf, TIMERID1, 0x3e, 0);
hdc = GetWindowDC(infoPtr->hwndSelf);
/* OffsetRect(wnrect, 0 | 1, 0 | 1) */
PAGER_DrawButton(hdc, infoPtr->clrBk, *btnrect,
infoPtr->dwStyle & PGS_HORZ, topLeft, btnstate);
ReleaseDC(infoPtr->hwndSelf, hdc);
return 0;
}
}
/* If we think we are captured, then do release */
if (infoPtr->bCapture && (WindowFromPoint(pt) != infoPtr->hwndSelf))
{
NMHDR nmhdr;
infoPtr->bCapture = FALSE;
if (GetCapture() == infoPtr->hwndSelf)
{
ReleaseCapture();
if (infoPtr->TLbtnState == PGF_GRAYED)
{
infoPtr->TLbtnState = PGF_INVISIBLE;
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
}
else if (infoPtr->TLbtnState == PGF_HOT)
{
infoPtr->TLbtnState = PGF_NORMAL;
/* FIXME: just invalidate button rect */
RedrawWindow(infoPtr->hwndSelf, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
if (infoPtr->BRbtnState == PGF_GRAYED)
{
infoPtr->BRbtnState = PGF_INVISIBLE;
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
}
else if (infoPtr->BRbtnState == PGF_HOT)
{
infoPtr->BRbtnState = PGF_NORMAL;
/* FIXME: just invalidate button rect */
RedrawWindow(infoPtr->hwndSelf, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
/* Notify parent of released mouse capture */
memset(&nmhdr, 0, sizeof(NMHDR));
nmhdr.hwndFrom = infoPtr->hwndSelf;
nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
nmhdr.code = NM_RELEASEDCAPTURE;
SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
}
if (IsWindow(infoPtr->hwndSelf))
KillTimer(infoPtr->hwndSelf, TIMERID1);
}
return 0;
}
static LRESULT
PAGER_LButtonDown (PAGER_INFO* infoPtr, INT keys, INT x, INT y)
{
BOOL repaintBtns = FALSE;
POINT pt;
INT hit;
pt.x = x;
pt.y = y;
TRACE("[%p] at (%d,%d)\n", infoPtr->hwndSelf, x, y);
hit = PAGER_HitTest(infoPtr, &pt);
/* put btn in DEPRESSED state */
if (hit == PGB_TOPORLEFT)
{
repaintBtns = infoPtr->TLbtnState != PGF_DEPRESSED;
infoPtr->TLbtnState = PGF_DEPRESSED;
SetTimer(infoPtr->hwndSelf, TIMERID1, INITIAL_DELAY, 0);
}
else if (hit == PGB_BOTTOMORRIGHT)
{
repaintBtns = infoPtr->BRbtnState != PGF_DEPRESSED;
infoPtr->BRbtnState = PGF_DEPRESSED;
SetTimer(infoPtr->hwndSelf, TIMERID1, INITIAL_DELAY, 0);
}
if (repaintBtns)
SendMessageW(infoPtr->hwndSelf, WM_NCPAINT, 0, 0);
switch(hit)
{
case PGB_TOPORLEFT:
if (infoPtr->dwStyle & PGS_HORZ)
{
TRACE("[%p] PGF_SCROLLLEFT\n", infoPtr->hwndSelf);
PAGER_Scroll(infoPtr, PGF_SCROLLLEFT);
}
else
{
TRACE("[%p] PGF_SCROLLUP\n", infoPtr->hwndSelf);
PAGER_Scroll(infoPtr, PGF_SCROLLUP);
}
break;
case PGB_BOTTOMORRIGHT:
if (infoPtr->dwStyle & PGS_HORZ)
{
TRACE("[%p] PGF_SCROLLRIGHT\n", infoPtr->hwndSelf);
PAGER_Scroll(infoPtr, PGF_SCROLLRIGHT);
}
else
{
TRACE("[%p] PGF_SCROLLDOWN\n", infoPtr->hwndSelf);
PAGER_Scroll(infoPtr, PGF_SCROLLDOWN);
}
break;
default:
break;
}
return 0;
}
static LRESULT
PAGER_LButtonUp (PAGER_INFO* infoPtr, INT keys, INT x, INT y)
{
TRACE("[%p]\n", infoPtr->hwndSelf);
KillTimer (infoPtr->hwndSelf, TIMERID1);
KillTimer (infoPtr->hwndSelf, TIMERID2);
/* make PRESSED btns NORMAL but don't hide gray btns */
if (infoPtr->TLbtnState & (PGF_HOT | PGF_DEPRESSED))
infoPtr->TLbtnState = PGF_NORMAL;
if (infoPtr->BRbtnState & (PGF_HOT | PGF_DEPRESSED))
infoPtr->BRbtnState = PGF_NORMAL;
return 0;
}
static LRESULT
PAGER_Timer (PAGER_INFO* infoPtr, INT nTimerId)
{
INT dir;
/* if initial timer, kill it and start the repeat timer */
if (nTimerId == TIMERID1) {
if (infoPtr->TLbtnState == PGF_HOT)
dir = (infoPtr->dwStyle & PGS_HORZ) ?
PGF_SCROLLLEFT : PGF_SCROLLUP;
else
dir = (infoPtr->dwStyle & PGS_HORZ) ?
PGF_SCROLLRIGHT : PGF_SCROLLDOWN;
TRACE("[%p] TIMERID1: style=%08x, dir=%d\n",
infoPtr->hwndSelf, infoPtr->dwStyle, dir);
KillTimer(infoPtr->hwndSelf, TIMERID1);
SetTimer(infoPtr->hwndSelf, TIMERID1, REPEAT_DELAY, 0);
if (infoPtr->dwStyle & PGS_AUTOSCROLL) {
PAGER_Scroll(infoPtr, dir);
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
}
return 0;
}
TRACE("[%p] TIMERID2: dir=%d\n", infoPtr->hwndSelf, infoPtr->direction);
KillTimer(infoPtr->hwndSelf, TIMERID2);
if (infoPtr->direction > 0) {
PAGER_Scroll(infoPtr, infoPtr->direction);
SetTimer(infoPtr->hwndSelf, TIMERID2, REPEAT_DELAY, 0);
}
return 0;
}
static LRESULT
PAGER_EraseBackground (const PAGER_INFO* infoPtr, HDC hdc)
{
POINT pt, ptorig;
HWND parent;
pt.x = 0;
pt.y = 0;
parent = GetParent(infoPtr->hwndSelf);
MapWindowPoints(infoPtr->hwndSelf, parent, &pt, 1);
OffsetWindowOrgEx (hdc, pt.x, pt.y, &ptorig);
SendMessageW (parent, WM_ERASEBKGND, (WPARAM)hdc, 0);
SetWindowOrgEx (hdc, ptorig.x, ptorig.y, 0);
return 0;
}
static LRESULT
PAGER_Size (PAGER_INFO* infoPtr, INT type, INT x, INT y)
{
/* note that WM_SIZE is sent whenever NCCalcSize resizes the client wnd */
TRACE("[%p] %d,%d\n", infoPtr->hwndSelf, x, y);
if (infoPtr->dwStyle & PGS_HORZ)
infoPtr->nHeight = y;
else
infoPtr->nWidth = x;
return PAGER_RecalcSize(infoPtr);
}
static LRESULT
PAGER_StyleChanged(PAGER_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
{
DWORD oldStyle = infoPtr->dwStyle;
TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
wStyleType, lpss->styleOld, lpss->styleNew);
if (wStyleType != GWL_STYLE) return 0;
infoPtr->dwStyle = lpss->styleNew;
if ((oldStyle ^ lpss->styleNew) & (PGS_HORZ | PGS_VERT))
{
PAGER_RecalcSize(infoPtr);
}
return 0;
}
static LRESULT WINAPI
PAGER_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PAGER_INFO *infoPtr = (PAGER_INFO *)GetWindowLongPtrW(hwnd, 0);
if (!infoPtr && (uMsg != WM_CREATE))
return DefWindowProcW (hwnd, uMsg, wParam, lParam);
switch (uMsg)
{
case EM_FMTLINES:
return PAGER_FmtLines(infoPtr);
case PGM_FORWARDMOUSE:
return PAGER_ForwardMouse (infoPtr, (BOOL)wParam);
case PGM_GETBKCOLOR:
return PAGER_GetBkColor(infoPtr);
case PGM_GETBORDER:
return PAGER_GetBorder(infoPtr);
case PGM_GETBUTTONSIZE:
return PAGER_GetButtonSize(infoPtr);
case PGM_GETPOS:
return PAGER_GetPos(infoPtr);
case PGM_GETBUTTONSTATE:
return PAGER_GetButtonState (infoPtr, (INT)lParam);
/* case PGM_GETDROPTARGET: */
case PGM_RECALCSIZE:
return PAGER_RecalcSize(infoPtr);
case PGM_SETBKCOLOR:
return PAGER_SetBkColor (infoPtr, (COLORREF)lParam);
case PGM_SETBORDER:
return PAGER_SetBorder (infoPtr, (INT)lParam);
case PGM_SETBUTTONSIZE:
return PAGER_SetButtonSize (infoPtr, (INT)lParam);
case PGM_SETCHILD:
return PAGER_SetChild (infoPtr, (HWND)lParam);
case PGM_SETPOS:
return PAGER_SetPos(infoPtr, (INT)lParam, FALSE);
case WM_CREATE:
return PAGER_Create (hwnd, (LPCREATESTRUCTW)lParam);
case WM_DESTROY:
return PAGER_Destroy (infoPtr);
case WM_SIZE:
return PAGER_Size (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
case WM_NCPAINT:
return PAGER_NCPaint (infoPtr, (HRGN)wParam);
case WM_WINDOWPOSCHANGING:
return PAGER_WindowPosChanging (infoPtr, (WINDOWPOS*)lParam);
case WM_STYLECHANGED:
return PAGER_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
case WM_NCCALCSIZE:
return PAGER_NCCalcSize (infoPtr, wParam, (LPRECT)lParam);
case WM_NCHITTEST:
return PAGER_NCHitTest (infoPtr, (short)LOWORD(lParam), (short)HIWORD(lParam));
case WM_MOUSEMOVE:
if (infoPtr->bForward && infoPtr->hwndChild)
PostMessageW(infoPtr->hwndChild, WM_MOUSEMOVE, wParam, lParam);
return PAGER_MouseMove (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
case WM_LBUTTONDOWN:
return PAGER_LButtonDown (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
case WM_LBUTTONUP:
return PAGER_LButtonUp (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
case WM_ERASEBKGND:
return PAGER_EraseBackground (infoPtr, (HDC)wParam);
case WM_TIMER:
return PAGER_Timer (infoPtr, (INT)wParam);
case WM_NOTIFY:
case WM_COMMAND:
return SendMessageW (infoPtr->hwndNotify, uMsg, wParam, lParam);
default:
return DefWindowProcW (hwnd, uMsg, wParam, lParam);
}
}
VOID
PAGER_Register (void)
{
WNDCLASSW wndClass;
ZeroMemory (&wndClass, sizeof(WNDCLASSW));
wndClass.style = CS_GLOBALCLASS;
wndClass.lpfnWndProc = PAGER_WindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = sizeof(PAGER_INFO *);
wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
wndClass.lpszClassName = WC_PAGESCROLLERW;
RegisterClassW (&wndClass);
}
VOID
PAGER_Unregister (void)
{
UnregisterClassW (WC_PAGESCROLLERW, NULL);
}
Reference in New Issue View Git Blame Copy Permalink