Example of Scrolling a Bitmap - Win32 Programmer's Reference

Custom Search

Example of Scrolling a Bitmap

The following example enables the user to capture the screen content into a bitmap and scroll the bitmap in the client area.

HDC hdc;

PAINTSTRUCT ps;

SCROLLINFO si;

/* These variables are required by BitBlt. */

static HDC hdcWin; /* window DC */

static HDC hdcScreen; /* DC for entire screen */

static HDC hdcScreenCompat; /* memory DC for screen */

static HBITMAP hbmpCompat; /* bitmap handle for old DC */

static BITMAP bmp; /* bitmap data structure */

static BOOL fBlt; /* TRUE if BitBlt occurred */

static BOOL fScroll; /* TRUE if scrolling occurred */

static BOOL fSize; /* TRUE if fBlt & WM_SIZE */

/* These variables are required for horizontal scrolling. */

static int xMinScroll; /* minimum horizontal scroll value */

static int xCurrentScroll; /* current horizontal scroll value */

static int xMaxScroll; /* maximum horizontal scroll value */

/* These variables are required for vertical scrolling. */

static int yMinScroll; /* minimum vertical scroll value */

static int yCurrentScroll; /* current vertical scroll value */

static int yMaxScroll; /* maximum vertical scroll value */

switch (uMsg) {

case WM_CREATE:

* Create a normal DC and a memory DC for the entire

* screen. The normal DC provides a snapshot of the

* screen contents. The memory DC keeps a copy of this

* snapshot in the associated bitmap.

hdcScreen = CreateDC("DISPLAY", (LPCSTR) NULL,

(LPCSTR) NULL, (CONST DEVMODE *) NULL);

hdcScreenCompat = CreateCompatibleDC(hdcScreen);

* Retrieve the metrics for the bitmap associated with the

* regular device context.

bmp.bmBitsPixel =

(BYTE) GetDeviceCaps(hdcScreen, BITSPIXEL);

bmp.bmPlanes = (BYTE) GetDeviceCaps(hdcScreen, PLANES);

bmp.bmWidth = GetDeviceCaps(hdcScreen, HORZRES);

bmp.bmHeight = GetDeviceCaps(hdcScreen, VERTRES);

/* The width must be byte-aligned. */

bmp.bmWidthBytes = ((bmp.bmWidth + 15) &~15)/8;

/* Create a bitmap for the compatible DC. */

hbmpCompat = CreateBitmap(bmp.bmWidth, bmp.bmHeight,

bmp.bmPlanes, bmp.bmBitsPixel, (CONST VOID *) NULL);

/* Select the bitmap for the compatible DC. */

SelectObject(hdcScreenCompat, hbmpCompat);

/* Initialize the flags. */

fBlt = FALSE;

fScroll = FALSE;

fSize = FALSE;

/* Initialize the horizontal scrolling variables. */

xMinScroll = 0;

xCurrentScroll = 0;

xMaxScroll = 0;

/* Initialize the vertical scrolling variables. */

yMinScroll = 0;

yCurrentScroll = 0;

yMaxScroll = 0;

break;

case WM_SIZE: {

int xNewSize;

int yNewSize;

xNewSize = LOWORD(lParam);

yNewSize = HIWORD(lParam);

if (fBlt)

fSize = TRUE;

* The horizontal scrolling range is defined by

* (bitmap_width) - (client_width). The current horizontal

* scroll value remains within the horizontal scrolling range.

xMaxScroll = max(bmp.bmWidth-xNewSize, 0);

xCurrentScroll = min(xCurrentScroll, xMaxScroll);

si.cbSize = sizeof(si);

si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;

si.nMin = xMinScroll;

si.nMax = xMaxScroll;

si.nPage = xNewSize;

si.nPos = xCurrentScroll;

SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);

* The vertical scrolling range is defined by

* (bitmap_height) - (client_height). The current vertical

* scroll value remains within the vertical scrolling range.

yMaxScroll = max(bmp.bmHeight - yNewSize, 0);

yCurrentScroll = min(yCurrentScroll, yMaxScroll);

si.cbSize = sizeof(si);

si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;

si.nMin = yMinScroll;

si.nMax = yMaxScroll;

si.nPage = yNewSize;

si.nPos = yCurrentScroll;

SetScrollInfo(hwnd, SB_VERT, &si, TRUE);

}

