Бакалаврская работа на тему
Визуализация контактных преобразований в среде Visual C++ 6.
План.
Введение.
Глава 1. Создание графического интерфейса.
o Генерация исходного кода.
o Классы и файлы программы.
Глава 2. Использование функций рисования. o Создание объекта контекста устройства.
o Выбор инструментов рисования.
Выбор стандартных инструментов рисования.
o Создание инструментов рисования.
Глава 3.Печать и предварительный просмотр.
Основы печати и предварительный просмотр.
Усовершенствованная печать.
Заключение.
Литература и источники.
Тема моей бакалаврской работы – «Визуализация контактных преобразований
(в среде Visual C++ 6.0)». Моя программа будет рисовать два эллипса с
определёнными аргументами, задаваемыми пользователем через диалоговые окна.
Также программа позволяет выводить изображения на принтер и осуществлять
предварительный просмотр.Visual C++ 6.0 - это сравнительно новая система
программирования, которая снискала уважение и популярность по всему миру. С
её помощью легко и удобно писать различные типы программ для Windows.
Шестая версия системы стала ещё более модной и удобной и избавляет от
большого количества рутинной работы по набивке и копированию стандартных
фрагментов подавляющего большинства программ. Безусловно, сердцевиной
системы, во многом определяющей её мощь и гибкость , является библиотека
классов MFC (Microsoft Foundation Classes – базовые классы Microsoft).
Новый 32-разрядный компилятор Microsoft Visual C++ 6.0 для Windows NT и
Windows 95 - одна из составных частей мощного пакета компиляторов
Developer Sudio, в который вхолят новейшие версии таких известных
программных продуктов, как Visual Basic, Visual J++, Visual FoxPro...
Система программирования Visual C++ - один из наиболее полных и
совершенных продуктов, предназначенных для разработки программного
обеспечения. Это высокоскоростная и удобная для программирования система,
предлагающая широкий набор разнообразных инструментов проектирования для
любого стиля программирования.Новые компоненты содержат средства для
программирования приложений, улучшенную реализацию ActiveX и Internet,
дополнительные возможности разработки баз данных, а также новые архитектуры
приложений и элементы взаимодействия между пользователями. Изучение правил
применения данной системы программирования (часто очень не простых, на
первый взгляд) может вас испугать, как это произошло со мной при первом
знакомстве со средой Visual C++.
Глава 1. Создание графического интерфейса.
Для создания моей программы мне потребуется программирование
графического интерфейса (GUI- Graphical User Interface). В программах с
графическим интерфейсом можно создавать одно и более окон с элементами
интерфейса (меню, панели инструментов, строки состояния, списки, полосы
прокрутки и тд). Данные программы могут выводить рисунки, растровые
изображения и текст с использованием большого набора шрифтов. Я буду
создавать свою программу, используя мастер генерации приложений App Wizard
и библиотеки MFC.
Существует несколько способов написания программ с графическим
интерфейсом с помощью Visual C++. Во-первых – на языке С или С++ с
непосредственным обращением к основным функциям Win32 API, которые
являются частью операционных систем Windows. При таком подходе требуется
написать множество строк программного кода, прежде чем перейти к решению
целевой задачи разрабатываемого приложения.
Во-вторых – с помощью библиотеки MFC, содержащей большой набор готовых
классов и вспомогательный код для выполнения стандартных задач
программирования в среде Windows (например, создания окон и обработки
сообщений). Кроме того, MFC используется для быстрого добавления в
программы панелей инструментов, многопанельных окон поддержки OLE.
Применяется для создания элементов, которые используются программными
компонентами и отображаются в Web-браузерах и других приложениях.
Использование MFC позволяет упростить программы с графическим интерфейсом,
что значительно облегчит процесс программирования. Отметим: функции MFC
содержат вызовы функций Win32 API. Говорят, что Win32 API «упакован» в
библиотеку MFC, представляющую более высокоуровневые и переносимые средства
программного интерфейса. Кроме того, в MFC-программах можно свободно
вызывать функции Win32 API, сохраняя возможность использования этого
интерфейса.
В-третьих – на языке С++ с использованием библиотеки MFC и различных
мастеров. Мастер AppWizard используется для генерации основы исходных
файлов программ. Аналогично, мастер AppWizard генерирует основную часть
кода для определения производных классов и обработчиков сообщений,
настройки библиотеки MFC, управления диалоговыми окнами, а также выполнения
других задач. Заметьте: возможности мастеров не ограничиваются генерацией
простых оболочек программ. Они позволяют создавать программы с большим
набором сложных компонентов. К таковым относятся панели инструментов,
строки состояния, контекстная справка, объекты OLE, средства доступа к
базам данных и даже законченные меню с частично или полностью
функционирующими командами открытия и сохранения файлов, печати,
предварительного просмотра печати и выполнения других задач. После
генерации основного кода программы с помощью мастера добавьте собственный
код, определяющий логику работы программы
Преимущество третьего подхода состоит в использовании не только уже
написанного кода MFC, но и сгенерированного исходного кода, позволяющего
решить многие рутинные задачи программирования. Библиотека MFC и матера
освобождают нас от необходимости создавать средства визуального интерфейса
вручную и обеспечивают соответствие этого интерфейса требованиям MicroSoft.
Генерация исходного кода.
Для генерации программы с помощью AppWizard создаётся новый проект
необходимого типа. Затем в последовательности диалоговых окон, отображаемых
мастером, задаются требуемые характеристики программы. Запускаем Developer
Studio и выполняем следующие шаги:
1) Выбираем в меню File команду New. В результате отобразится диалоговое окно New.
2) Открываем вкладку Projects (если она не отображена), чтобы можно было
создать новый проект.
3) В списке типов проекта выбираем “MFC AppWizard(Exe)”. Это приведёт к
тому, что мастер AppWizard сначала предложит ввести необходимую информацию,
а затем создаст основу кода MFC-программы.
4) Вводим имя Ellipse в поле Project Name. Visual C++ присвоит новому
проекту и связанной с ним рабочей области имя Ellipse.
5) В поле Location задаём путь к папке с файлами, т.е. к каталогу проекта.
Можно принять стандартный каталог, указанный в этом поле. Стандартному
каталогу присваивается то же имя, что и рабочей области – Ellipse.
6) Чтобы завершить работу с вкладкой Projects диалогового окна New,
убедитесь, что в поле Platforms отмечен пункт Win32. До тех пор, пока не
будет установлена версия Visual C++ со средствами кросс-платформенной
разработки, Win32 останется единственной опцией в этой области.
7) Щелкаем на кнопке ОК в диалоговом окне. Отобразится первое из диалоговых
окон мастера AppWizard, помеченное “MFC AppWizard – Step 1”. В параметрах
мастера AppWizard, выбираемых по умолчанию, будет указано стандартное
значение.
8) В диалоговом окне выбираем тип приложения Single Document, отмечаем
стандартный параметр Document/View Architecture Support и задаём поддержку
английского языка. Выбор типа приложения Single Document определяет то, что
AppWizard генерирует приложения с однооконным интерфейсом (Single Document
Interface – SDI), отображающее единственное окно документа. Задание
параметра Document/View Architecture Support приведёт к тому, что мастер
AppWizard сгенерирует отдельные классы для хранения и отображения данных программы, а также код для чтения и записи данных на диске.
Щёлкаем Next для перехода к следующему диалоговому окну.
9) Чтобы исключить из программы поддержку баз данных, в диалоговом
окне выбираем пункт None. Щёлкаем Next для перехода к следующему
диалоговому окну.
10) В диалоговом окне выбираем пункт None чтобы исключить из программы
поддержку составных документов. Убираем опцию Automation, чтобы
устранить поддержку автоматизации. Щелкаем Next, чтобы перейти к следующему
диалоговому окну.
11) В диалоговом окне выбираем поддержку печати (Printing and Print
preview), панель инструментов (Docking toolbar), строку состояния (Initial
status bar)и поддержку помощи (Context-sensitive Help), а также 3D
controls. Щёлкаем Next, чтобы перейти к следующему диалоговому окну.
12) Чтобы сгенерировать для программы традиционный пользовательский
интерфейс библиотеки MFC, в диалоговом окне мастера выбираем установку
стиля проекта “MFC Standart”. Чтобы мастер включил комментарии в
генерируемые исходные файлы, выбираем установку “Yes,Please”. Комментарии
поясняют назначение кода и определяют места, в которые программист должен
добавить собственный код. Наконец выбираем вариант связи библиотеки MFC “As
a staticaly linked library”. При этой установке код переносится прямо в
исполняемый файл. Щёлкаем на Next, чтобы отобразить следующее диалоговое
окно.
13) Это диалоговое окно отображает информацию по каждому из четырёх
главных классов, созданных для программы мастером. Не изменяем эту
информацию. Щелкаем Finish
14) Диалоговое окно New Project Information позволяет подытожить
сделанный ранее выбор характеристик программы. Щелкаем ОК, и мастер создаст указанный каталог проекта, сгенерирует исходные файлы программы и откроет вновь созданный проект Ellipse.
Классы и файлы программы.
Программу Ellipse будем называть приложением с однооконным
интерфейсом(SDI). Это означает, что в данный момент времени в ней может
отображаться только один документ. Когда мастер создаёт приложение SDI, он
порождает четыре главных класса:
- класс документа;
- класс представления (view);
- класс главного окна;
- класс приложения;
Исходные задачи программы распределяются по этим четырём главным
классам, и мастер создаёт четыре отдельных исходных файла для каждого из
них. По умолчанию он порождает имена классов и исходных файлов по имени
проекта.
Класс документа в Ellipse называется CЕllipseDoc. Он порождается из
класса CDocument библиотеки MFC. Заголовочный файл CEllipseDoc имеет имя
CEllipseDoc.h, а имя файла реализации - CEllipseDoc.cpp. Класс документа
отвечает за хранение данных программы и за чтение и запись данных на диск.
Класс представления в Ellipse называется CЕllipseView и порождается от
MFC-класса Cview. Заголовочный файл CEllipseView называется
CEllipseView.h, а имя файла реализации - CЕllipse.cpp. Класс представления
отвечает за отображение данных программы (на экране, на принтере, или
другом устройстве) и за обработку информации, вводимой пользователем.
Этот класс управляет окном представления (view window), которое
используется для отображения данных программы на экране. Класс
представления в Ellipse просто отображает строку сообщения внутри окна
представления.
Класс главного окна в Ellipse называется CMainFraim и порождается от
MFC-класса CFrameWnd. Заголовочный файл CMainFrame называется MainFrm.h, а
имя файла реализации - MainFrm.cpp. Класс главного окна управляет главным
окном программы, которое является обрамляющим окном и содержит рамку окна,
строку заголовка, строку меню и системное меню. Обрамляющее окно также
содержит кнопки Minimize, Maximize, Close, а иногда и другие элементы
пользовательского интерфейса, например, панель инструментов, строку
состояния. Окно представления, управляемое классом представления, занимает
внутри обрамляющего окна пустую область, которая называется клиентской
областью главного окна. Окно представления не имеет видимых элементов,
кроме текста и графики, отображающейся явно. Окно представления – дочернее
окно главного окна, поэтому оно всегда отображается поверх и внутри границ
рабочей области главного окна.
Наконец, класс приложения назван CEllipseApp и порожден из MFC–класса
CWinApp. Файл заголовков класса CEllipseApp назван Ellipse.h, а файл
реализации – Ellipse.cpp. Класс приложения управляет программой в целом.
Это значит, что он выполняет общие задачи, не относящиеся к каким-либо
другим трём классам (например, инициализацию программы и её заключительную
очистку). Каждая MFC–программа должна создать в точности один экземпляр
класса, порождённого из класса CWinApp. Четыре главных класса обращаются
друг к другу и обмениваются данными, вызывая открытые функции-члены другого
класса и посылая сообщения.
Глава 2.
Использование функций рисования
1) Создание объекта контекста устройства
2) Выбор инструментов рисования
3) Выбор стандартных инструментов рисования
4) Создание инструментов рисования
Существуют два различных подхода к созданию и манипулированию
графическими изображениями. Можно также вызвать функции рисования в
процессе выполнения программы. Эти функции предназначены для создания
рисунков, состоящих из отдельных геометрических фигур, таких, как прямые
линии, дуги и прямоугольники. Возможно создание и отображение растровых
изображений (называемых точечными рисунками), сохраняющих текущие коды
пикселей, используемых для воспроизведения образов на устройстве. Растровые
изображения удобны для создания более сложных рисунков, которые нелегко
разделить на отдельные геометрические фигуры. Средства, описанные в этих
главах, взаимосвязаны. Функции рисования используются для изменения узоров
пикселей внутри растровых изображений, а битовые операции применяются для
манипулирования изображениями, созданными с помощью функций рисования,
например, для перемещения или растягивания изображения.
Рассматривается как используются функции рисования, предоставляемые
системой Windows и библиотекой MFC. Эти функции в сочетании с растровыми
средствами составляют полный набор инструментов создания графических
образов внутри окна представления или какого-либо другого устройства
(например, принтера). Существуют специальные технические приемы печати
графических изображений или текстов. В этой главе я рассмотрю основные
действия, выполняемые при создании графических
изображений:
1. Создание объекта контекста устройства.
2. Выбор средств рисования внутри объекта.
3. Установка атрибутов рисования для объекта.
4. Вызов функций-членов объекта для рисования графики.
1).Создание объекта контекста устройства
Как известно, для отображения текста или графики необходим объект
контекста устройства, соответствующий окну или устройству вывода данных.
При рисовании этот объект сохраняет выбранные средства и установленные
атрибуты и предоставляет функции-члены для рисования точек, линий,
прямоугольников и других фигур.
Для отображения графического объекта с помощью функции OnDraw класса
представления используется объект контекста устройства, адрес которого
передается в функцию. void CMyView::OnDraw (CDC* pDC )
{
// отобразите графику, используя 'pDC->'
}
Функция OnDraw вызывается при рисовании или перерисовке окна
представления. Если класс представления поддерживает прокрутку (т. е.
порожден от класса CScrollView), то переданный в него объект контекста
устройства настраивается на текущую позицию прокрутки документа.
Если программа отображает графику не в окне представления, а в каком-то
другом окне (например, в диалоговом), то класс окна для рисования или
перерисовки предоставляет обработчик сообщений wm_paint, называемый
OnPaint, который создает объект контекста устройства, порождаемый от MFC-
класса CPaintDC.
void CMyDialog::OnPaint()
{
CPaintDC PaintDC (this) ;
// отобразите графику, используя 'PaintDC". . .
)
Примечание Когда нужно нарисовать или перерисовать окно представления, ему передают сообщение wm_paint. Класс cview предоставляет функцию OnPaint, которая создает и подготавливает объект контекста устройства, а затем передает его в функцию OnDraw. Класс окна, который не порождается от cview, должен предоставлять собственную функцию OnPaint, выполняющую рисование содержимого окна.
Чтобы отобразить графику в окне представления или другом окне из функции,
которая не обрабатывает сообщения OnDraw или OnPaint, нужно создать объект
контекста устройства, являющийся членом MFC-класса CClientDC. Если окно
представления поддерживает прокрутку, то перед использованием объекта
необходимо вызвать функцию CScrollView: :OnPrepareDC для настройки объекта
на текущую позицию документа.
void CMyView::OtherFunction ()
{
CClientDC ClientDC (this)
// Если графика отображается в окне представления,
// поддерживающем прокрутку:
OnPrepareDC (sdientDC) ;
// для отображения графики используется 'ClientDC' ...
}
Чтобы отобразить графику вне рабочей области окна, создаём объект класса cwindowDC.
Все функции рисования являются членами класса CDC. Так как cdc — базовый
класс по отношению к остальным классам объекта контекста устройства, то эти
функции вызываются при использовании объекта контекста устройства
произвольного типа.
Основной акцент сделан на рисовании внутри окна (прежде всего окна
представления). Однако перечисленные функции и способы не зависят от типов
устройств и используются для отображения рисунков на других устройствах,
например принтерах или плоттерах.
2)Выбор инструментов рисования.
Имеются два инструмента, выбор которых отражается на работе функций
класса CDC — перо и кисть. Перо влияет на способ рисования линии. Оно
действует как на прямые и кривые линии (например, нарисованные с
использованием функции LineTo или Arc), так и на границы замкнутых фигур
(например, прямоугольников и эллипсов). Кисть действует на способ рисования
внутренней области замкнутых фигур. Очевидно, что замкнутая фигура состоит
из двух отдельных элементов: границы и внутренней области.
Инструменты рисования, определенные в этом разделе, т.е. перья и кисти, принадлежат к категории объектов, называемых графическими или объектами GDI (термин объект относится к структуре данных Windows, а не к объекту C++; GDI означает графический интерфейс устройства – graphics device interface). Существуют другие графические объекты: шрифты , растровые изображения , области, контуры и палитры. Хотя области, контуры и палитры также относятся к рисованию. Полное описание областей, контуров и палитр приведено в следующих разделах справочной системы: Platform SDK, Graphics and Multimedia Services, GDI . Информация об использовании областей и палитр в MFC - в следующих разделах справочной системы: Visual C++ Documentation, Reference, Microsoft Foundation Class Library and Templates, Microsoft Foundation Class Library, Class Library Reference, CRgn и CPalette. Информация об использовании контуров в MFC - в разделах Visual C++ Documentation, Reference, Microsoft Foundation Class Library and Templates, Microsoft Foundation Class Library, Class Library Reference, CDC, CDC Class Members, а также в разделе Path Functions.
При первичном создании объект контекста устройства содержит заданные по
умолчанию перо и кисть. Перо рисует сплошную черную линию шириной в 1
пиксель независимо от текущего режима отображения (который будет рассмотрен
далее). Кисть заливает внутреннюю область фигуры с замкнутым контуром
непрозрачным белым цветом. Для каждого из этих инструментов приведены
функции рисования, на которые влияет выбор инструмента, и выбранный по
умолчанию идентификатор инструмента. Если нужно выбрать инструмент,
идентификатор передается в функцию SelectStockObject .
Чтобы изменить текущее перо или кисть, выбираем стандартное перо или
кисть или создаём пользовательские, а затем выбираем их в объекте контекста
устройства. Выбранные перо или кисть используются до следующего явного
выбора других инструментов рисования.
3)Выбор стандартных инструментов рисования
Выбирается перо или кисть вызовом функции SelectStockObject класса cdc:
CGdiObject* SelectStockObject (int nIndex);
Параметр nIndex является кодом отдельного стандартного объекта, который
передается в объект контекста устройства. Можно вызвать функцию
SelectStockObject для выбора стандартного шрифта.
Например, следующие строки выбирают белое перо и серую кисть.
void CMyView:;OnDraw(CDC* pDC)
(
pDC->SelectStockObject (WHITE_PEN) ; pDC->SelectStockObject (GRAY_BRUSH) ;
// Вызов других графических функций и рисование графики ... // (линии и границы будут белыми, внутренние области // фигур с замкнутыми контурами - серыми)
}
При выборе пера null_pen линии не рисуются. Значит, выбор не удачен.
Аналогично при выборе NULL_BRUSH внутренняя часть фигуры не закрашивается.
Этот инструмент удобен при рисовании фигур, состоящих только из границы
(прямоугольник), если необходимо оставить неизменным существующее на экране
графическое изображение внутри границы.
Примечание Стандартное перо рисует сплошные линии шириной в один пиксель независимо от заданного режима отображения. Стандартная кисть закрашивает сплошным цветом, а не узорами.
4)Создание инструментов рисования
Можно создать перо или кисть, выполнив следующие действия.
1. Создаём экземпляр класса СРеn для пера или CBrush для кисти.
2. Вызываем соответствующую функцию класса СРеn или CBrush для инициализации пера или кисти.
3. Выбираем перо или кисть в объекте контекста устройства, сохраняя указатель на предыдущее перо или кисть.
4. Вызываем функции рисования для выполнения графического вывода.
5. Снова выбираем старое перо или кисть в объекте контекста устройства.
Для создания временного пера или кисти можно объявить экземпляр класса
СРеn или CBrush как локальный объект внутри функции, генерирующей
графический вывод. Этот метод продемонстрирован в примере фрагмента
программы, приведенном в конце этого раздела. При многократном
использовании в программе выбранного пера или кисти объект удобнее объявить
как переменную класса представления или любого класса, управляющего окном
вывода.
Для инициализации пера вызываем функцию CreatePen класса СРеn.
BOOL CreatePen (int nPenStyle, int nWidth, COLORREF crColor) ;
Параметр nPenStyle описывает стиль линии, нарисованной пером.
Присваивание стиля ps_null создает перо, совпадающее со стандартным пером
null_pen. Стиль ps_insideframe выбирает перо для рисования границы вокруг
фигуры с замкнутым контуром, расположенной внутри ограничивающего
прямоугольника. Ограничивающие прямоугольники и эффекты стиля
ps_insideframe описаны далее. Стили ps_dash, ps_dot, ps_dashdot и PS
dashdotdot используются, если ширина пера равна 1 пикселю. Если ширина пера
превышает этот размер, то перечисленные стили генерируют сплошные линии.
Параметр nWidth описывает ширину линии в логических единицах,
используемых в текущем режиме отображения. Если ширина пера — 0, то
ширина линии — 1 пиксель, независимо от текущего режима отображения. Такая
ширина генерируется и стандартным пером, и заданным по умолчанию.
Параметр crColor задает цветовой код линии. Легче всего описать цвет,
используя макрос Win32 rgb.
ColorRef RGB (bRed, bGreen, bBlue)
Параметры bRed, bGreen и bBlue показывают относительную интенсивность
красного, зеленого и синего цветов. Каждому параметру можно присвоить
значение в диапазоне от 0 до 255. В табл. 19.3 приведены значения, которые
передаются в макрос RGB для описания 16 чистых цветов, доступных в
стандартном графическом режиме VGA.
Обратим внимание: перу присваивается только чистый цвет. Чистый цвет -
это цвет, генерируемый аппаратными средствами для видеоотображения, который
не требуется имитировать смешиванием различных цветов (известным как
имитация полутонов (dithering)). Если присвоить перу цветовой код, который
не относится НИ к одному из чистых цветов, то линия будет нарисована с
использованием ближайшего чистого цвета. Исключение из этого правила: если
перо имеет стиль ps_insideframe и ширину более 1 пикселя, то Windows
использует полутона (если присвоенный цвет не является чистым).
Примечание Класс СPеn предоставляет более совершенную функцию инициализации пера, называемую ExtCreatePen. В среде Windows NT эта функция задает способ изменения и объединения широких перьев, что позволяет создавать перья с пользовательским стилем. Однако Windows 95 не поддерживает большинство из этих средств. Заметим также, что вместо вызова функции CPen: :CreatePen, объект пера можно инициализировать при его создании, передавая конструктору СPеn соответствующие параметры. Информация о конструкторах СРеn и ExtCreatePen - в следующих разделах справочной системы: Visual C++ Documentation, Reference, Microsoft Foundation Class Library and Templates, Microsoft Foundation Class Library, Class Library Reference, СРеп.
Кисть можно инициализировать так, чтобы она окрашивала однородным цветом
внутреннюю область фигур, вызывая функцию CreateSolidBrush класса CBrush с
параметром crColor, описывающим цвет заливки. Можно задать любой цвет. Если
присвоенный цвет не является чистым, то Windows генерирует
псевдополутоновый цвет (полученный имитацией полутонов).
BOOL CreateSolidBrush (COLORREF crColor);
Кроме того, для заливки внутренней области фигур можно инициализировать
кисть, вызвав функцию CreateHatchBrush класса Cbrush.
BOOL CreateHatchBrush (int nindex, COLORREF crColor);
Параметр nIndex задает узор. Параметр crColor описывает цвет линий
штриховки.
Функция CreatePatternBrush класса CBrush вызывает кисть для заполнения
фигуры заданным узором.
BOOL CreatePatternBrush (CBitmap* pBitmap);
Параметр pBitmap является указателем на объект растрового изображения.
Если фигура рисуется с помощью кисти, то ее внутренняя область полностью
заполняется копиями растрового изображения, размещаемыми одна возле другой.
Объект растрового изображения создается и инициализируется. Задаём размер
растрового изображения равным 8х8 пикселей.
Если растровое изображение монохромное, то Windows использует текущие
цвета текста и фона.
Примечание Объект кисть (как и перо) можно инициализировать при создании, передавая конструктору CBrush соответствующие параметры. Информация об этом - в следующих разделах справочной системы: Visual C++ Documentation, Reference, Microsoft Foundation Class Library and Templates, Microsoft Foundation Class Library, Class Library Reference, CBrush.
Как только перо или кисть инициализированы, их выбирают в объекте
контекста устройства с помощью функции SelectObject класса cdc. Для выбора
пера вызовите функцию SelectObject,
CPen* SelectObject (CPen* рРеn) ;
где рРеn — указатель на объект-перо. Функция SelectObject возвращает
указатель на предыдущий объект-перо, выбранный в объекте контекста
устройства. Если перо ранее не выбиралось, это будет временный объект пера,
заданного по умолчанию. Для выбора кисти вызывается функция SelectObject.
CBrush* SelectObject (CBrush* pBrush);
где pBrush — указатель на объект-кисть. Функция SelectObject возвращает
указатель на ранее выбранную кисть. Если она ранее не выбиралась, то это
будет временный объект для заданной по умолчанию кисти.
При вызове функции SelectObject для выбора пера или кисти нужно сохранить
возвращаемый указатель. После вызова графических функций для отображения
выводимой информации с использованием пера или кисти (что описано далее в
этой же главе) удалите перо или кисть из объекта контекста устройства и
вызовите функцию SelectObject для выбора предыдущего объекта.
Перо или кисть необходимо удалить из объекта контекста устройства, чтобы
объект контекста устройства не хранил некорректный дескриптор
после удаления объекта. При инициализации пера или кисти Windows добавляет
дескриптор, сохраняемый внутри объекта. При выборе пера или кисти объект
контекста устройства также сохраняет этот дескриптор. Когда объекты выходят
за пределы области видимости или удаляются, деструктор объекта уничтожает
дескриптор. Однако этот шаг не нужно выполнять, если объект контекста
устройства удаляется до удаления объекта пера или кисти.
В моей программе будут рисоваться два эллипса, первый по формуле x2 y2
( --- --- =1 ; a2 b2 а второй, по формуле
x=a cos t
( y=b sin t
Вот функция, которая рисует оба эллипса: void CEllipseView::OnDraw(CDC* pDC)
{
CEllipseDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc); float x, y, t, PI = 3.1415926; for (x = -pDoc->A; x A; x+=0.005)
{ y = sqrt(abs((1.0 - (x*x)/(pDoc->A*pDoc->A))*(pDoc->B*pDoc->B))); pDC->SetPixel(x*5+pDoc->A*5+10, y*5+pDoc->B*5+10, RGB(0xFF,0,0)); y = -sqrt(abs((1.0 - (x*x)/(pDoc->A*pDoc->A))*(pDoc->B*pDoc->B))); pDC->SetPixel(x*5+pDoc->A*5+10, y*5+pDoc->B*5+10, RGB(0xFF,0,0));
} for (t = -PI; t
{ x = pDoc->Ac * cos(t); y = pDoc->Bc * sin(t); pDC->SetPixel(x*5+MAX(pDoc->A,pDoc->Ac)*15+20, y*5+MAX(pDoc->B,pDoc->Bc)*5+10, RGB(0,0x20,0x80));
}
Для передачи параметров в функцию рисования я создал два диалоговых
окна, одно для первой формулы (первого эллипса), другое – для второй
формулы (второго эллипса). При нажатии на иконки эллипсов появляются эти
диалоговые окна и предлагается ввести соответствующие параметры формулы
эллипса. Диалоговые окна вызываются в файле EllipseDoc.Cpp, вот функции
вызова обоих диалоговых окон: void CEllipseDoc::OnNewEllipseProperties()
{
CEditEllipseProperties dlg; dlg.m_A = A; dlg.m_B = B; dlg.DoModal();
A = dlg.m_A;
B = dlg.m_B;
UpdateAllViews(NULL);
}
void CEllipseDoc::OnEditEllipseProperties2()
{
CEditEllipseProperties dlg; dlg.m_A = Ac; dlg.m_B = Bc; dlg.DoModal();
Ac = dlg.m_A;
Bc = dlg.m_B;
UpdateAllViews(NULL);
}
Глава 3.Печать и предварительный просмотр
1)Основы печати и предварительный просмотр
2)Усовершенствованная печать
В этой главе я объясню, как выполняется печать текстов и графических
изображений, а также предварительный просмотр внешнего вида документа перед
печатью. А также, как выполняются стандартные команды Print..., Print
Preview и Print Setup из меню File. Так как в Windows применяется модель
вывода данных, не зависящая от устройств, для отображения текста и графики
на печатной странице можно использовать уже известные вам способы.
Рассмотрим особые способы печати - выбор и установку принтера, разбиение
документа на страницы и другие действия, необходимые для работы принтером.
Прежде всего рассмотрим как обеспечивается поддержка печати, позволяющая
программе печатать или предварительно просматривать одну страницу. Показаны
более совершенные способы печати или просмотра страниц документа, который
не помещается на одну страницу. Примеры добавления средств поддержки печати
и предварительного просмотра приведены в программе .
Основы печати и предварительный просмотр
При генерации новой программы с использованием мастера AppWizard, в нее
можно включить основные средства поддержки печати и предварительного
просмотра, установив опцию Printing And Print Preview в диалоговом окне
(Step 4) AppWizard , в следствие чего команды Print..., Print Preview и
Print Setup... добавляются в меню программы File. При реализации мастером
AppWizard команда Print... печатает ту часть документа, которая помещается
на одной странице. Оставшаяся часть документа игнорируется.
Подобным образом команда Print Preview отображает распечатку,
появляющуюся на одной странице документа. Как вы увидите, команды Print...
и Print Preview вызывают функцию OnDraw, чтобы сгенерировать реально
выводимую текстовую или графическую информацию. Команда Print Setup...
отображает обычное диалоговое окно Print Setup, позволяющее выбрать тип
принтера и задать его установки.
В этом разделе в мою программу Ellipse добавлены все средства печати,
позволяющее печатать так же, как и при выборе опции Printing And Print
Preview в первом варианте программы, сгенерированном мастером AppWizard. В
новую версию моей программы Ellipse включены все средства, которые вошли в
программу.
Модификация ресурсов
Чтобы отобразить ресурсы программы, перед началом модификации ресурсов откроем проект Ellipse и вкладку Resource View в окне Workspace. Затем откроем меню idr_mainframe в конструкторе меню. Непосредственно под существующей командой Save As... в меню File добавляем разделитель и команды Print..., Print Preview и Print Setup....
Откроем в редакторе акселераторов таблицу idr_main frame, чтобы задать
клавиатурный акселератор для команды Print... (Ctrl+P). Добавим акселератор
с идентификатором id_file_print и комбинацией клавиш Ctrl+P.
Теперь необходимо включить в файл определения ресурсов Ellipse некоторые
дополнительные предопределенные ресурсы. Для этого выбираем команду
Resource Includes... в меню View Developer Studio. В диалоговом окне
Resource Includes добавляем конце текста в поле Compile-Time Directives
следующую строку:
#include "afxprint.re"
Щелкаем на кнопке ОК, а после запроса Developer Studio подтверждаем свои
действия. Добавление этой строки предписывает компилятору ресурсов добавить
их определения, содержащиеся в списке Afxprint.rc, которые задают несколько
ресурсов, используемых для поддержки команд Print... и Print Preview
программы (например, диалоговое окно Printing, отображаемое во время
печати).
Модификация текста программы
Первый шаг модификации текста программы состоит в создании обработчика
для новой команды Print Setup..., добавленной в меню File. Его не нужно
писать самостоятельно, так как класс cwinApp предоставляет обработчик,
называемый OnFilePrintSetup. Однако MFC не добавляет его в схему сообщений,
т. е. текущая функция не получает управление при выборе команды Print
Setup... Следовательно, его необходимо вручную добавить в схему сообщений
класса приложения Ellipse. Для этого откроем файл Ellipse.cpp и добавим
операторы, выделенные полужирным шрифтом, в определение схемы обработки
сообщений.
////////////////////////////////////////////////////////////////
// Класс CMiniDrawApp
BEGIN_MESSAGE_MAP(CMiniDrawApp, CWinApp) //{{AFX_MSG_MAP(CMiniDrawApp)
//-Входы' схемы обработки сообщений мастера ClassWizard ...
//}}AFX_MSG_MAP
// Команды работы с файлами документов • ON_COMMAND(ID_FILE_NEW,
CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
ON_COMMAND (ID_FILE_PRINT_SETUP, CWinApp: : OnFilePrintSetup) END
MESSAGE MAP()
Новая запись в схеме сообщений приводит к тому, что при выборе команды
PrintSetup... будет вызываться функция CWinApp:: OnFilePrintSetup. Функция
' OnFilePrintSetup отображает диалоговое окно PrintSetup, в котором нужно
выбрать тип принтера и установить его параметры. Это все, что необходимо
для поддержки команды PrintSetup...
Подобным образом класс cview предоставляет обработчики сообщений для
стандартных команд меню Print и Print Preview. Эти обработчики необходимо
активировать, добавив их в схему сообщений для класса представления
программы Ellipse. Откроем файл Ellipse.cpp и добавим следующие две записи
в конце схемы обработки сообщений.
BEGIN_MESSAGE_MAP(CEllipse,CScrollView) //{(AFX_MSG__MAP(CEllipse)
ON_WM_LBUTTONDOWN() ON_WM_MOUSEMOVE() ON_WM_LBUTTONUP()
//}}AFX_MSG_MAP
ON_COMMAND(ID_FILE_PRINT,CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW,CView: : OnFilePrintEreview)
END_MESSAGE_MAP() .
Обе функции, CView:: OnFilePrint и CView: :OnFilePrintPreview, управляют
операциями печати. Однако OnFilePrint передает результат на
принтер, а функция OnFilePrintPreview — в окно предварительного просмотра
печати, отображаемое поверх обычного окна программы. При этом она
показывает результат в виде одной или двух печатаемых страниц. В процессе
управления печатью эти функции вызывают виртуальные функции, определенные
внутри класса CView. Реализация виртуальных функций в классе CView по
умолчанию накладывает ограничение на процесс печати. Для улучшения
возможностей программы печати одну (или более) из этих функций можно
переопределить.
Чтобы реализовать поддержку печати или предварительного просмотра печати,
необходимо переопределить только виртуальную функцию OnPreparePrinting. MFC
вызывает ее либо перед печатью, либо перед предварительным просмотром.
Чтобы создать функцию OnPreparePrinting для программы Ellipse, вызовите
мастер ClassWizard, откроем вкладку Message Maps, выберем CEllipse в
списках Class Name и Object Ids, а в списке Messages — OnPreparePrinting и
щелкнем на кнопке Add Function. Затем щелкнем на кнопке Edit Code, в
функции OnPreparePrinting удалим вызов основной версии функции
OnPreparePrinting и добавим вызов функции CView::DoPrepa-rePrinting.
BOOL CEllipse:;OnPreparePrinting(CPrintInfo* pinfo) (
// TODO: Здесь добавьте собственный код обработчика
// и/или вызов базового класса
return DoPreparePrinting (pinfo); // удалите вызов // CScrollView::
OnPreparePrinting(pinfo)
)
Функция DoPreparePrinting создает объект контекста устройства, связанный с принтером. Если документ печатается, то DoPreparePrinting отображает обычное диалоговое окно Print, позволяющее выбрать определенный принтер и установить несколько опций печати. Затем функция
создает объект контекста устройства для выбранного принтера и задает для
него выбранные установки. Однако при предварительном просмотре документа
функция DoPreparePrinting создает объект контекста устройства для текущего
стандартного принтера Windows, а затем присваивает стандартные установки
принтера, не отображая диалоговое окно Print. Если объект контекста
устройства связан с принтером, он дополнительно сохраняет установки
принтера при сохранении атрибутов и инструментов рисования, описанных в
предыдущих главах. Обратите внимание: функцию OnPreparePrinting необходимо
создать, так как ее стандартная версия ничего не выполняет. Это может
привести к тому, что MFC попытается напечатать или просмотреть документ без
наличия корректного объекта контекста устройства.
Примечание
Указатель на объект класса cprintinfo передается во все виртуальные функции выполнения печати. Этот объект содержит информацию о печати и предоставляет функции и переменные, которые используются виртуальными функциями для получения или изменения установок принтера. Например, если известен номер печатаемой страницы документа, то из функции
OnPreparePrinting можно вызвать функцию Cprintinfo: :SetMaxPage {перед вызовом DoPreparePrinting), чтобы задать номер печатаемой страницы. Тогда при печати документа этот номер отобразится в диалоговом окне Print (в текстовом поле То). При просмотре документа предоставление этого номера приведет к отображению MFC полосы прокрутки в окне предварительного просмотра, что позволит прокручивать страницы документа. MFC должно передаваться общее число страниц для корректной установки позиции бегунка на полосе прокрутки.
После того как MFC вызовет функцию OnPreparePrinting, чтобы подготовить
объект контекста устройства для печати или просмотра, она передает этот
объект в функцию OnDraw класса представления. Поскольку объект контекста
устройства связывается с принтером, а не с окном представления, выводимая
графическая информация появляется на печатаемой странице (или в окне
предварительного просмотра печати), а не внутри окна представления.
Единственная программа рисования внутри функции OnDraw имеет возможность
отобразить выводимую информацию как в окне представления, так и при печати,
поскольку вызываемые для этого функции класса CDC в достаточной степени
аппаратно независимы.
Примечание Когда документ печатается или просматривается, MFC готовит объект контекста устройства, связанный с принтером, и передает его в функцию OnDraw. Однако при просмотре документа код MFC в объекте контекста устройства фактически передается в окно предварительного просмотра. При этом используется отдельный контекст устройства, который связан с окном представления и задает установки для имитации печатаемой страницы.
Теперь можно построить и выполнить новую версию программы Ellipse. Если
выбрать команду Print Setup..-, программа открывает одноименное диалоговое
окно, позволяющее выбрать принтер, принимающий выводимую на печать
информацию (если в Windows установлено несколько принтеров), и задать
некоторые его параметры. Щелчок на кнопке Properties... в диалоговом окне
Print Setup позволяет получить доступ ко всем имеющимся установкам принтера
(в зависимости от выбранного принтера).
При выборе команды Print... программа откроет диалоговое окно Print. В диалоговом окне Print можно выбрать принтер, принимающий выводимую
информацию, и указать некоторые параметры печати (качество печати и число
копий). Щелчок на кнопке Properties... в диалоговом окне Print позволяет
изменить любой из доступных параметров принтера непосредственно перед
печатью. Эти же параметры отображаются при щелчке на кнопке Properties... в
диалоговом окне Print Setup. Если рисунок печатается не очень быстро, то во
время печати будет видно диалоговое окно Printing. В этом окне можно
щелкнуть на кнопке Cancel, чтобы остановить работу принтера. Если сделать
это до передачи Print Manager выводимой информации, то печать выполняться
не будет.
Добавление средств печати в окно представлений класса CEditView
Если класс представления в программе наследуется из класса CEditVtew, то
MFC и Windows предоставляют большую часть кода, требуемого для печати. Даже
если в мастере AppWizard не была выбрана опция Printing and Print Preview,
можно реализовать команды Print..., Print Preview и Print Setup самому,
потратив небольшие усилия на программирование.
Чтобы реализовать команду Print..., просто добавим ее в меню File, задав
идентификатор id_file_print_preview, без дальнейшего изменения кода.
Результирующая команда Print будет печатать весь текст документа,
занимающий даже более одной страницы.
Для реализации команды Print Preview добавим ее в меню File, присвоив
идентификатор id_e'ile_print_preview, затем добавим в схему сообщений
оператор include для вставки файла Afxprint.rc и макрос on_command для
класса представления.
Чтобы реализовать команды Print... или Print Preview, не нужно создавать
функцию OnPreparePrinting.
Усовершенствованная печать
С добавленными средствами печати программа Ellipse печатает или
просматривает только часть рисунка, поместившуюся на одной странице.
Оставшаяся часть рисунка игнорируется. В этом разделе возможности программы
будут расширены таким образом, чтобы она печатала весь рисунок. Любая часть
рисунка, которая не поместилась на одной странице, будет печататься на
дополнительных. Как вы увидите, это достигается переопределением некоторых
вызываемых при печати виртуальных функций.
Заметим: текущая версия функции OnDraw всегда рисует границу справа и
внизу рисунка. Однако граница служит только для ограничения рисунка внутри
окна представления. На печатной копии рисунка она не появляется. В этом
разделе команда OnDraw модифицируется таким образом, что граница будет
печататься только в случае, если выводимая информация направляется в окно
представления.
Изменение размера рисунка
В программе Ellipse устанавливается размер рисунка 640 на 480 пикселей .
Для большинства принтеров рисунок такого размера легко помещается на одной
странице. Чтобы продемонстрировать способы печати нескольких страниц,
необходимо модифицировать программу Ellipse для работы с рисунками, размеры
которых превышают стандартную печатную страницу. Чтобы выполнить это,
сначала определим целочисленные константы для ширины и высоты рисунка в
начале файла Ellipse.h.
consfc int DRAWWIDTH = 4000; // ширина рисунка const int DEAHHEIGHT =
6000; // высота рисунка
class CEllipse : public CScrollView (
В функции OnlnitialUpdate файла Ellipse.cpp используем эти константы вместо числовых значений (640 и 480).
void CEllipse::OnlnitialUpdate()
(
// TODO: Здесь добавьте собственный код
// и/или вызов базового класса
SIZE Size = (DRAHWTDTH, DBAWHEIGHT}; SetScrollSizes (MM_TEXT, Size) ;
}
Использование констант drawwidth и drawheight вместо числовых значений
облегчает изменение размера рисунка.
При изменении размера рисунка необходимо изменить номер версии,
используемый для сериализации документа, чтобы не прочитать по ошибке файл,
созданный предыдущей версией (или, используя предыдущую версию программы,
прочитать файл, созданный текущей версией). Для этого откроем файл
Ellipse.cpp и изменим номер версии с 2 на 3 в каждом вхождении макроса
implement_serial (мы должны найти восемь вхождений). Например, мы должны
изменить макрос
IMPLEMENT_SERIAL (CFigure, CObject, 2)
на
IMPLEMENT_SERIAL (CFigure, CObject, 3)
Примечание Программа рисования обычно позволяет устанавливать размер каждого рисунка чаще всего с помощью команды меню Options программы. Если рисунок сохраняется в файле на диске, то его размер тоже будет сохранен вместе с данными для отдельных фигур.
Заключение.
Столкнувшись впервые с Visual C++, я испытал массу трудностей, часть
трудностей до сих пор не преодолена мной. Непривычность среды, да даже не
среды, а вообще незнания визуального языка, и привычка писать на
стандартных языках программирования CC++, Pascal, Basic сделали мою работу
очень медленной и сложной, даже та подробная литература, которая была у
меня и которую я использовал практически неотрывно мало помогала. Прежде
всего возникла масса вопросов, на которые книга не могла бы дать ответов.
Сразу же возникла путаница со «слишком большим» (по моим меркам)
количеством файлов, каждый из которых отвечает за определённые классы и
функции и приходилось постоянно обращаться к литературе, чтобы понять и
осмыслить назначение каждого класса и файла. Поиски литературы в интернете
особых результатов не принесли, зато я почерпнул массу полезных курсов (или
уроков) «молодого бойца», которые во многом помогли мне разобраться в этом
непривычном начинании. Имея некоторое знакомство с языком Visual Basic и
проведя сравнение с Visual C++ , я бы сказал, что среда Visual C++
значительно сложнее для восприятия чем бейсик, хотя на то он и Basic (see
english translation) особенно для восприятия и самообучения. Несомненно
нужен учитель или хотя бы человек, который подсказывал некоторые непонятные
и труднопроходимые моменты.
Очень порадовали классы MFC, без них работа была бы просто невыносимой.
Многим может показаться, что создание программы с помощью MFC это слишком
просто и ничего особенного не представляет, но на самом деле это довольно
сложно, хотя со временем очень привыкаешь и без труда пользуешься этим
удобным «инструментом».
Надеюсь, в недалёком будущем я разберусь в среде Visual C++ более
подробно и досконально и у меня уже не будет такого огромного количества
трудностей, как при первых шагах в Visual C++.
Литература и источники.
1. Майкл Дж. Янг «Visual C++6. Полное руководство»
Michel J. Young “Mastering Visual C++6.”
«Ирина», BHV,Киев-1999.
2. Ю. Тихомиров «Visual C++6. Новые возможности для программистов»
Дюссельдорф, Киев, Москва, Санкт-Петербург, BHV 1999.
3. Microsoft Visual C++ FAQ
(Microsoft Visual C++/Microsoft Foundation Classes (MFC)
Frequently Asked Questions Version 5.6)
4. http://www.vc.nn.ru/lessons/index.html
5. http://www.mjk.msk.ru/~dron/
6. http://mark5.dhtp.kiae.ru/