95 в двух томах Том I


Pattern: 1 1 1 1 0 0 0 0 Source



Pdf просмотр
страница16/41
Дата27.11.2016
Размер4.32 Mb.
Просмотров7697
Скачиваний0
ТипРеферат
1   ...   12   13   14   15   16   17   18   19   ...   41
Pattern:
1 1
1 1 0 0 0 0
Source:
1 1 0 0 1 1 0 0
Destination:
1 0 1 0 1 0 1 0
Result:
? ? 1 0 ? ? 1 0
Полдела сделано. Теперь для каждого белого бита битового образа вы хотите, чтобы приемный контекст закрашивался шаблоном. Кисть, выбранная вами в приемный контекст устройства — это шаблон. Таким образом, везде где Source равен 1, вы хотите, чтобы Result равнялся Pattern:
Pattern:
1 1
1 1 0 0 0 0
Source:
1 1 0 0 1 1 0 0
Destination:
1 0 1 0 1 0 1 0
Result:
1 1
1 0 0 0 1 0
Это означает, что старшее слово ROP кода равняется 0xE2. Вы можете заглянуть в таблицу ROP кодов пакета
Microsoft Developer Studio и обнаружить, что полный ROP код равен 0xE20746.
Если обнаружится, что вы перепутали белые и черные биты при создании битового образа, то это легко исправить, используя другую логическую операцию:
Pattern:
1 1
1 1 0 0 0 0
Source:
1 1 0 0 1 1 0 0
Destination:
1 0 1 0 1 0 1 0
Result:
1 0 1 1
1 0 0 0
Теперь старшее слово ROP кода равно 0xB8, а весь ROP код равен 0xB8074A, что соответствует логической операции:
((Destination ^ Pattern) & Source) ^ Pattern
Теперь второй пример: вы можете заметить, что значки и курсоры состоят из двух битовых образов.
Использование двух битовых образов позволяет этим объектам быть прозрачными или инвертировать цвет

138 закрываемых ими фрагментов экрана. Для монохромного значка или курсора, эти два битовых образа кодируются следующим образом:
Bitmap1:
0 0 1
1
Bitmap2:
0 1 0 1
Result:
Черный
Белый
Цвет экрана
Инверсный цвет экрана
Windows выбирает битовый образ Bitmap1 в контекст памяти и использует функцию BitBlt с ROP кодом SRCAND для переноса битового образа на экран. Этот ROP код соответствует логической операции:
Destination & Source
Она сохраняет неизменными биты приемника, соответствующие единичным битам Bitmap1, и устанавливает в 0 биты, соответствующие нулевым битам Bitmap1. Затем Windows выбирает Bitmap2 в контекст устройства и использует функцию BitBlt с параметром SRCINVERT. Логическая операция такова:
Destination ^ Source
Данная операция сохраняет неизменными биты приемника, соответствующие нулевым битам Bitmap2, и инвертирует биты, соответствующие единичным битам Bitmap2.
Взгляните на первый и второй столбцы таблицы: Bitmap1 и SRCAND делают биты черными, а Bitmap2 и
SRCINVERT инвертируют выбранные биты в белый цвет. Эти операции устанавливают белые и черные биты, которые составляют значок и курсор. Теперь посмотрите на третий и четвертый столбцы таблицы: Bitmap1 и
SRCAND сохраняют дисплей неизменным, а Bitmap2 и SRCINVERT инвертируют цвета указанных битов. Эти операции делают значки и курсоры прозрачными или позволяют инвертировать цвет закрываемой области экрана.
Другой пример творческого использования ROP кодов приводится далее в этой главе при описании функции
GrayString.
Дополнительные сведения о контексте памяти
Мы использовали контекст памяти для передачи существующих битовых образов на экран. Вы можете также использовать контекст памяти для рисования на поверхности битового образа. Мы сделаем это в программе
GRAFMENU в главе 10. Во-первых, вы строите контекст памяти: hdcMem = CreateCompatibleDC(hdc);
Затем вы создаете битовый образ желаемого размера. Если вы хотите создать монохромный битовый образ, его можно сделать совместимым с hdcMem: hBitmap = CreateCompatibleBitmap(hdcMem, xWidth, yHeight);
Для создания битового образа с такой же организацией цветов, как и у видеотерминала, сделайте битовый образ совместимым с hdc: hBitmap = CreateCompatibleBitmap(hdc, xWidth, yHeight);
Теперь вы можете выбрать битовый образ в контекст памяти:
SelectObject(hdcMem, hBitmap);
А затем вы можете рисовать в этом контексте памяти (т. е. на поверхности битового образа), используя все функции GDI, рассмотренные в этой главе. Когда вы впервые создаете битовый образ, он содержит случайные биты. Поэтому есть смысл начать с использования функции PatBlt с ROP кодом WHITENESS или BLACKNESS для стирания фона контекста памяти.
Когда вы закончите рисование в контексте памяти, просто удалите его:
DeleteDC(hdcMem);
Теперь битовый образ будет содержать все, что вы нарисовали, пока он был выбран в контекст памяти.
Программа SCRAMBLE, показанная на рис. 4.26, очень "грубая", и не следовало бы показывать ее вам. Но она использует контекст памяти, как временный буфер для операций BitBlt, меняющих местами содержимое двух прямоугольных фрагментов экрана.
SCRAMBLE.MAK
#------------------------
# SCRAMBLE.MAK make file
#------------------------ scramble.exe : scramble.obj

