Перья и кисти внутри классов
Рисование перьями и раскрашивание кистями
Перевод А. И. Легалова
Англоязычный оригинал находится на сервере компании Reliable Software
Подобно живописцу, Вы нуждаетесь в перьях и кистях, чтобы создать шедевр на вашем холсте. Когда Вы вызываете метод Canvas::Line или Canvas::Rectangle, Windows использует текущие установки пера, чтобы рисовать линии, и текущие установки кисти, чтобы заполнять охватываемые контуры.
Когда объект сопоставляется с Холстом, нельзя забывать освободить его после окончания работы. Это надо делать до тех пор, пока вы не обеспечите такой возможностью вашу программу на языке C++. Используйте только локальные объекты, чьи конструкторы присоединяют, а деструкторы (вызываемые автоматически, при выходе области действия) освобождают объекты (см. страницу «Управление ресурсами» для более детального знакомства с этой методологией). Обратите внимание, что ниже следующие объекты используют HDC (дескрипторы контекстов устройств) в качестве параметры в их конструкторах. Однако, взамен этого, Вы должны просто передать им объект Canvas. Помните, что «Холст» может автоматически приводиться к HDC.
class StockObject {
public:
StockObject(HDC hdc, int type) : _hdc(hdc) {
_hObjOld = SelectObject(_hdc, GetStockObject(type));
}
~StockObject () {
SelectObject(_hdc, _hObjOld);
}
private:
HGDIOBJ _hObjOld;
HDC _hdc;
};
Windows имеет набор предопределенных перьев и кистей. Если Вы хотите использовать их, то достаточно присоединить выбранные перья и кисти к вашему холсту не некоторое время.
class WhitePen : public StockObject {
public:
WhitePen(HDC hdc): StockObject(hdc, WHITE_PEN) {}
};
// example
void Controller::Paint(HWND hwnd) {
PaintCanvas canvas(hwnd);
WhitePen pen(canvas);
canvas.Line(0, 10, 100, 10);
// destructor of WhitePen
// destructor of PaintCanvas
}
Если ваша программа поддерживает использование несколько перьев, отсутствующих в Windows, Вы можете предварительно создать их (например, внедрив их в объект View) и использовать объект PenHolder, для временного присоединения к Холсту.
class Pen {
public:
Pen(COLORREF color) {
_hPen = CreatePen(PS_SOLID, 0, color);
}
~Pen() {
DeleteObject(_hpen);
}
operator HPEN() {
return _hPen;
}
private:
HPEN _hPen;
};
class PenHolder {
public:
PenHolder(HDC hdc, HPEN hPen) : _hdc (hdc) {
_hPenOld = (HPEN)SelectObject (_hdc, hPen);
}
~PenHolder() {
SelectObject(_hdc, _hPenOld);
}
private:
HDC _hdc;
HPEN _hPenOld;
};
class View {
public:
View() : _penGreen (RGB (0, 255, 128)) {}
void Paint(Canvas& canvas) {
PenHolder holder(canvas, _penGreen);
canvas.Line(0, 10, 100, 10);
// destructor of PenHolder
}
private:
Pen _penGreen;
};
И, наконец, если ваша программа нуждается в произвольных цветных перьях, то есть, невозможно предварительно определить всех цветов, в которых вы будете нуждаться, Вы должны использовать цветные перья. Когда Вы определяете автоматический объект ColorPen, его конструктор создает и присоединяет перо. Когда, в конце области действия, вызывается деструктор, он отсоединяет перо и удаляет его.
class ColorPen {
public:
ColorPen(HDC hdc, COLORREF color) : _hdc (hdc) {
_hPen = CreatePen(PS_SOLID, 0, color);
_hPenOld = (HPEN)SelectObject(_hdc, _hPen);
}
~ColorPen() {
SelectObject(_hdc, _hPenOld);
DeleteObject(_hPen);
}
private:
HDC _hdc;
HPEN _hPen;
HPEN _hPenOld;
};
Точно таким же способом Вы можете работать с кистями (кистей, поддерживаемых Windows, гораздо больше, чем перьев). В качестве примера, ниже дается определение ColorBrush.
class ColorBrush {
public:
ColorBrush(HDC hdc, COLORREF color) : _hdc (hdc) {
_hBrush = CreateSolidBrush(color);
_hBrushOld = (HBRUSH)SelectObject(_hdc, _hBrush);
}
~ColorBrush() {
SelectObject(_hdc, _hBrushOld);
DeleteObject(_hBrush);
}
private:
HDC _hdc;
HBRUSH _hBrush;
HBRUSH _hBrushOld;
};
Как всегда, мы пощряем Ваши собственные эксперименты.
Далее: совершенно иная тема — «Потоки».
Классовая оболочка для потоков
Использование потоков
Перевод А. И. Легалова
Англоязычный оригинал находится на сервере компании Reliable Software
Многозадачность — один из наиболее трудных аспектов программирования. Поэтому, для нее тем более важно обеспечить простой набор абстракций и инкапсулировать их в хорошей объектно-ориентированной оболочке. В ОО мире, естественным аналогом потока, являющегося, чисто процедурной абстракцией, служит «Активный объект». Активный объект обладает удерживаемым потоком, который асинхронно выполняет некоторые задачи. Этот поток имеет доступ к всем внутренним (закрытым) данным и методам объекта. Открытый интерфейс Активного объекта доступен внешним агентам (таким как основному потоку, или потоку, несущему сообщения Windows). Поэтому, они могут манипулировать состоянием объекта также, как эта манипуляция осуществляется из удерживаемого потока. Хотя, режим управления при этом сильно ограничен.
Активный Объект сформирован как каркас по имени ActiveObject. Построение производного класса, как предполагается, обеспечивает реализацию для чистых виртуальных методов InitThread, Run и Flush (также как и написание деструктора).
class ActiveObject {
public:
ActiveObject();
virtual ~ActiveObject() {}
void Kill();
protected:
virtual void InitThread() = 0;
virtual void Run() = 0; virtual void FlushThread() = 0;
static DWORD WINAPI ThreadEntry(void *pArg);
int _isDying;
Thread _thread;
};
Конструктор класса ActiveObject инициализирует удерживаемый поток, передавая ему указатель функции, которую предполагается выполнить и указатель "this" на себя. Мы должны отключить предупреждение, сигнализирующее об использовании "this" до полного создания объекта. Мы знаем, что этот объект не будет использоваться раньше положенного, потому что поток создается в неактивном состоянии. Предполагается, сто конструктор производного класса вызывает _thread.Resume() чтобы активизировать поток.
// The constructor of the derived class
// should call
// _thread.Resume ();
// at the end of construction
ActiveObject::ActiveObject() : _isDying (0),
#pragma warning(disable: 4355) // 'this' used before initialized
_thread(ThreadEntry, this)
#pragma warning(default: 4355)
{ }
Метод Kill вызывает виртуальный метод FlushThread — это необходимо для завершения потока из любого состояния ожидания и дает ему возможность запустить _isDying для проверки флажка.
void ActiveObject::Kill() {
_isDying++;
FlushThread();
// Let's make sure it's gone
_thread.WaitForDeath();
}
Мы также имеем каркас для функции ThreadEntry (это — статический метод класса ActiveObject, поэтому мы можем определять соглашение о вызовах, требуемое API). Эта функция выполняется удерживаемым потоком. Параметр, получаемый потоком от системы является тем, который мы передали конструктору объекта потока — это указатель "this" Активного Объекта. API ожидает void-указатель, поэтому мы должны делать явное приведение указателя на ActiveObject. Как только мы овладеваем Активным Объектом, мы вызываем его чистый виртуальный метод InitThread, делать все специфические для реализации приготовления, а затем вызываем основной рабочий метод Run. Реализация метода Run оставлена клиенту каркаса.
DWORD WINAPI ActiveObject::ThreadEntry(void* pArg) {
ActiveObject* pActive = (ActiveObject*)pArg;
pActive->InitThread();
pActive->Run();
return 0;
}
Объект Thread — это тонкая инкапсуляция API. Обратите внимание на флажок CREATE_SUSPENDED, который гарантирует, что нить не начнет выполняться прежде, чем мы не закончим конструирование объекта ActiveObject.
class Thread {
public:
Thread(DWORD(WINAPI* pFun)(void* arg), void* pArg) {
_handle = CreateThread(
0, // Security attributes
0, // Stack size
pFun, pArg, CREATE_SUSPENDED, &_tid);
}
~Thread() {
CloseHandle(_handle);
}
void Resume() {
