Мы будем заниматься разработкой приложения, задача которого — отображать текущее время в виде аналоговых часов (т. е. часов с циферблатом и стрелками). Естественно, что основная цель преследуется несколько иная, а именно — показать использование большей части того, что предоставляет библиотека классов MFC в плане работы с графикой. По этой причине многие фрагменты кода написаны "не оптимально" — но это не должно вас смущать: благодаря такому подходу мы рассмотрим различные варианты решения одной и той же задачи (где-нибудь это вам обязательно пригодится).
Изменение начального размера окна
Взгляните на следующий код, где полужирным шрифтом выделен фрагмент. который необходимо добавить к каркасу:
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
return FALSE;
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs. lpszName = "Приложение \"Аналоговые часы\"";
int nSize = min (GetSystemMetrics(SM_CXMAXIMIZED) ,
GetSystemMetrics(SM_CYMAXIMIZED)) * 3 / 5;
cs. cx = nSize;
cs. cy = nSize;
cs. dwExStyle &= ~WS_EX_CLIENTEDGE;
cs. lpszClass = AfxRegisterWndClass(0);
return TRUE;
}
Как видите, сначала мы определяем ширину и высоту экрана, выбираем из них минимальное значение и устанавливаем размеры окна равными трем пятым этой величины.
Вот, собственно, пока и все, что необходимо добавить в код класса CMainFrame, поскольку никакого взаимодействия с пользователем в данном приложении не предполагается.
Для вывода надписей нам понадобятся шрифты, а для создания внешнего вида часов — кисти и карандаши. Чтобы не создавать их каждый раз при выводе рисунка (и, соответственно, не удалять после окончания вывода), сделаем это непосредственно в классе. В этом случае они будут освобождены при удалении объекта класса CChildView.
class CChildView : public CWnd
{
…
// Attributes
private:
CFont m_Font_1;
CFont m_Font_2;
CFont m_Font_3;
CBrush m_wndBrush;
CPen m_wndPen;
CBrush m_arrBrush;
CPen m_arrPen;
CBrush m_clkBrush;
CPen m_clkPen;
CBrush m_rndBrush;
CPen m_rndPen;
CBrush m_crnBrush;
CPen m_crnPen;
…
}
Зачем нам так много графических объектов — три шрифта и по пять кистей и карандашей — мы разберемся по ходу создания приложения, а пока запомним, что объекты Windows создаются в два этапа: сначала объект некоторого класса библиотеки MFC, а затем, вызовом соответствующей функции с префиксом Create, непосредственно объект Windows. Пока мы выполнили только первый этап — создали объекты соответствующих классов. Поэтому переходим ко второму этапу.
Создание графических объектов Windows
Как вы думаете, где лучше всего реализовать действия второго этапа по созданию графических объектов Windows? Надеюсь, что вы догадались. Действительно, в обработчике сообщения WM_CREATE — функции OnCreate. Поэтому первое, что надо сделать — это определить обработчик OnCreate. Как это сделать, мы уже рассматривали. После этого можно переходить непосредственно к созданию графических объектов Windows. И начнем мы со шрифтов (см. Справочник).
Для создания шрифта, с помощью которого мы будем выводить название, нам необходимо заполнить поля структуры LOGFONT.
LOGFONT lf = {
130, // Высота шрифта в логических единицах
0, //В качестве ширины символов
// выбирается значение, наиболее
// подходящее конкретному устройству
0, // Текст будем выводить
0, // без наклона
FW_BOLD, // полужирный,
0, // не курсивный,
0, // не подчеркнутый
0, // и не перечеркнутый шрифт
DEFAULT_CHARSET, // Кодировка, установленная
// по умолчанию
OUT_DEFAULT_PRECIS, // Механизм соответствия заданным
// параметрам по умолчанию
CLIP_DEFAULT_PRECIS, // Механизм отсечения,
// используемый по умолчанию
PROOF_QUALITY, // Важно качество шрифта
VARIABLE_PITCH | FF_DONTCARE, // Пропорциональный шрифт, а какое
// семейство — не имеет значения
"Arial" // Имя шрифта
};
После того как структура заполнена, для создания соответствующего объекта Windows осталось только вызвать функцию CreateFontIndirect, передав ей в качестве, параметра указатель на эту структуру.
m_Font_l. CreateFontInctirect (&lf);
Воспользуемся функцией CreateFont для создания второго шрифта:
m_Font_2.CreateFont (
100,
О, //В качестве ширины символов
// выбирается значение, наиболее
// подходящее конкретному устройству
О, // Текст будем выводить
О, // без наклона
FW_BOLD, // полужирный,
О, //не курсивный,
О, //не подчеркнутый
О, // и не перечеркнутый шрифт
DEFAULT_CHARSET, // Кодировка, установленная
//по умолчанию
OUT_DEFAULT_PRECIS, // Механизм соответствия заданным
// параметрам по умолчанию
CLIP_DEFAULT_PRECIS, // Механизм отсечения,
// используемый по умолчанию
PROOF_QUALITY, // Важно качество шрифта
VARIABLE_PITCH! FF_SWISS, // Пропорциональный шрифт
// без засечек
"Arial" // Имя шрифта
);
Как видите, особой разницы в рассмотренных способах создания шрифта нет.
Как вы помните, нам надо создать еще один, последний, шрифт. Воспользуемся для этого уже заполненной структурой:
// Изменяем высоту
lf. lfHeight =80;
// Делаем шрифт самым "тонким"
1f. lfWeight = FW_THIN;
// Устанавливаем пропорциональный шрифт без засечек
lf. lfPitchAndFamily = VARIABLE_PITCH! FF_SWISS;
Осталось только вызвать соответствующую функцию, что мы и делаем:
m_Font_3.CreateFontIndirect (&lf) ;
Итак, мы подготовили шрифты и переходим к следующему необходимому нам объекту — кисти.
Для создания однотонной кисти, которой мы будем закрашивать фон наших часов, нам необходимо задать ее цвет:
#define COLOR_BCKGR RGB(224, 224, 224)
и вызвать функцию CreateSolidBrush:
m_wndBrush. CreateSolidBrush(COLOR_BCKGR);
Аналогичную операцию проделаем и для других кистей, за исключением одной:
#define COLOR_CLOCK RGB(64, 128, 128)
#define COLOR_ROUND RGB (64, 128, 128)
#define COLOR_CRNER RGB(64, 128, 128)
....
m_clkBrush. CreateSolidBrush(COLOR_CLOCK); m_rndBrush. CreateSolidBrush(COLOR_ROUND); m_crnBrush. CreateSolidBrush(COLOR_CRNER);
Для фона стрелок наших часов используем кисть со штриховкой. Создать ее так же просто, как и однотонную кисть:
m_arrBrush. CreateHatchBrush (
HS_DIAGCROSS, // Штриховка крест накрест под углом 45°
COLOR_ARROW) //цвет линий штриховки
Кисть для фона реализуем с помощью специального шаблона. Очевидно, что сначала требуется создать соответствующий ресурс. Вот как он будет выглядеть у нас (рис. 1).
Затем ресурс надо загрузить в объект класса CBitmap:
CBitmap bmp;
bmp. LoadBitmap(IDB_BMP_BK);
Рис. 1. На основе этого шаблона мы будем создавать "цвет фона" кисти часов
После того как объект класса СBitmap создан, нам осталось передать указатель на него в функцию CreatePatternBrush:
m_clkBrush. CreatePatternBrush(&bmp) ;
Результатом наших действии будет кисть на основе этого шаблона.
Как и в случае создания кистей, никаких сложностей при создании карандашей нет. Вот как мы осуществляем это в нашем примере:
#define COLOR_BCKGR RGB(224, 224, 224)
#define COLOR_BLACK RGB( 0, 0, 0)
#define COLOR_ARROW RGB( 0, 128, 128)
#define COLOR_CRNER RGB( 64, 128, 128)
...
m_wndPen. CreatePen(PS_SOLID, 1, COLOR_BCKGR); m_arrPen. CreatePen(PS_SOLID, 1, COLOR_ARROW) ;
m_clkPen. CreatePen{PS_SOLID, 1, COLOR_BLACK) ; m_crnPen. CreatePen;PS_SOLID, 1, COLOR_CRNER);
Единственное исключение мы сделаем для карандаша, которым будем рисовать "метки" для обозначения цифр. В этом случае используем вторую версию функции CreatePen. Для нее, как вы помните, нам необходим указатель на структуру LOGBRUSH. которая содержит параметры кисти, применяемой при рисовании "толстых" линии. Посмотрите, как можно получить параметры кисти, используемой в качестве основы карандаша:
LOGBRUSH lb;
m_rndBrush. GetLogBrush(&1b);
После того как поля структуры заполнены, нам осталось только вызвать функцию создания карандаша, передав ей в качестве параметра указатель на эту структуру:
m_rndPen. CreatePen(
PS_SOLID | PS_GEOMETRIC | // "Сплошные",
PS_ENDCAP_SQUARE, // с прямоугольными концами линии
20, // Ширина 20 пикселов
&1b); // Параметры кисти
Изменение размеров окна
Вообще-то за изменение размеров окна в приложениях отвечает класс фрейма (у нас это CMainFrame). И более того, для поддержки этой возможности нам не пришлось писать ни строчки кода — все сделала библиотека MFC. Нас же вопрос изменения размеров интересует несколько с другой точки зрения: мы хотим, чтобы размер наших часов всегда совпадал с размерами окна.
Реализовать это чрезвычайно просто. Прежде всего необходимо определить две переменные, которые будут хранить текущие значения ширины и высоты окна:
class CChildView : public CWnd
{
...
private:
int m_cxClient; // ширина клиентской области окна
int m_cyClient; // высота клиентской области окна
};
А для отслеживания текущих значений ширины и высоты необходимо определить обработчик сообщения WM_SIZE. Вот как он будет выглядеть:
void CChildView::OnSize (UINT nType, int cx, int cy)
{
// He вмешиваемся в работу библиотеки
CWnd::OnSize(nType, cx, су);
// Запоминаем размер клиентской области
// окна, чтобы каждый раз при перерисовке
// не запрашивать размер заново
m_cxClient = сх;
m_cyClient = су;
}
Вот собственно и все. Теперь, как только нам понадобятся параметры размеров часов, мы всегда можем получить их текущие значения.
Обработка сообщения WM_PAINT
Многие из вас, конечно же, ожидали, что в конце концов мы придем к созданию обработчика сообщения WM_PAINT. И вы не ошиблись, хотя в нашем конкретном случае вполне можно было бы обойтись и без него. Дело в том, что рисование часов обладает особенностью — их надо перерисовывать не в зависимости от "поврежденности" окна, а тогда, когда истечет выбранный нами отрезок времени (через секунду, если будем рисовать секундную стрелку, или через минуту, если секундную стрелку рисовать не будем).
Однако для демонстрации "работы" этого наиболее часто используемого обработчика я решил определить в нем перерисовку фона. Вот как выглядит обработчик OnPaint в нашем примере:
void CChildView::OnPaint()
{
CPaintDC dc(this); // device context for painting
// контекст устройства для перерисовки
// Закрашиваем клиентскую область,
// для чего создаем однородную кисть и...
CBrush brush(COLOR_BCKGR);
// Рисуем прямоугольник
dc. FillRect(CRect(0, 0, m_cxClient, m_cyClient, &brush);
// Циферблат, текст и стрелки рисовать не будем,
// этим займется функция CClockApp::OnIdle
// Do not call CWnd::OnPaint() for painting messages
// Это едва ли не единственное место,
// где не надо вызывать переопределенную функцию базового класса
}
Организация процесса рисования
Ясно, что нам нужна некоторая функция, которая будет заниматься собственно рисованием в окне. Назовем ее, например, Redraw (нам же периодически придется заниматься именно перерисовкой). Очевидно, что она должна принадлежать классу CChildView, отвечающему за окно, в котором мы будем рисовать.
Теперь необходимо определить, где и когда следует вызывать эту функцию. Первое, что приходит на ум: создать таймер и с заданной периодичностью вызывать Redraw. Безусловно, это один из вариантов. Однако я предлагаю рассмотреть другой способ.
Вернемся немного назад — к классу CWinApp. Как вы помните, на базе этого класса создается объект приложения. Некоторые основные его функции мы рассмотрели, нас же сейчас интересует еще одна, а именно:
virtual BOOL CWinApp::OnIdle (LONG lCount)
Параметр lCount увеличивается перед каждым вызовом функции, т. е. всякий раз, когда очередь сообщений приложения пуста, и сбрасывается в 0 при обработке нового сообщения. Этот параметр можно использовать для определения различных режимов обработки или относительного времени "простоя" приложения.
Функция CWinApp::OnIdle вызывается в цикле обработки сообщений, когда очередь сообщений приложения пуста. Функция, выполняемая по умолчанию, обновляет команды объектов интерфейса пользователя, такие как элементы меню и кнопки панелей инструментов, и очищает внутренние структуры данных. Если вы переопределяете эту функцию, то в новой версии необходимо сначала вызвать базовую функцию CWinApp::Onldle с параметром lCount.
Именно этой функцией мы и воспользуемся (естественно, сначала ее переопределив).
Через окно Properties найдите и добавьте виртуальную функцию OnIdle. В созданную заготовку внесите следующий код:
BOOL CClockApp::OnIdle(LONG lCount)
{
CWinApp::OnIdle(lCount);
// Перерисовываем окно
((CMainFrame *)m_pMainWnd)->Redraw();
// чтобы не закончить цикл вызова функции OnIdle возвращаем TRUE
return TRUE;
}
В классе CMainFrame определяем функцию Redraw:
class CMainFrame : public CFrameWnd
{
...
// Operations
public:
void Redraw();
...
};
// Функция перерисовки часов может вызываться
// практически в любой функции программы
//У нас это будет происходить во время "простоя" приложения
void CMainFrame::Redraw()
m_wndChild. Redraw();
}
В классе CChildView определяем свою функцию Redraw:
class CChildView : public CWnd
{
...
// Operations
public:
void Redraw();
...
};
void CChildView::Redraw()
{
// Именно здесь будем реализовывать рисование часов
}
Сам по себе алгоритм достаточно прост:
1. Проверим, не свернуто ли окно — нет смысла рисовать, если все равно никто ничего не увидит.
2. Поскольку мы реализовали механизм перерисовки содержимого окна во время "простоя" приложения, то вполне возможна ситуация, когда текущее время еще не успело измениться. Очевидно, что и в этом случае незачем заниматься перерисовкой.
3 Получим доступ к контексту клиентской области окна — без него мы ничего нарисовать не сможем.
4. Установим систему координат, относительно которой мы будем рисовать.
5. Теперь нарисуем циферблат.
6. Нарисуем стрелки "по старому месту" — перед выводом нового значения времени необходимо стереть старые стрелки.
7. Поскольку надписи на циферблате могут перекрываться стрелками, то обновить их можно только теперь.
8. Выводим стрелки по их новому месту.
9. Осталось только "прибрать за собой" — восстановить измененные параметры контекста устройства и записать новое значение текущего времени.
Вот, собственно, и все. Посмотрите, как это выглядит в коде:
// Функция перерисовки часов может вызываться
// практически в любом месте программы
//
void CChildView::Redraw()
{
static CTime m_tmPrev; // переменная статическая,
// поэтому ее значение не будет изменяться
// между вызовами функции
// Если окно свернуто, нет необходимости что-либо перерисовывать
if (IsIconic())
return;
// Поскольку мы рисуем часы — без получения текущего времени
// нам не обойтись
CTime tmCurrent = CTime::GetCurrentTime();
// Моменты времени, когда мы будем рисовать, у нас произвольные,
// поэтому сначала проверяем, изменились ли текущие значения
if (tmCurrent!= m_tmPrev)
{
// Получаем доступ к. контексту клиентской области окна
CClientDC dc(this);
// Устанавливаем нашу систему координат
SetMode(&dc);
// Рисуем циферблат
DrawClock(&dc);
// Закрашиваем цветом фона ранее выведенные стрелки,
// другими словами — стираем их
CPen *pPen = dc. SelectObject(&m_wndPen);
CBrush *pBrush = dc. SelectObject(&m_wndBrush);
DrawArrows(&dc, m_tmPrev);
// Выводим текст надписей
DrawLabel(&dc);
// Выводим стрелки по их новому месту
dc. SelectObject(&m_amPen);
dc. SelectObject(&m_amBrush);
DrawArrows(&dc, tmCurrent);
// Восстанавливаем параметры контекста устройства,
// которые у него были перед тем, как мы их начали менять
dc. SelectObject(pBrush);
dc. SelectObject(pPen);
} .
// Изменяем значение текущего времени
m_tmPrev = tmCurrent;
}
А мне осталось только привести некоторые комментарии.
Проверка того, что окно свернуто
Для проверки "состояния" окна — не свернуто ли оно, мы воспользовались функцией класса CWnd — CWnd::IsIconic, которая возвращает TRUE, если окно свернуто, и FALSE — в противном случае.
Установка системы координат
Для установки системы координат я реализовал функцию SetMode. код которой приведен ниже:
// Функция формирования системы координат
//
void CChildView::SetMode(CDC *pDC)
// Устанавливаем масштаб, начало и направление
// координатных осей
pDC->SetMapMode(MM_ISOTROPIC);
pDC->SetWindowExt(1000, 1000);
pDC->SetViewportExt (m_cxClient / 2, - m_cyClient / 2) ;
pDC->SetViewportOrg(m_cxClient / 2, m_cyClient / 2);
Прежде всего необходимо установить режим отображения:
pDC->SetMapMode(MM_ISOTROPIC);
Почему выбран именно этот режим — MM_ISOTROPIC? Причина должна быть вам уже понятна: в этом случае по осям х и у устанавливается одинаковая размерность.
Далее задаем размеры логической
pDC->SetWindowExt (1000, 1000);
и физической областей вывода
pDC->SetViewportExt (m_cxClient / 2, - m_cyClient / 2) ;
Знаак "минус" у второго параметра сообщает, что ось у будет направлена вверх.
И, наконец, начало физических координат помещаем в центр окна:
pDC->SetViewportOrg(m_cxClient / 2, m_cyClient /2);
В результате начало координат — в середине клиентской области окна, ось х направлена направо, ось у — вверх, а размер окна — 2000x2000 логических единиц:
X: [-1000; +1000]
Y: [-1000; +1000]
Рисование циферблата часов
Аналогично следует поступить (т. е. реализовать отдельную функцию, чтобы не загромождать код) и с функцией для рисования циферблата часов — CChildView::DrawClock. Но сначала о том, что мы собираемся делать (я не буду описывать необходимые для реализации нашего замысла математические выкладки — это выходит за рамки поставленных задач):
1. Нарисовать отметки для каждого часа, причем для 12, 3, 6 и 9 часов будем рисовать прямоугольники со скругленными углами, а для остальных — круги.
2. Нарисовать дуги между часовыми отметками. Их диаметр следует сделать немного больше диаметра окружности, на которой расположены часовые отметки.
3. Нарисовать "углы" часов. Для демонстрации различных подходов сделаем это тремя способами.
А вот и программная реализация описанного алгоритма:
// Функция рисования циферблата часов
//
void CChildView::DrawClock(CDC *pDC)
{
CPen *pPen;
CBrush *pBrush;
int nAngle;
// Рисуем отметки для каждого часа,
// причем для 12-ти, 3-х, 6-ти и 9-ти часов
// отметки — прямоугольники,
// для остальных — круги
//
// Выбираем в контекст устройства кисть, созданную для циферблата,
pBrush = pDC->SelectObject(&m_clkBrush);
//и шрифт для названия часов
CFont *pFont = pDC->SelectObject (&m_Font_l) ;
POINT pt[2];
double pi = 3.;
double rad = 900;
int nAngle;
int nStep = 30;
// Рисуем отметки для каждого часа
for (nAngle = 0; nAngle < 360; nAngle += nStep)
{
// He буду загромождать текст пояснениями математических
// выкладок — примите на веру или проверьте самостоятельно
double rAngle = (((450 - nAngle) % 360)*pi)/180;
// pt[0] и pt[l] задают
// размеры ограничивающего фигуру прямоугольника
pt[0].x = rad*cos(rAngle);
pt[0].y = rad*sin(rAngle);
int x = (nAngle % 180) ? 70 : 250;
int y = ((nAngle+90) % 180) ? 70 : 250;
pt[0].x -= x / 2;
pt[0].y -= y / 2;
pt[1].x = pt[0].x + x;
pt[1].y = pt[0].y + y;
if (nAngle % 90)
// Для 12, 3, 6 и 9 часов рисуем круги
pDC->Ellipse(pt[0].x, pt[0].y, pt[1].x, pt[1].y);
else
// для остальных — скругленные прямоугольники
pDC->RoundRect(pt[0].x, pt[0].y, pt[1].x, pt[1].y,
min(x, y) / 2, min(x, y) / 2) ;
}
// Рисуем дуги между часовыми отметками
// так, чтобы их диаметр был немного
// больше диаметра окружности, на которой расположены
// часовые отметки
//
// Для рисования дуг между часовыми отметками
// выбираем в контекст устройства специальный карандаш
pPen = pDC->SelectObject(&m_rndPen);
int dAngle = 5;
// Опять опускаю математическое обоснование
for (nAngle = 0; nAngle < 360; nAngle += nStep)
{
double rAngle1 = (((nAngle + nStep - dAngle)) % 360)*pi)/180;
double rAngle2 = (((nAngle + dAngle)) % 360)*pi)/180;
rad = 980;
pt[0].x = rad*cos(rAngle1);
pt[0].y = rad*sin(rAngle1);
pt[1].x = rad*cos(rAngle2);
pt[1].y = rad*sin(rAngle2);
// Рисуем дугу, радиус которой, как мы договорились,
// несколько меньше радиуса окружности, где расположены
// часовые отметки
pDC->Arc(-rad, rad, rad, - rad,
pt[0].x, pt[0].y, pt[1].x, pt[1].y);
}
// Рисуем "углы" часов, причем тремя различными способами
//
CRect round(-1100, -1100, 1100, 1100);
CRgn rgn; CRect rect;
// Для рисования "углов" выбираем в контекст устройства
// специальные карандаш и кисть
pDC->SelectObject(&m_crnPen);
pDC->SelectObject(&m_crnBrush);
// 1-й способ:
// Рисуем левый верхний угол
//
rect = CRect(-950, 950, -550, 550);
// Преобразуем логические координаты прямоугольника в физические
pDC->LPtoDP(&rect);
// Формируем область отсечения,
// для чего нужны координаты в единицах
// устройства вывода
rgn. CreateRectRgnIndirect(&rect);
// Выбираем сформированный регион в контекст устройства
pDC->SelectObject(&rgn);
// Рисуем замкнутую дугу (круг), но выводится
// только ее часть в соответствии с заданной
// областью отсечения
pDC->Arc(&round, CPoint(0, 0), CPoint(0, 0));
// Добавляем две линии для формирования
// замкнутого контура
pDC->MoveTo(-550, 950);
pDC->LineTo(-950, 950);
// Поскольку функция LineTo не изменяет значение текущих
// координат, сразу можно рисовать обе линии
pDC->LineTo(-950, 550);
// Делаем доступной для рисования всю клиентскую часть окна
pDC->SelectClipRgn(NULL);
// До сих пор был задействован только текущий карандаш,
// теперь же в дело вступает текущая кисть
// Заполняем замкнутую область
// с внутренней точки до границы
pDC->ExtFloodFill(-900, 900, COLOR_CRNER, FLOODFILLBORDER);
// Рисуем правый верхний угол,
// здесь все действия аналогичны предыдущим.
// Рисуем дугу и две линии для формирования
// замкнутого контура
pDC->Arc(&round, CPoint(950, 550), CPoint(550, 950));
pDC->MoveTo(550, 950);
pDC->LineTo(950, 950); pDC->LineTo(950, 550);
// Заполняем замкнутую область, заданную цветом
// внутренней точки
pDC->ExtFloodFill(900, 900, COLOR_BCKGR, FLOODFILLSURFACE);
//2-й способ:
// Рисуем правый нижний угон
// Создаем два региона:
// первый — прямоугольный, в него вписан
// радиус окружности
rect = CRect(550, -950, 950, -550);
CRgn rgn1;
Rgn1.CreateRectRgnIndirect(&rect);
// второй — эллиптический, он как раз
// равен окружности
CRect rect2 = round;
CRgn rgn2;
rgn2.CreateEllipticRgnIndirect(&rect2);
// На основе полученных регионов создаем
// комбинированный с нужной нам формой и...
bineRgn(&rgn1, &rgn2, RGN_DIFF);
// ... закрашиваем его
pDC->PaintRgn(&rgn);
// Убираем за собой
rgn. DeleteObject();
rgn1.DeleteObject();
rgn2.DeleteObject();
// 3-й способ:
// Рисуем левый нижний угол,
// с помощью контура и кривых Безье
// начинаем формирование контура
pDC->BeginPath();
// Массив точек для рисования
// кривой Безье
POINT ptB[] = {
-950, -550,
-950, -670,
-670, -950,
-550, -950 };
// "Рисуем" кривую Безье, т. к. другие
// функции рисования гладких кривых
//не фиксируются в контуре
pDC->PolyBezier(ptB, 4);
// Добавляем две линии для формирования
// замкнутого контура, аналогично первым двум способам
pDC->MoveTo(-950, -550);
pDC->LineTo(-950, -950);.
pDC->LineTo(-550, -950);
pDC->EndPath();
// Закрашиваем пространство, ограниченное
// сформированным контуром
pDC->FillPath();
// Мы нарисовали все, что хотели, поэтому
// восстанавливаем параметры контекста устройства
pDC->SelectObject(pPen);
pDC->SelectObject(pBrush);
}
Приведенный код функции DrawClock я снабдил большим числом комментариев, которые, надеюсь, избавили меня от необходимости в каких-либо дополнительных пояснениях.
Нам осталось рассмотреть всего два момента: обновление надписей на циферблате и рисование стрелок.
Вывод текста
Как вы помните, мы предусмотрели три различных шрифта для надписей на циферблате часов. Один (самый крупный) будем использовать для названия, второй (средний) — для надписи о том, что это кварцевые часы, и третий — для вывода некоторой дополнительной информации. Но перейдем непосредственно к коду:
// Функция рисования строк текста на циферблате
//
void CChildView::DrawLabel(CDC *pDC)
{
// Надписи будем выводить по центру
pDC->SetTextAlign(TA_CENTER);
// Первые две строки рисуем так, чтобы
// промежутки заполнялись цветом фона
COLORREF color = pDC->SetBkColor(COLOR_BCKGR);
// Выбираем в контекст устройства шрифт для надписи
CFont *pFont = pDC->SelectObject(&m_Font_1);
// ... и выводим ее в окно
// (текст задаем непосредственно в параметре)
pDC->TextOut(0, 480, _T("Томск"), 5);
// Для вывода надписи о том,
// что часы кварцевые, используем другой способ
// Получаем параметры текущего шрифта
TEXTMETRIC tm;
pDC->GetTextMetrics(&tm);
// Выбираем в контекст устройства соответствующий шрифт
pDC->SelectObject(&m_Font_2);
// Выводим надпись, сместив ее на расстояние,
// равное сумме высоты символов и размера
// области между строками текста
// (все величины взяты для предыдущего шрифта)
pDC->ExtTextOut(0, 480-(tm. tmHeight+tm. tmExternalLeading),
ETO_OPAQUE, NULL,
_T("Кварцевые"), 9, NULL);
// Восстанавливаем в контексте устройства цвет фона
pDC->SetBkColor(color);
// Последнюю строку рисуем так, чтобы
// промежутки между контурами символов
// оставались без изменения — цвет
// фона влияния на эти области не оказывает
pDC->SetBkMode(TRANSPARENT);
// Выбираем в контекст устройства соответствующий шрифт
pDC->SelectObject{&m_Font_3);
// и выводим его в окно
pDC->TextOut(0, -500, _T("ФИО"));
// Восстанавливаем "старый" шрифт
pDC->SelectObject(pFont);
}
На мой взгляд, и здесь от меня не требуется дополнительных комментариев.
Рисование стрелок
Для рисования стрелок я использовал функцию CDC::Polygon. Это единственное место, которое отвечает за отображение. Весь остальной код — это подготовка к выводу трех многоугольников.
// Функция вывода стрелок установленными вне
// ее текущими карандашом и кистью
//
void CChildView::DrawArrows(CDC *pDC, CTime &tm)
{
double pi = 3.;
// Массив точек, которые определяют контуры стрелок
static POINT pt[3][11] =
{
// часовая стрелка
0, -50, -50, 0, -5, 40, -5, 100, -30, 120, 0, 600, 30,
120, 5, 100, 5, 40, 50, 0, 0, -50,
// минутная стрелка
0, -40, -40, 0, -5, 30, -5, 90, -20, 110, 0, 800,
20, 110, 5, 90, 5, 30, 40, 0, 0, -40,
// секундная стрелка
0, -100, -5, -100, -5, -100, -5, -100, -5, -100, 0, 850,
5, -100, 5, -100, 5, -100, 5, -100, 0, -100
};
double nAngle[3];
// Вычисляем углы поворота каждой из трех стрелок
// в зависимости от текущих значений часов, минут и секунд
nAngle[0] = (tm. GetHour() * 30) % 360 + tm. GetMinute() / 2;
nAngle[1] = (tm. GetMinute() * 60 + tm. GetSecond ()) / 10.0;
nAngle[2] = (tm. GetSecond() * 6);
// Чтобы не "потерять" исходные значения стрелок,
// создаем временный массив
POINT ptTemp[11];
for (int i = 0; i < 3; i++)
{
// Вычисление текущих координат всех точек
// контура стрелки
memcpy(ptTemp, pt[i], sizeof(pt[i]));
double rAngle = 450 - nAngle[i];
if (rAngle >= 360) rAngle -= 360;
rAngle *= pi/180;
for (int j = 0; j < 11; j++)
{
double rad = sqrtf(ptTemp[j].x * ptTemp[j].x +
ptTemp[j].y * ptTemp[j].y);
double pAngle = rAngle + pi/2-acos(ptTemp[j].x/rad);
ptTemp[j].x = rad*cos(pAngle);
ptTemp[j].y = rad*sin(pAngle);
}
// Рисование стрелки
pDC->Polygon(ptTemp, 11);
}
}