139
$(LINKER) $(GUIFLAGS) -OUT:scramble.EXE scramble.obj $(GUILIBS) scramble.obj : scramble.c
$(CC) $(CFLAGS) scramble.c
SCRAMBLE.C
/*------------------------------------------------
SCRAMBLE.C -- Scramble(and Unscramble) Screen
(c) Charles Petzold, 1996
------------------------------------------------*/
#include
#include
#define NUM 200
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR szCmdLine, int iCmdShow)
{ static int iKeep [NUM][4];
HDC hdc, hdcMem; int cx, cy;
HBITMAP hBitmap; int i, j, x1, y1, x2, y2; if(LockWindowUpdate(GetDesktopWindow()))
{ hdc = CreateDC("DISPLAY", NULL, NULL, NULL); hdcMem = CreateCompatibleDC(hdc); cx = GetSystemMetrics(SM_CXSCREEN) / 10; cy = GetSystemMetrics(SM_CYSCREEN) / 10; hBitmap = CreateCompatibleBitmap(hdc, cx, cy);
SelectObject(hdcMem, hBitmap); srand((int) GetCurrentTime()); for(i = 0; i < 2; i++) for(j = 0; j < NUM; j++)
{ if(i == 0)
{ iKeep [j] [0] = x1 = cx *(rand() % 10); iKeep [j] [1] = y1 = cy *(rand() % 10); iKeep [j] [2] = x2 = cx *(rand() % 10); iKeep [j] [3] = y2 = cy *(rand() % 10);
} else
{ x1 = iKeep [NUM - 1 - j] [0]; y1 = iKeep [NUM - 1 - j] [1]; x2 = iKeep [NUM - 1 - j] [2]; y2 = iKeep [NUM - 1 - j] [3];
}
BitBlt(hdcMem, 0, 0, cx, cy, hdc, x1, y1, SRCCOPY);
BitBlt(hdc, x1, y1, cx, cy, hdc, x2, y2, SRCCOPY);
BitBlt(hdc, x2, y2, cx, cy, hdcMem, 0, 0, SRCCOPY);
Sleep(10);
}
DeleteDC(hdcMem);

140
DeleteDC(hdc);
DeleteObject(hBitmap);
LockWindowUpdate(NULL);
} return FALSE;
}
Рис. 4.26 Программа SCRAMBLE
В программе SCRAMBLE нет оконной процедуры. В функции WinMain она получает контекст устройства для всего экрана: hdc = CreateDC("DISPLAY", NULL, NULL, NULL); а также контекст памяти: hdcMem = CreateCompatibleDC(hdc);
Затем она определяет размеры экрана и делит их на 10: xSize = GetSystemMetrics(SM_CXSCREEN) / 10; ySize = GetSystemMetrics(SM_CYSCREEN) / 10;
Программа использует эти размеры для создания битового образа: hBitmap = CreateCompatibleBitmap(hdc, xSize, ySize); и выбирает его в контекст памяти:
SelectObject(hdcMem, hBitmap);
Используя функцию rand языка C, программа SCRAMBLE формирует четыре случайных величины, кратные значениям xSize и ySize: x1 = xSize *(rand() % 10); y1 = ySize *(rand() % 10); x2 = xSize *(rand() % 10); y2 = ySize *(rand() % 10);
Программа меняет местами два прямоугольных блока дисплея, используя три функции BitBlt. Первая копирует прямоугольник с вершиной в точке (x1, y1) в контекст памяти:
BitBlt(hdcMem, 0, 0, xSize, ySize, hdc, x1, y1, SRCCOPY);
Вторая копирует прямоугольник с вершиной в точке (x2, y2) в прямоугольную область с вершиной в точке (x1, y1):
BitBlt(hdc, x1, y1, xSize, ySize, hdc, x2, y2, SRCCOPY);
Третья копирует прямоугольник из контекста памяти в прямоугольную область с вершиной в точке (x2, y2):
BitBlt(hdc, x2, y2, xSize, ySize, hdcMem, 0, 0, SRCCOPY);
Этот процесс эффективно меняет местами содержимое двух прямоугольников на дисплее. SCRAMBLE делает это
200 раз, что может привести к полному беспорядку на экране. Но этого не происходит, потому что программа
SCRAMBLE отслеживает свои действия, и перед завершением восстанавливает экран.
Вы можете также использовать контекст памяти для копирования содержимого одного битового образа в другой.
Предположим, вы хотите создать битовый образ, содержащий только левый верхний квадрант другого битового образа. Если исходный битовый образ имеет описатель hBitmap, то вы можете скопировать его размеры в структуру типа BITMAP:
GetObject(hBitmap, sizeof(BITMAP),(LPVOID) &bm); и создать новый неинициализированный битовый образ размером в одну четверть исходного: hBitmap2 = CreateBitmap(bm.bmWidth / 2, bm.bmHeight / 2, bm.bmPlanes, bm.bmBitsPixel, NULL);
Теперь создаются два контекста памяти и в них выбираются исходный и новый битовые образы: hdcMem1 = CreateCompatibleDC(hdc); hdcMem2 = CreateCompatibleDC(hdc);
SelectObject(hdcMem1, hBitmap);
SelectObject(hdcMem2, hBitmap2);
Теперь копируем левый верхний квадрант первого битового образа во второй:

141
BitBlt(hdcMem2, 0, 0, bm.bmWidth / 2, bm.bmHeight / 2, hdcMem1, 0, 0, SRCCOPY);
Все сделано, кроме очистки:
DeleteDC(hdcMem1);
DeleteDC(hdcMem2);
DeleteObject(hBitmap);
Преобразования цветов
Если приемный и исходный контексты устройства в функции BitBlt имеют различные цветовые характеристики, то операционная система Windows должна преобразовать битовый образ из одного цветового формата в другой.
Наилучший результат преобразования достигается в случае, если исходный битовый образ монохромный. Windows использует атрибуты цвета текста и фона приемного контекста устройства для преобразования:
Монохромный DC (Источник)
Цветной DC (Приемник)
0 (Черный)
Цвет текста (по умолчанию черный)
1 (Белый)
Цвет фона (по умолчанию белый)
Кроме того, атрибут цвета фона используется Windows для заполнения пробелов в точечных и штриховых линиях, а также между штрихами в штриховых кистях. Вы можете изменить цвет фона с помощью функции SetBkColor.
Цвет фона, с которым мы еще встретимся позднее в этой главе, определяет цвет текста. Вы можете изменить его с помощью функции SetTextColor. По умолчанию, монохромный битовый образ просто преобразуется в черно-белый битовый образ в цветном контексте устройства.
Преобразование битового образа из цветного контекста устройства в монохромный приемный контекст устройства является менее удовлетворительным:
Цветной DC (Источник)
Монохромный DC (Приемник)
Пиксель != Цвет фона 0
(Черный)
Пиксель == Цвет фона
1 (Белый)
В этом случае Windows использует цвет фона исходного контекста устройства для определения того, какой цвет преобразовывать в белый. Любой другой цвет преобразуется в черный.
Здесь существует проблема, связанная с цветами: Windows необходимо сравнить конкретную комбинацию битов цвета битового образа (лежащих в разных цветовых плоскостях или в одной плоскости) с 24-битным значением цвета фона. Это значит, что цветной контекст устройства должен относиться к физическому устройству или быть контекстом памяти на базе реального устройства. Например, у вас имеется монохромный драйвер устройства. Вы строите контекст памяти на базе дисплейного контекста устройства и выбираете цветной битовый образ в контекст памяти, а затем делаете попытку перенести битовый образ в монохромный контекст устройства. Это не удается, потому что Windows не знает, как множество цветовых плоскостей или множество битов на пиксель битового образа контекста памяти соотносится с реальными цветами.
Преобразования режимов отображения
Вызов функции BitBlt требует задания различных начальных координат для исходного и приемного контекстов устройства, но при этом должна быть задана одна ширина и одна высота:
BitBlt(hdcDest, xDest, yDest, xWidth, yHeight, hdcSrc, xSrc, ySrc, dwROP);
Величины xWidth и yHeight задаются в логических единицах и относятся одновременно к прямоугольникам исходного и приемного контекста устройства. Функция BitBlt должна преобразовать все координаты и размеры в координаты устройства перед вызовом драйвера для выполнения операции. Поскольку значения xWidth и yHeight используются для обоих контекстов устройства, они должны преобразовываться в единицы устройства (пиксели) независимо для каждого контекста устройства.
Когда исходный и приемный контексты устройства равны или когда оба контекста устройства используют режим отображения MM_TEXT, размер этого прямоугольника в единицах устройства будет одинаковым для обоих контекстов устройства. Windows тогда может осуществить простой перенос пиксель-в-пиксель. Однако, когда размеры прямоугольника в единицах устройства различны в двух контекстах устройства, Windows перекладывает работу на более мощную функцию StretchBlt.
Растяжение битовых образов с помощью функции
StretchBlt