break;

case WM_PAINT: {

PRECT prect;

hdc = BeginPaint(hwnd, &ps);

* If the window has been resized and the user has

* captured the screen, use the following call to

* BitBlt to paint the window's client area.

if (fSize) {

BitBlt(ps.hdc,

0, 0,

bmp.bmWidth, bmp.bmHeight,

hdcScreenCompat,

xCurrentScroll, yCurrentScroll,

SRCCOPY);

fSize = FALSE;

}

* If scrolling has occurred, use the following call to

* BitBlt to paint the invalid rectangle.

* The coordinates of this rectangle are specified in the

* RECT structure to which prect points.

* Note that it is necessary to increment the seventh

* argument (prect->left) by xCurrentScroll and the

* eighth argument (prect->top) by yCurrentScroll in

* order to map the correct pixels from the source bitmap.

if (fScroll) {

prect = &ps.rcPaint;

BitBlt(ps.hdc,

prect->left, prect->top,

(prect->right - prect->left),

(prect->bottom - prect->top),

hdcScreenCompat,

prect->left + xCurrentScroll,

prect->top + yCurrentScroll,

SRCCOPY);

fScroll = FALSE;

}

EndPaint(hwnd, &ps);

}

break;

case WM_HSCROLL: {

int xDelta; /* xDelta = new_pos - current_pos */

int xNewPos; /* new position */

int yDelta = 0;

switch (LOWORD(wParam)) {

/* User clicked the shaft left of the scroll box. */

case SB_PAGEUP:

xNewPos = xCurrentScroll - 50;

break;

/* User clicked the shaft right of the scroll box. */

case SB_PAGEDOWN:

xNewPos = xCurrentScroll + 50;

break;

/* User clicked the left arrow. */

case SB_LINEUP:

xNewPos = xCurrentScroll - 5;

break;

/* User clicked the right arrow. */

case SB_LINEDOWN:

xNewPos = xCurrentScroll + 5;

break;

/* User dragged the scroll box. */

case SB_THUMBPOSITION:

xNewPos = HIWORD(wParam);

break;

default:

xNewPos = xCurrentScroll;

}

/* New position must be between 0 and the screen width. */

xNewPos = max(0, xNewPos);

xNewPos = min(xMaxScroll, xNewPos);

/* If the current position does not change, do not scroll.*/

if (xNewPos == xCurrentScroll)

break;

/* Set the scroll flag to TRUE. */

fScroll = TRUE;

/* Determine the amount scrolled (in pixels). */

xDelta = xNewPos - xCurrentScroll;

/* Reset the current scroll position. */

xCurrentScroll = xNewPos;

* Scroll the window. (The system repaints most of the

* client area when ScrollWindowEx is called; however, it is

* necessary to call UpdateWindow in order to repaint the

* rectangle of pixels that were invalidated.)

ScrollWindowEx(hwnd, -xDelta, -yDelta, (CONST RECT *) NULL,

(CONST RECT *) NULL, (HRGN) NULL, (LPRECT) NULL,

SW_INVALIDATE);

UpdateWindow(hwnd);

/* Reset the scroll bar. */

si.cbSize = sizeof(si);

si.fMask = SIF_POS;

si.nPos = xCurrentScroll;

SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);

}

break;

