Is it necessary to use ScrollWindowEx/ScrollWindow/ScrollDC for scrolling? - c++

Question

I am in the process of implementing scrolling in a custom edit control that I have been working on. What I was wondering was, is it essential to use ScrollWindowEx/ScrollWindow/ScrollDC to implement scrolling? I see that ScrollWindowEx just scrolls the paint area. All that is fine, but since my edit control implements double buffering, I'd have to update my BitBlt as well. That is a trivial thing, but I was wondering if it is essential. If I use only SetScrollInfo, that would also have the same effect. The only advantage that I see here is that when a user scrolls up or down, there would already be some text over there(because ScrollWindowEx shifts the target client area) and I wouldn't have to bother aobut repainting. Is there any other advantage, or reason why ScrollWindowEx is used? I am new to scrolling in win32, and this is actually the first time I've had to do all the processing on my own instead of the api doing it for me, so I really don't know how to go about this.
P.S.
Just to be clear, I'm not using MFC. Only Win32 api.
Programming Language : unmanaged C++

Answer 1

You can implement scrolling any way you want.
ScrollWindow etc will scroll the relevant part of the client area and invalidate the part that then needs repainting.
In general this is an efficient and simple way to handle scrolling, so obviously it's popular. But if you can show that in your case you can achieve the same result more efficiently, go for it.

Answer 2

An example for comparison can be found in ScrollCall.
Also, there's an interesting example in C of using ScrollDC to scroll a screen here
In that example, lprcScroll and lprcClip refer to the same RECT, which delineates the painted output rectangle from the scrolling.
The painted output from ScrollDC can be handled by a routine in WM_PAINT, so long as the call is followed by InvalidateRect. However, unlike ScrollWindow(Ex), ScrollDC doesn't care about any owned/child/parent/sibling windows which may be overlaid in the DC, it is more suited to images or text in single controls. For scrolling a large DC, be sure to use lprcScroll and lprcClip to avoid scrolling areas of the DC which are not visible.
As mentioned, ScrollWindoW(Ex) is the preferred choice, especially for windows with mixed control content.
Included for further illustration is an amazingly venerable implementation of all the three functions copied from here:
* Scroll windows and DCs
*
* Copyright David W. Metcalfe, 1993
*
*/
static char Copyright[] = "Copyright David W. Metcalfe, 1993";
#include <stdlib.h>
#include "windows.h"
#include "gdi.h"
#include "stddebug.h"
/* #define DEBUG_SCROLL /* */
/* #undef DEBUG_SCROLL /* */
#include "debug.h"
static int RgnType;
/*************************************************************************
* ScrollWindow (USER.61)
*/
void ScrollWindow(HWND hwnd, short dx, short dy, LPRECT rect, LPRECT clipRect)
{
HDC hdc;
HRGN hrgnUpdate;
RECT rc, cliprc;
dprintf_scroll(stddeb,"ScrollWindow: dx=%d, dy=%d, rect=%d,%d,%d,%d\n",
dx, dy, rect->left, rect->top, rect->right, rect->bottom);
hdc = GetDC(hwnd);
if (rect == NULL)
GetClientRect(hwnd, &rc);
else
CopyRect(&rc, rect);
if (clipRect == NULL)
GetClientRect(hwnd, &cliprc);
else
CopyRect(&cliprc, clipRect);
hrgnUpdate = CreateRectRgn(0, 0, 0, 0);
ScrollDC(hdc, dx, dy, &rc, &cliprc, hrgnUpdate, NULL);
InvalidateRgn(hwnd, hrgnUpdate, TRUE);
ReleaseDC(hwnd, hdc);
}
/*************************************************************************
* ScrollDC (USER.221)
*/
BOOL ScrollDC(HDC hdc, short dx, short dy, LPRECT rc, LPRECT cliprc,
HRGN hrgnUpdate, LPRECT rcUpdate)
{
HRGN hrgnClip, hrgn1, hrgn2;
POINT src, dest;
short width, height;
DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
dprintf_scroll(stddeb, "ScrollDC: dx=%d, dy=%d, rc=%d,%d,%d,%d\n", dx, dy,
rc->left, rc->top, rc->right, rc->bottom);
if (rc == NULL)
return FALSE;
if (cliprc)
{
hrgnClip = CreateRectRgnIndirect(cliprc);
SelectClipRgn(hdc, hrgnClip);
}
if (dx > 0)
{
src.x = XDPTOLP(dc, rc->left);
dest.x = XDPTOLP(dc, rc->left + abs(dx));
}
else
{
src.x = XDPTOLP(dc, rc->left + abs(dx));
dest.x = XDPTOLP(dc, rc->left);
}
if (dy > 0)
{
src.y = YDPTOLP(dc, rc->top);
dest.y = YDPTOLP(dc, rc->top + abs(dy));
}
else
{
src.y = YDPTOLP(dc, rc->top + abs(dy));
dest.y = YDPTOLP(dc, rc->top);
}
width = rc->right - rc->left - abs(dx);
height = rc->bottom - rc->top - abs(dy);
if (!BitBlt(hdc, dest.x, dest.y, width, height, hdc, src.x, src.y,
SRCCOPY))
return FALSE;
if (hrgnUpdate)
{
if (dx > 0)
hrgn1 = CreateRectRgn(rc->left, rc->top, rc->left+dx, rc->bottom);
else if (dx < 0)
hrgn1 = CreateRectRgn(rc->right+dx, rc->top, rc->right,
rc->bottom);
else
hrgn1 = CreateRectRgn(0, 0, 0, 0);
if (dy > 0)
hrgn2 = CreateRectRgn(rc->left, rc->top, rc->right, rc->top+dy);
else if (dy < 0)
hrgn2 = CreateRectRgn(rc->left, rc->bottom+dy, rc->right,
rc->bottom);
else
hrgn2 = CreateRectRgn(0, 0, 0, 0);
RgnType = CombineRgn(hrgnUpdate, hrgn1, hrgn2, RGN_OR);
}
if (rcUpdate) GetRgnBox( hrgnUpdate, rcUpdate );
return TRUE;
}
/*************************************************************************
* ScrollWindowEx (USER.319)
*/
int ScrollWindowEx(HWND hwnd, short dx, short dy, LPRECT rect, LPRECT clipRect,
HRGN hrgnUpdate, LPRECT rcUpdate, WORD flags)
{
HDC hdc;
RECT rc, cliprc;
dprintf_scroll(stddeb,"ScrollWindowEx: dx=%d, dy=%d, rect=%d,%d,%d,%d\n",
dx, dy, rect->left, rect->top, rect->right, rect->bottom);
hdc = GetDC(hwnd);
if (rect == NULL)
GetClientRect(hwnd, &rc);
else
CopyRect(&rc, rect);
if (clipRect == NULL)
GetClientRect(hwnd, &cliprc);
else
CopyRect(&cliprc, clipRect);
ScrollDC(hdc, dx, dy, &rc, &cliprc, hrgnUpdate, rcUpdate);
if (flags | SW_INVALIDATE)
{
RedrawWindow(hwnd, NULL, hrgnUpdate,
RDW_INVALIDATE | ((flags & SW_ERASE) ? RDW_ERASENOW : 0));
}
ReleaseDC(hwnd, hdc);
return RgnType;
}