Функция StretchBlt имеет два дополнительных параметра по сравнению с функцией BitBlt

:

142
StretchBlt( hdcDest, xDest, yDest, xDestWidth, yDestHeight, hdcSrc, xSrc, ySrc, xSrcWidth, ySrcHeight, dwROP
);
Поскольку функция StretchBlt имеет различные параметры ширины и высоты исходного и приемного прямоугольников, становится возможным растяжение или сжатие битового образа исходного контекста устройства для того, чтобы занять большую или меньшую область в приемном контексте устройства.
Так же как функция BitBlt — есть расширение функции PatBlt, так и функция StretchBlt — есть расширение функции BitBlt, позволяющее задавать раздельно размеры исходного и приемного прямоугольника. Как и у функций PatBlt и BitBlt все координаты и значения в функции StretchBlt задаются в логических единицах. Функция
StretchBlt также позволяет вам переворачивать изображение по горизонтали и вертикали. Если знаки xSrcWidth и
xDestWidth (при преобразовании в единицы устройства) различны, то функция StretchBlt создает зеркальное изображение: левая часть становится правой, правая часть — левой. Если знаки ySrcHeight и yDestHeight (при преобразовании в единицы устройства) различны, то функция StretchBlt переворачивает изображение по вертикали.
Функция StretchBlt может работать достаточно медленно, особенно с большими битовыми образами. Кроме того, существуют проблемы, связанные с трудностями масштабирования битовых образов. При растяжении битового образа функция StretchBlt должна дублировать строки или столбцы пикселей. Если растяжение происходит не в целое число раз, то в результате может получиться искаженный образ.
При сжатии битового образа функция StretchBlt должна комбинировать две или более строки или столбца пикселей в одну строку или столбец. Она делает это одним из трех способов в зависимости от атрибута режима растяжения в контексте устройства. Вы можете использовать функцию SetStretchBltMode для изменения этого атрибута:
SetStretchBltMode(hdc, iMode);
Величина iMode может принимать следующие значения:

BLACKONWHITE (по умолчанию) — Если два или более пикселей должны быть преобразованы в один пиксель, то функция StretchBlt выполняет логическую операцию AND над пикселями. Результирующий пиксель будет белым только в том случае, если все исходные пиксели были белыми, что на практике означает, что черные пиксели преобладают над белыми.

WHITEONBLACK — Если два или более пикселей должны быть преобразованы в один пиксель, то функция StretchBlt выполняет логическую операцию OR над пикселями. Результирующий пиксель будет черным только в том случае, если все исходные пиксели были черными, что означает, что белые пиксели преобладают над черными.