case WM_VSCROLL: {

int xDelta = 0;

int yDelta; /* yDelta = new_pos - current_pos */

int yNewPos; /* new position */

switch (LOWORD(wParam)) {

/* User clicked the shaft above the scroll box. */

case SB_PAGEUP:

yNewPos = yCurrentScroll - 50;

break;

/* User clicked the shaft below the scroll box. */

case SB_PAGEDOWN:

yNewPos = yCurrentScroll + 50;

break;

/* User clicked the top arrow. */

case SB_LINEUP:

yNewPos = yCurrentScroll - 5;

break;

/* User clicked the bottom arrow. */

case SB_LINEDOWN:

yNewPos = yCurrentScroll + 5;

break;

/* User dragged the scroll box. */

case SB_THUMBPOSITION:

yNewPos = HIWORD(wParam);

break;

default:

yNewPos = yCurrentScroll;

}

/* New position must be between 0 and the screen height. */

yNewPos = max(0, yNewPos);

yNewPos = min(yMaxScroll, yNewPos);

/* If the current position does not change, do not scroll.*/

if (yNewPos == yCurrentScroll)

break;

/* Set the scroll flag to TRUE. */

fScroll = TRUE;

/* Determine the amount scrolled (in pixels). */

yDelta = yNewPos - yCurrentScroll;

/* Reset the current scroll position. */

yCurrentScroll = yNewPos;

* Scroll the window. (The system repaints most of the

* client area when ScrollWindowEx is called; however, it is

* necessary to call UpdateWindow in order to repaint the

* rectangle of pixels that were invalidated.)

ScrollWindowEx(hwnd, -xDelta, -yDelta, (CONST RECT *) NULL,

(CONST RECT *) NULL, (HRGN) NULL, (LPRECT) NULL,

SW_INVALIDATE);

UpdateWindow(hwnd);

/* Reset the scroll bar. */

si.cbSize = sizeof(si);

si.fMask = SIF_POS;

si.nPos = yCurrentScroll;

SetScrollInfo(hwnd, SB_VERT, &si, TRUE);

}

break;

case WM_COMMAND: /* uMsg: command from app. menu */

switch(wParam) {

case IDM_STC:

* Copy the contents of the current screen

* into the compatible DC.

BitBlt(hdcScreenCompat, 0, 0, bmp.bmWidth,

bmp.bmHeight, hdcScreen, 0, 0, SRCCOPY);

* Copy the compatible DC to the client area.

hdcWin = GetDC(hwnd);

BitBlt(hdcWin, 0, 0, bmp.bmWidth, bmp.bmHeight,

hdcScreenCompat, 0, 0, SRCCOPY);

ReleaseDC(hwnd, hdcWin);

fBlt = TRUE;

break;

default:

return (DefWindowProc(hwnd, uMsg,

wParam, lParam));

}

break;

Last news from Greatis Software

    Nostalgia .Net     .Net is powerful, but not all-powerful, so sometimes we need to use Win32 API for our .Net applications. It's simple enough with Platform Invoke if you have Win32 skill, but we do not always have time to dig the ancient documentation, declare the special types that are compatible with Win32, find the values of the Win32's constants and so on. Nostalgia .Net offers several simple-to-use classes, and components that will allow you to forget about the headache of Win32 and just use the power of Win32 in your application the same way as you use the native. Net classes. More »

Recommended software for developers

    Ultimate Pack     Component pack for Delphi and C++ Builder that contains runtime form designer, runtime object inspector, print suite and much more for the very special price. More »

    Form Designer .Net     Unique runtime form design solution that allows to edit any form in .Net WinForms application at runtime with full source codes for only 300 euro! More »

    Print Suite .Net     Print Suite .Net is a set of components for easy printing texts, images and grids from your WinForms applications. Full C# source codes are available More »

    Gradient Controls .Net     Gradient Controls .Net offers controls with gradient background feature. Labels, panels and so on... Full C# source codes are available More »

    Greatis iGrid     iGrid plots drawing grid right over your desktop, so you can use it everywhere, with any drawing application without any special plugins for different graphic editors. More »

All the contacts and projects

Dmitry Vasiliev (just.dmitry)

More Online Helps

Win32 Programmer's Reference
Win32 Multimedia Programmer's Reference
OLE Programmer's Reference
Microsoft Windows Pen API Programmer's Reference
Microsoft Windows Sockets 2 Reference
Microsoft Windows Telephony API (TAPI) Programmer's Reference
Unix Manual Pages

greatis just4fun network