А. Легалов - Применение Windows API

public:

Controller(HWND hwnd, CREATESTRUCT* pCreate);

~Controller();

void Timer(int id);

void Size(int x, int y);

void Paint();

void Command(int cmd);

private:

HWND _hwnd;

WinTimer _timer;

View _view;

};

Controller::Controller(HWND hwnd, CREATESTRUCT * pCreate) : _hwnd (hwnd), _timer (hwnd, 1), _view(pCreate->hInstance) {

_timer.Set (100);

}

Once set, the timer sends our program timer messages and we have to process them.

LRESULT CALLBACK MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {

Controller* pCtrl = WinGetLong(hwnd);

switch (message) {

...

case WM_TIMER:

pCtrl->Timer(wParam);

return 0;

...

}

return ::DefWindowProc(hwnd, message, wParam, lParam);

}

void Controller::Timer(int id) {

_timer.Kill();

_view.Step();

UpdateCanvas canvas(_hwnd);

_view.Update(canvas);

:: InvalidateRect(_hwnd, 0, FALSE);

_timer.Set(50);

}

void Controller::Paint() {

PaintCanvas canvas(_hwnd);

_view.Paint(canvas);

}

The Update method of View is the workhorse of our program. It creates the image in the buffer. We then call InvalidateRectangleto force the repaint of our window (the last parameter, FALSE, tells Windows not to clear the previous image — we don't want it to flash white before every frame).

Here's the class View, with the three bitmaps.

class View {

public:

View(HINSTANCE hInst);

void SetSize(int cxNew, int cyNew) {

_cx = cxNew;

_cy = cyNew;

}

void Step() { ++_tick; }

void Update(Canvas& canvas);

void Paint(Canvas& canvas);

private:

int _cx, _cy;

int _tick;

Bitmap _bitmapBuf; // for double buffering

Bitmap _background;

int _widthBkg, _heightBkg;

Bitmap _sprite;

Bitmap _mask;

int _widthSprite, _heightSprite;

};

View::View(HINSTANCE hInst) : _tick (0) {

// Load bitmap from file

_background.Load("picture.bmp");

// Load bitmap from resource

_background.GetSize(_widthBkg, _heightBkg);

// Load bitmaps from resources

_sprite.Load(hInst, IDB_FANNY);

_mask.Load(hInst, IDB_MASK);

_sprite.GetSize(_widthSprite, _heightSprite);

DesktopCanvas canvas;

_bitmapBuf.CreateCompatible(canvas, 1, 1);

_cx = 1;

_cy = 1;

}

And here's the implementation of Update. We create a bitmap canvas in memory, making it compatible with the current display canvas. We blit the background image into it, then blit the mask and the sprite (notice the change of position for each frame). Finally, we transfer the complete bitmap into our buffer (overloaded assignment operator at work!).

void View::Update(Canvas& canvas) {

const double speed = 0.01;

Bitmap bmp(canvas, _cx, _cy);

BitmapCanvas bmpCanvas(canvas, bmp);

RECT rect = { 0, 0, _cx, _cy };

bmpCanvas.WhiteWash(rect);

// Do the off-line drawing

Blitter bltBkg(_background);

bltBkg.BlitTo(bmpCanvas);

int xRange = (_widthBkg - _widthSprite) / 2;

int yRange = (_heightBkg - _heightSprite) / 2;

int x = xRange + static_cast(xRange * sin(speed * _tick));

int y = yRange + static_cast(yRange * cos(4 * speed * _tick));

Blitter bltMask(_mask);

bltMask.SetMode(SRCPAINT);

bltMask.SetDest(x, y);

bltMask.BlitTo(bmpCanvas);

Blitter bltSprite(_sprite);

bltSprite.SetMode(SRCAND);

bltSprite.SetDest(x, y);

bltSprite.BlitTo(bmpCanvas);

// update the buffer

_bitmapBuf = bmp;

}

For completeness, here's the definition of bitmap canvas. You draw directly on this canvas using standard canvas methods, like Line, Text, SetPixel, etc... Here we only blit bitmaps into it.

class BitmapCanvas: public MemCanvas{

public:

BitmapCanvas(HDC hdc, HBITMAP hBitmap) : MemCanvas(hdc) {

// convert bitmap to format compatible with canvas

_hOldBitmap = reinterpret_cast(:: SelectObject(_hdc, hBitmap));

}

~BitmapCanvas() {

:: SelectObject(_hdc, _hOldBitmap);

}

private:

HBITMAP _hOldBitmap;

};

class MemCanvas: public Canvas{

public:

MemCanvas(HDC hdc) : Canvas(:: CreateCompatibleDC(hdc)) {}

~MemCanvas() {

:: DeleteDC(_hdc);

}

};

Now, if you want more speed, read about DirectDraw.

Имеется превосходная статья Элен Ульман (Ellen Ullman), которае должна быть рекомендована для чтения каждому, кто все еще чувствует позывы к использованию MFC или OWL. Она доступно интерактивно:

Часть 1

Часть 2

или, в печатном виде, в августовском издании журнала Харпера за 1998 год. Предлагаем Вам несколько цитат:

"… В этом мире программирования, написание моего кода перемещалось с акцента на задачу, в сторону становления набором придатков к архитектуре системы, выстроенной Microsoft."