COLORONCOLOR — функция StretchBlt просто уничтожает строки или столбцы пикселей без выполнения логических операций. Иногда, это лучший подход для цветных битовых образов, поскольку два других режима могут вызвать искажения цветов.
Кисти и битовые образы
Когда вы используете функции CreatePatternBrush или CreateBrushIndirect с полем lbStyle, установленным в значение BS_PATTERN, вы должны сначала получить описатель битового образа. Битовый образ должен быть размером как минимум 8 на 8 пикселей. Если он больше, то Windows использует только левый верхний угол битового образа для кисти.
Поскольку кисти и битовые образы — объекты GDI, вы должны удалить все объекты, созданные вами, до того, как ваша программа завершится. Когда вы создаете кисть на базе битового образа, Windows делает копию данных битового образа для использования при рисовании кистью. Вы можете удалить битовый образ сразу же после вызова функций CreatePatternBrush или CreateBrushIndirect без какого-либо влияния на кисть. Аналогично, вы можете удалить кисть без влияния на битовый образ.
Скажем, вы хотите нарисовать прямоугольник, закрашенный кистью, в виде сетки, как показано на рис. 4.27.
Рис. 4.27 Фигура, закрашенная пользовательской кистью
Битовый образ, который вам нужен, выглядит так:

143
Это монохромный битовый образ с высотой и шириной в 8 пикселей.
Как будет показано в главе 9, вы можете создать битовый образ в виде небольшого файла в программе Microsoft
Developer Studio и определить его в вашей программе как ресурс. Загружая его, вы получаете описатель битового образа: hBitmap = LoadBitmap(hInstance, "Brick"); hBrush = CreatePatternBrush(hBitmap);
Когда у вас будет действительный контекст устройства, выберите кисть в контекст устройства и отобразите прямоугольник:
SelectObject(hdc, hBrush);
Rectangle(hdc, xLeft, yTop, xRight, yBottom);
Когда вы освободите контекст устройства, удалите кисть и битовый образ:
DeleteObject(hBrush);
DeleteObject(hBitmap);
Для удаления битового образа не нужно ждать, пока освободится контекст устройства. Вы можете сделать это в любой момент после создания кисти на основе битового образа.
Можно также описать пиксели битового образа в вашей программе как массив восьми беззнаковых целых. Каждое целое соответствует скан-линии в шаблоне битового образа. Бит, равный 1, используется для задания белого цвета, бит, равный 0 — для черного:
HBITMAP hBitmap;
HBRUSH hBrush; static WORD wBrickBits [] =
{ 0xFF, 0x0C, 0x0C, 0x0C, 0xFF, 0xC0, 0xC0, 0xC0 };
Битовый образ создается функцией CreateBitmap с параметром — ссылкой на массив целых: hBitmap = CreateBitmap(8, 8, 1, 1,(LPVOID) &wBrickBits); hBrush = CreatePatternBrush(hBitmap);
И далее продолжать, как указано выше.
Метафайлы
Метафайлы имеют такое же значение для векторной графики, как и битовые образы для растровой графики.
Метафайлы конструируются человеком или компьютерной программой. Метафайл состоит из набора записей, соответствующих вызовам графических функций, например, рисующих прямые линии, кривые, закрашенные области и текст. Таким образом, метафайл — набор вызовов графических функций, закодированный в двоичной форме.
Программы рисования создают битовые образы, программы черчения — метафайлы. В программах черчения вы можете "захватить" конкретный графический объект (такой как линия) и переместить его в другое место. Это возможно потому, что все компоненты чертежа хранятся как отдельные записи. В программах рисования такие действия невозможны — вы можете только удалять и вставлять прямоугольные фрагменты битового образа.
Поскольку метафайл описывает изображение в терминах команд графического вывода, изображение может быть промасштабировано без потери разрешения. С битовыми образами это невозможно. Если вы отображаете битовый образ в увеличенном в два раза виде, то вы не получите двойного разрешения. Биты внутри битового образа будут просто повторяться горизонтально и вертикально.

144
Метафайл может быть преобразован в битовый образ без потери информации. Графические объекты, составляющие метафайл, теряют свою индивидуальность и соединяются вместе в одном большом образе.
Преобразование битового образа в метафайл — гораздо более сложная задача, решаемая обычно только для простых битовых образов, и требующая высокой мощности процессора для выявления углов и контуров.
Метафайлы чаще всего используются для разделения изображений между программами посредством буфера обмена, хотя они могут также быть сохранены на диске в виде файлов. Поскольку метафайлы описывают изображение как набор вызовов GDI, для их хранения требуется значительно меньше места, и они более независимы от устройства, чем битовые образы.
Сначала мы рассмотрим функции работы с метафайлами, которые поддерживаются Windows, начиная с версии 1.0 и кончая Windows 95, а затем остановимся на "расширенных метафайлах", разработанных для Windows NT, но также поддерживаемых Windows 95. Расширенные метафайлы имеют серьезные преимущества в сравнении с метафайлами старого формата и значительно лучше приспособлены для дискового хранения.
Простое использование метафайлов памяти
Для создания метафайла сначала надо построить контекст устройства метафайла путем вызова функции
CreateMetaFile. Затем вы можете использовать большинство функций рисования GDI в этом контексте метафайла.
Эти вызовы функций GDI ничего не будут выводить на экран. Вместо этого они будут запоминаться в метафайле.
Когда вы закроете контекст устройства метафайла, вы получите описатель метафайла. Затем, вы можете "проиграть" этот метафайл на реальном контексте устройства и выполнить функции GDI метафайла.
Функция CreateMetaFile имеет один параметр. Он может быть равен NULL или быть именем файла. Если NULL, то метафайл запоминается в оперативной памяти. Если указано имя файла (обычно с расширением .WMF —
"Windows Metafile"), то метафайл запоминается как дисковый файл.
Программа METAFILE, приведенная на рис. 4.28, показывает, как создать метафайл в памяти во время обработки сообщения WM_CREATE и 100 раз вывести изображение во время обработки сообщения WM_PAINT.
METAFILE.MAK
#------------------------
# METAFILE.MAK make file
#------------------------ metafile.exe : metafile.obj
$(LINKER) $(GUIFLAGS) -OUT:metafile.exe metafile.obj $(GUILIBS) metafile.obj : metafile.c
$(CC) $(CFLAGS) metafile.c
METAFILE.C
/*----------------------------------------------
METAFILE.C -- Metafile Demonstration Program
(c) Charles Petzold, 1996
----------------------------------------------*/
#include
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR szCmdLine, int iCmdShow)
{ static char szAppName [] = "Metafile";
HWND hwnd;
MSG msg;
WNDCLASSEX wndclass; wndclass.cbSize = sizeof(wndclass); wndclass.style = CS_HREDRAW | CS_VREDRAW; wndclass.lpfnWndProc = WndProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 0; wndclass.hInstance = hInstance;

145 wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION); wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); wndclass.hbrBackground =(HBRUSH) GetStockObject(WHITE_BRUSH); wndclass.lpszMenuName = NULL; wndclass.lpszClassName = szAppName; wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
RegisterClassEx(&wndclass); hwnd = CreateWindow(szAppName, "Metafile Demonstration",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL, hInstance, NULL);
ShowWindow(hwnd, iCmdShow);
UpdateWindow(hwnd); while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
} return msg.wParam;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{ static HMETAFILE hmf; static int cxClient, cyClient;
HBRUSH hBrush;
HDC hdc, hdcMeta; int x, y;
PAINTSTRUCT ps; switch(iMsg)
{ case WM_CREATE: hdcMeta = CreateMetaFile(NULL); hBrush = CreateSolidBrush(RGB(0, 0, 255));
Rectangle(hdcMeta, 0, 0, 100, 100);
MoveToEx(hdcMeta, 0, 0, NULL);
LineTo (hdcMeta, 100, 100);
MoveToEx(hdcMeta, 0, 100, NULL);
LineTo (hdcMeta, 100, 0);
SelectObject(hdcMeta, hBrush);
Ellipse(hdcMeta, 20, 20, 80, 80); hmf = CloseMetaFile(hdcMeta);
DeleteObject(hBrush); return 0; case WM_SIZE: cxClient = LOWORD(lParam); cyClient = HIWORD(lParam); return 0; case WM_PAINT: hdc = BeginPaint(hwnd, &ps);

146
SetMapMode(hdc, MM_ANISOTROPIC);
SetWindowExtEx(hdc, 1000, 1000, NULL);
SetViewportExtEx(hdc, cxClient, cyClient, NULL); for(x = 0; x < 10; x++) for(y = 0; y < 10; y++)
{
SetWindowOrgEx(hdc, -100 * x, -100 * y, NULL);
PlayMetaFile(hdc, hmf);
}
EndPaint(hwnd, &ps); return 0; case WM_DESTROY:
DeleteMetaFile(hmf);
PostQuitMessage(0); return 0;
} return DefWindowProc(hwnd, iMsg, wParam, lParam);
}



Поделитесь с Вашими друзьями:
1   ...   12   13   14   15   16   17   18   19   ...   41


База данных защищена авторским правом ©nethash.ru 2019
обратиться к администрации

войти | регистрация
    Главная страница


загрузить материал