Визуальные средства разработки программных приложений

На первых порах, когда вы только начинаете работать с MFC, многим кажется очень непривычной разница между экземпляром класса окна MFC и элементом Windows, который он представляет. Например, когда вы создаете объект класса фрейма MFC, в действительности создаются два объекта -- MFC-объект класса окна, который имеет члены-функции и переменные, и окно Windows, которым можно манипулировать, используя функции MFC-объекта. Элемент Windows ассоциируется с соответствующим классом, но сам по себе также представляет некую сущность.

В классе документа (Doc.cpp) за перерисовку окна отвечает функция

UpdateAllViews()

В классе представления (View.cpp) за перерисовку окна отвечает функция

Invalidate()

Вызов функции Invalidate() приводит к тому, что МFС обращается к функции OnDraw(), которая, в свою очередь, перерисовывает изображение на экране. Invalidate() принимает единственный аргумент (его значение по умолчанию-- TRUE), который указывает, нужно ли стирать прежнее изображение перед прорисовкой нового функцией OnDraw(). Хотя и редко, но бывают случаи, когда удобнее вызывать Invalidate() с аргументом FALSE, и тогда OnDraw() будет рисовать поверх прежнего изображения.

12.Вывод на экран. Контекст устройства. Классы контекстов устройства в MFC

Вывод на экран

Большинство приложений нуждается в выводе определенной информации на экран. На первый взгляд кажется, что, поскольку Windows является системой, не зависящей от аппаратных средств, сформировать изображение на экране для нее не сложно. Однако на деле именно эта "независимость" и перекладывает большую часть нагрузки на плечи программиста. Вы не знаете, с устройством какого типа придется иметь дело вашему приложению, но должны задать все необходимые параметры для его настройки. Средства вывода работают с аппаратурой через промежуточное звено, которое называется контекстом устройства (device context -- DC).

Независимость Windows от аппаратных средств, с одной стороны, причиняет программисту головную боль в связи с усложнением методики программирования операций отображения информации, и, с другой стороны, избавляет от необходимости настраивать программу на каждый новый вариант аппаратуры отображения. В большинстве случаев Windows управляет устройствами посредством специальных программ -- драйверов. Драйверы принимают информацию от приложения и передают соответственно этой информации данные конкретному устройству -- монитору, принтеру или какому-нибудь другому устройству.

Связывается драйвер с приложением посредством специальной структуры данных, названной контекстом устройства.

Контекст устройства -- это структура C++, которая содержит атрибуты рабочего поля окна. Эти атрибуты включают выбранное для текущей операции перо, кисть и шрифт. Контекст устройства в каждый момент времени располагает только одним пером, кистью или шрифтом. Если вам понадобится некоторую часть изображения нарисовать другим пером, например более толстым, придется, во-первых, создать такое новое перо, а во-вторых, внести его в контекст устройства вместо старого. Точно так, если вы хотите заливать контуры красной кистью, придется ее создать и "выбрать ее в контекст" --- так программисты называют операцию замены инструмента в контексте устройства.

Рабочая область окна (window's client area) -- это часть поверхности экрана, в которой можно отображать все, что посчитает нужным приложение: текст, таблицы данных, картинку и т.д. Определенную помощь в этом вам окажет библиотека MFC, которая инкапсулирует функции графического интерфейса Windows (Graphic Device Interface-- gdi) в свои классы контекста устройств.

Контекст устройства также можно представить как лист бумаги, на котором будет производиться рисование.

Драйвер устройства - это специальная программа, которая умеет этот самый контекст перевести на конкретное устройство

В MFC есть несколько контекстов устройств и все наследники от CDC.

CObject -

| |-> CClientDC

| |-> CWindowDC

CDC----->|-> CMetaFileDC

|-> CPaintDC

Каждый из контекстов рисует в определенном месте, то есть каждый контекст предназначен для рисования в определенной области. При этом CPaintDC и CClientDC очень похожи. Оба эти класса предназначены для рисования внутри клиентской области окна. То есть они не могут добраться до меню или рамки окна. Чем они отличаются ? CPaintDC используется только тогда когда отвечает на сообщение WM_PAINT. Вместе с этим сообщением будет передана та область, которая требует перерисовки. Ведь окно может быть на экране не полностью. Для извещения о перерисовке вызываются функции BeginPaint и EndPaint, без их вызова Windows будет считать, что перерисовка не произошла. Вот в этом и существенные отличия CPaint, в его конструкторе автоматически вызывается BeginPaint, а в деструкторе EndPaint. CClientDC не выполняет эти функции автоматически. CClientDC вызывает функцию GetDC, а деструктор ReleaseDC .

Если вы хотите получить доступ ко всему окну, то должны использовать класс CWindowDC этот класс позволит вам рисовать и поверх меню и везде в пределах рамки окна определенной при создании окна.

Контекст CMetaFileDC используется для работы с метафайлами, рисование из которых может выполняться многократно.

Функции, находящиеся в классе контекста устройства обеспечивают:

связь с физическим устройством

набор изобразительных средств

регулирование вывода

Смысл физической связи в том, что вы можете рисовать на устройстве, не заботясь о том, как это устройство физически работает. Например, монитор. Вас не интересует его производитель, марка и другие особенности. За это отвечает драйвер, связанный с контекстом устройства.

Набор изобразительных средств - это то, чем вы можете рисовать. Контекст устройства дает вам перья, кисти, умеет делать некоторые операции по рисованию примитивов. То есть он дает инструментарий по рисованию.

Регулировка вывода связана с необходимостью следить за тем, что часть экрана может перекрываться другими областями и поэтому в них рисовать нельзя.

13. Классы изобразительных средств. Примеры рисования простейших фигур

Классы изобразительных средств

В контексте устройства есть ряд классов изобразительных средств, которые являются наследниками CGdiObject. В MFC их шесть.

CObject - |-CBitmap

| |-CBrush

CGdiObject---|-CFont

|-CPalette

|-CPen

|-CRgn

Теперь кратко о каждом классе. CBitmap - это класс, который умеет работать с растровыми изображениями. CBrush - это кисть для рисования. CFont - класс шрифта текста. CPalette - класс умеющий работать с цветовыми палитрами. CPen - класс пера и CRgn - класс региона, то есть области вывода.

Рисование простейших фигур

Рассмотрим примеры:

Вывести строку:

void CMainWnd::OnPaint()

{

CPaintDC dc(this);

dc.TextOut( X1, Y1,"TextOut Samples");

}

Вывести точку, чем выше разрешение экрана, тем меньше точка.

void CMainWnd::OnPaint()

{

CPaintDC dc(this);

dc.SetPixel(500,200,RGB(255,0,0));

}

Дуга окружности:

void CMainWnd::OnPaint()

{

CPaintDC dc(this);

dc.Arc(200,200,100,100,400,400,10,10);

}

Замкнутая дуга:

void CMainWnd::OnPaint()

{

CPaintDC dc(this);

dc.Chord(250,250,100,100,400,400,10,10);

}

Эллипс:

void CMainWnd::OnPaint()

{

CPaintDC dc(this);

dc.Ellipse(450,450,50,150);

}

Линия:

void CMainWnd::OnPaint()

{

CPaintDC dc(this);

dc.MoveTo(200,200);

dc.LineTo(100,100);

}

Как выполняется рисование и вычерчивание в программе, использующей MFC

Одно из основных сообщений, которое должна уметь обрабатывать любая Windows-программа, -- сообщение WM_PAINT. Операционная система Windows посылает это сообщение окну приложения (точнее-- объекту, представляющему окно) при любой; операции, требующей перерисовки изображения в окне. Несколько событий могут стать причиной возникновения необходимости в такой перерисовке.

*Первое из них -- запуск программы. В правильно организованной Windows-программе окно приложения получает сообщение WM_PAINT практически немедленно после запуска с тем, чтобы данные, соответствующие исходному состоянию приложения, сразу же были предъявлены пользователю.

*Другое событие, требующее перерисовки окна, а значит, и генерирующее сообщение WM_PAINT, -- изменение размеров окна или перекомпоновка окон на экране. В последнем случае окно приложения может стать верхним или быть частично перекрытым другим окном. В любом случае приоткрывается хотя бы часть окна и изображение в нем должно быть перерисовано.

*И наконец, программа может посылать сообщение WM_PAINT сама себе с тем, чтобы удалить старые данные на экране и вывести новые. Такая возможность позволяет приложению всегда держать пользователя в курсе происходящих событий. Например, текстовый процессор может стереть на экране старый текст сразу же после вставки некоторого фрагмента текста из системного буфера.

Когда будем рассматривать карту сообщений, мы познакомимся с соглашением о преобразовании идентификатора сообщения в имя макроса карты сообщений и имя функции. Для сообщения - WM_PAINT , соответствующий макрос будет называться ON_WM_PAINT(), а соответствующая функция-- OnPaint(). Это пример того, как MFC берет на себя значительную часть работы по соотнесению сообщений Windows с функциями их обработки.

Текст функции CView::OnPaint() представлен ниже.

void CView::OnPaint()

{// Стандартная последовательность вызовов для прорисовки.

CPaintDC dc(this);

OnPrepareDC(&dc);

OnDraw(&dc);

}

Класс CPaintDC -- это специальный класс для управления контекстами отрисовки (paint DCs) -- контекстами устройств, которые используются только для реакции на сообщения WM_PAINT. Объект класса CPaintDC делает нечто большее, чем просто создание контекста устройства. Он также вызывает BeginPaint() -- функцию Windows API -- в конструкторе класса и функцию EndPaint() -- в деструкторе. В процессе реакции на сообщение WM_PAINT необходимо вызывать и BeginPaint(), и EndPaint(). Класс CPaintDC избавляет вас от необходимости заботиться о таких мелочах. Конструктор класса CPaintDC требует одного аргумента-- указателя на объект, представляющий окно, для которого и создается контекст устройства. Указатель this указывает на текущее окно, т.е. конструктору дается задание создать контекст для текущего окна.

Функция ОnРгерагеDС() является членом класса CView. Она подготавливает контекст устройства для дальнейшего использования.

Функция OnDraw() берет на себя всю работу по обновлению представления документа на экране. В большинстве случаев для каждого приложения нужно разрабатывать собственную функцию OnDraw() и никогда не вносить изменений в предлагаемый MFC текст функции OnPaint().

Изменение размеров и положения окна

В программе, использующей MFC, можно изменить размеры и положение окна с помощью функции PreCreateWindowO-- члена класса главного окна приложения. Она вызывается автоматически перед началом формирования главного окна приложения. В главном окне содержатся все видимые объекты приложения и определяется размер представления.

Функция PreCreateWindow() имеет один аргумент-- ссылку на экземпляр структуры CREATESTRUCT. Эта структура содержит всю информацию об окне, которое должно появиться на экране.

Если при создании приложения Windows вы не будете пользоваться библиотекой MFC, то со структурой CREATESTRUCT столкнетесь при обращении к функции API CreateWindow(), которая формирует окно приложения. Особое внимание тех, кто программирует с помощью MFC, привлекают члены сх, су, х и у. Изменяя сх и су, можно регулировать ширину и высоту окна, а изменяя х и у, -- положение окна на экране. Перегрузив функцию PreCreateWi ndow(), вы получаете шанс пообщаться со структурой CREATESTRUCT еще до того, как Windows использует ее для формирования окна.

AppWizard уже создал CMainFrame:: PreCreateWindow(). Так что можете развернуть класс СМаin Frame в окне ClassView, дважды щелкнуть на названии PreCreateWindow() и отредактировать текст функции-- включить в нее фрагмент:

BOOL CMainFrame: : PreCreateWindow(CREATESTRUCT& cs)

{cs.cx = 440;

cs.cy = 480;

if(!CFrameWnd::PreCreateWindow(cs)) return FALSE;

return TRUE;}

Эти операторы устанавливают новые высоту и ширину окна приложения.

14.Использование перьев. Работа с кистью

Использование перьев

Для пера требуется определить стиль начертания линии, ее толщину и цвет. Рассмотрим функцию ShowPens() , которая формирует различные типы перьев в теле цикла for.

void CPaint1View::ShowPens(CDC * pDC)

{

// Инициализировать положение линии.

UINT position =10;

// Начертить шестнадцать линий.

for (UINT x=0; х<16; ++х)

{

// Сформировать новое перо и выбрать его в контекст.

CPen pen(PS_SOLID, x*2+1, RGB(0, 0, 255));

CPen* oldPen = pDC->SelectObject(&pen);

// Начертить линию новым пером.

position += x * 2 + 10;

pDC->MoveTo(20, position);

pDC->LineTo(400, position);

// Восстановить прежнее перо в контексте.

pDC->SelectObject(оldPen);

}

}

В теле цикла ShowPens() сначала формирует новое перо -- экземпляр класса CPen. Конструктору требуется передать три параметра. Первый-- стиль линии. Варианты стилей:

Стиль Описание'

PS DASH Перо вычерчивает штриховую линию

PS DASHDOT Перо вычерчивает штрихпунктирную линию

PS DASHDOTOOT Перо вычерчивает штрихпунктирную линию с двумя точками

PS DOT Перо вычерчивает пунктирную линию

PS INSIDEFRAME Перо используется для вычерчивания линий внутри замкнутого контура

PS NULL Перо вычерчивает невидимую линию

PS SOLID Перо вычерчивает сплошную линию

Только сплошные линии могут иметь регулируемую толщину. Все линии, вычерчиваемые по шаблону, должны иметь толщину 1. Второй параметр -- толщина линии, которая увеличивается в каждом последующем цикле. Третий параметр-- цвет линии. Макрос RGB принимает три значения соответственно для красной, зеленой и синей составляющих, и преобразует их в комбинированный код цвета, воспринимаемый Windows. Значения интенсивностей компонентов находятся в диапазоне 0-255 (естественно, чем больше величина, тем более интенсивный цвет).

RGB(0, 0, 0), // черный

RGB(255,0, 0), // красный

RGB (0,255., 0), // зеленый

RGB(0,0, 255), // синий

RGB(255,255, 0), // желтый

RGB(255,0, 255), // пурпурный

RGB(0,255,255), // голубой

RGB(127,127, 127), // серый

RGB(255,255, 255)};// белый

Тот код, который присутствует во фрагменте текста в листинге, задает синий цвет максимальной интенсивности. Если все компоненты цвета будут равны нулю, получим абсолютно черное перо; максимальное значение всех компонентов создаст белое перо.

Покончив с созданием нового пера, функция ShowPens() выбирает его в контекст, сохраняя, тем не менее, указатель старого пера. Метод MoveTo() перемещает перо в точку с координатами X,Y без вычерчивания; метод LineТо() собственно и выполняет вычерчивание, "передвигая" перо вдоль прямой линии. При этом используются заказанные стиль, толщина и цвет пера. И последнее -- в контексте восстанавливается прежнее перо.

Работа с кистью

Перо вычерчивает на экране линии заданной толщины. Кисть же закрашивает (заливает) внутреннюю область замкнутых фигур. Можно создавать сплошные кисти или стандартные трафаретные (pattern) и даже творить кисти из растровых картинок, которые будут содержать трафареты, созданные вашей фантазией. Функция ShowBrushes() продемонстрирует как сплошные кисти, так и стандартные трафаретные, которые будут использованы для заливки прямоугольников.

void CPaintlView::ShowBrushes(CDC * pDC)

{ '

// Инициализировать расположение прямоугольника.

UlNT position = 0;

//Выбрать перо для вычерчивания контура прямоугольника.

СРеn pen(PS_SOLID, 5, RGB(255, 0, 0));

CPen* oldPen = pDC->SelectObject(&pen);

// Начертить семь прямоугольников.

for (UINT x=0; x<7; ++x)

{

CBrush* brush;

// Создать сплошную или заштрихованную кисть

if(x==6)

brush = new CBrush(RGB(0,255,0));

else

brush = new CBrush(x, RGB(0,160,0));

//Выбрать новую кисть в контекст.

CBrush* oldBrush = pDC->SelectObject(brush);

// Начертить прямоугольник.

position += 50;

pDC->Rectangle(20, position, 400, position + 40);

// Восстановить контекст и стереть кисть.

pDC->SelectObject(oldBrush);

delete brush;

}

//Восстановить прежнее перо в контексте

pDC->SelectObject(oldPen);

}

Все прямоугольники, закрашиваемые различными кистями, будут вычерчены с видимой линией контура. Для этого нужно создать перо (стиль -- сплошное, толщина -- 5 пикселей, цвет-- ярко-красное) и выбрать его в контекст устройства. Оно будет безо всяких на то дополнительных указаний использовано для вычерчивания контуров прямоугольников. Подобно функции ShowPensO, эта программа также использует для демонстрации кистей цикл for. Однако в отличие от предыдущей функции новые объекты (в этой функции -- кисти) создаются вызовом new. Это позволяет использовать то конструктор с одним аргументом, который создает сплошную кисть, то конструктор с двумя аргументами, который создает трафаретную кисть.

Первый аргумент двухаргументного конструктора есть переменная цикла х;

Обычно вам не нужно показывать все трафареты заливки, следует только выбрать некоторый Подходящий. Можно использовать одну из перечисленных ниже констант трафаретов.

*HS..HORIZONTAL (горизонтальный)

*HS_VERTICAL (вертикальный)

*HS_CROSS (прямая клетка)

*HS_FDIAGONAL (диагональный, наклон влево)

*HS_BDIAGONAL (диагональный, наклон вправо)

*HS_D I AGONALCROSS (косая клетка)

В теле цикла в контекст выбирается один из этих трафаретов, определяется положение очередного прямоугольника в поле окна и затем вызывается функция Rectangle(), которая и использует контекст с включёнными в: него пером и кистью. После всего этого в контексте восстанавливается прежняя кисть. После выхода из цикла в контексте восстанавливается и перо.

Метод Rectang1е() -- это только один из методов, используемых для построения на экране замкнутых фигур. Rectanglе()использует в качестве аргументов координаты левого верхнего и правого нижнего углов вычерчиваемого прямоугольника: Среди других методов, представляющих определенный интерес,--Chord (), , Ellipse(), Pie() - сектор, Polygon() - многоугольник, PolyPolygon() - массив многоугольников, Polyline() - линия, соединяющая массив точек, и RoundRect() - прямоугольник со скругленными углами.

15. Концепция сохранения - восстановления объектов. Необходимые действия по обеспечению возможности сохранения восстановления объектов класса CDocument. Разбор примера с сериализацией в классе документа

Сохранение и восстановление состояния объектов

Одна из основных задач программы -- сохранять данные пользователя после их изменения по той или иной причине. Без этого все усилия, которые пользователь затратил на редактирование данных, пропадут, как только приложение завершит работу. В большинстве случаев, когда приложение создается с использованием AppWizard, Visual C++ без Вашего участия включает в него программы, которые необходимы для сохранения и восстановления данных.

Одна из задач, решаемых программистом при разработке приложений, которые могут создавать и редактировать документы различных типов (например, различные редакторы), заключается в том, чтобы предоставить пользователю возможность записать внутреннее представление документа в файл и восстановить его

Процесс сохранения и восстановления внутреннего представления объекта называется сериализацией данных.

При создании приложения вам приходится иметь дело с достаточно большим разнообразием типов объектов. Одни типы объектов, хранящих данные, довольно просты, например тип int или chaг. Другие являются экземплярами классов ---строками (экземплярами класса CString) или даже объектами классов, созданными специально для данного приложения. При использовании таких, объектов в приложении, которое должно формировать, сохранять и восстанавливать документы, разработчику волей-неволей необходимо изобретать средства сохранения и восстановления этих объектов с тем, чтобы можно было их восстановить. Свойство объекта сохраняться и восстанавливаться называется живучестью (persistence). Практически все классы MFC наделены этим свойством, поскольку они прямо или косвенно происходят от базового класса CObject. Последний уже обладает базовыми функциями сохранения-восстановления объекта.

Приложения, подготовленные при помощи средства AppWizard, используют этот механизм с помощью методов класса CDocument.

Программисту предлагается только переопределить метод Serialize этого класса для работы с конкретными данными приложения.

Программист может определить свой класс (на основе базового класса CObject) для работы с данными и определить в нем механизм записи и восстановления объектов.

Создание класса, обеспечивающего сериализацию данных

Библиотека классов MFC определяет механизм записи и восстановления объектов (serialization), причем поддержка этого механизма осуществляется средствами класса CObject.

Классы, наследованные от CObject, также могут обеспечивать работу механизма записи и восстановления объектов. Для этого при объявлении класса надо указать макрокоманду DECLARE_SERIAL, а при определении - макрокоманду IMPLEMENT_SERIAL.

Макрокоманду DECLARE_SERIAL необходимо поместить в описании класса в заголовочном файле. В качестве параметра макрокоманды надо указать имя класса

DECLARE_SERIAL (имя_класса)

Макрокоманду IMPLEMENT_SERIAL следует указать перед упоминанием класса в файле исходного текста приложения. Прототип макрокоманды IMPLEMENT_SERIAL представлен ниже:

IMPLEMENT_SERIAL (имя_класса, имя_базового_класса, номер_версии)

Параметр имя_класса определяет имя класса, имя_базового_класса - имя базового класса, из которого непосредственно наследуется класс. Последний параметр номер_версии - это число типа UINT, определяющее версию программы. Если разрабатывается новая версия приложения и изменяется набор данных, которые необходимо записать в файл, нужно изменить значение параметра номер_версии.

В классе должны быть определены специальные методы для записи и восстановления состояния объектов этого класса. Обычно эти методы сохраняют и восстанавливают элементы данных из класса. Таким образом, объекты класса сами отвечают за то, как они сохраняют и восстанавливают свое состояние.

Методы, сохраняющие и восстанавливающие объекты, взаимодействуют с объектом класса CArchive, который осуществляет непосредственную запись и чтение информации из файла на диске.

Класс CObject содержит виртуальный метод Serialize, отвечающий за запись и чтение объектов классов, наследованных от класса CObject:

virtual void Serialize(CArchive& ar);

В качестве параметра ar методу передается указатель на объект класса CArchive, используемый для записи и восстановления состояния объекта класса CObject (или наследуемого от него класса). Чтобы узнать, какую операцию должен выполнить метод Serialize, необходимо воспользоваться методами IsLoading или IsStoring класса CArchive.

Итак, при создании нового класса, в котором метод Serialize применяется для сериализации данных, необходимо:

Чтобы класс был производным от класса CObject или его потомков.

При объявлении класса необходимо вставить макрокоманду DECLARE_SERIAL.

Определить в классе функцию Serialize, отвечающую за хранение переменных класса.

Определить в классе конструктор без параметров. Это может быть защищенный конструктор, если он вызывается только для процесса сериализации данных. В конструкторе возможно динамическое создание объектов и инициализация переменных, если это необходимо.

Объявить в классе деструктор, если требуется выполнить специальные действия при разрушении объектов класса, например, освободить память динамически созданных объектов.

При реализации класса в начало файла реализации вставить макрос IMPLEMENT_SERIAL. У этой макрокоманды три параметра: имя класса, имя базового класса и номер версии формата файла, хранящего документ. Можно иметь несколько модификаций документа и с каждой из них связать свою версию.

Шаблон (заготовка) файлов определения и реализации класса, который обеспечивает процесс сериализации данных

// фрагмент файла определения класса

class CMyDoc:public CObject

{

DECLARE_SERIAL(CMyDoc)

protected:

virtual void Serialize(CArchive& ar);

 protected:

CMyDoc();

protected:

~CMyDoc();

// другие описания класса

. . .

};

// фрагмент файла реализации класса

IMPLEMENT_SERIAL(CMyDoc, CObject,1)

CMyDoc::CMyDoc()

{

// здесь возможно динамическое создание объектов и

// инициализация переменных, если это необходимо

. . .

}

CMyDoc::~CMyDoc()

{

// здесь возможно выполнение специальных действий

// при разрушении объектов класса, например,

// освобождение памяти динамически созданных объектов

. . .

}

void CMyDoc::Serialize(CArchive& ar)

{

if(ar.Storing())

{

// здесь следует добавить код для записи переменных в архив

. . .

}

else

{

// здесь следует добавить код для чтения переменных из архива,

. . .

}

// здесь следует добавить вызовы методов Serialize для переменных

// класса CMyDoc, являющихся объектами классов,

// имеющих собственные методы Serialize

. . .

}

// другие методы класса

. . .

Рассмотрим примеры реализации сохранения-восстановления объектов.

При создании программы с помощью AppWizard мы получаем приложение, которое использует классы документа и представления для формирования, редактирования и отображения данных. При этом объект класса документа, производного от CDocument, отвечает за хранение данных в течение всего сеанса работы приложения, а также за сохранение и загрузку данных, так что документ сохраняет свое состояние после завершения одного сеанса работы с ним и восстанавливает в начале следующего сеанса.

Рассмотрим некоторое приложение, документ которого представляет собой единственную текстовую строку, которая выводится на экран классом представления. Предусмотрим в работе приложения три команды меню. При первом запуске текст сообщения автоматически устанавливается как Default Message. Его можно изменить, выполнив команду меню Edit->Change Message. Сохранить документ можно с помощью команды File->Save, а вновь загрузить -- с помощью File->Open.

Классы документа

Способность объектов сохраняться после изменения в одном сеансе и восстанавливать свое состояние в следующем, используя файл в качестве промежуточной среды хранения, есть ничто иное, как живучесть объектов с точки зрения пользователя. Рассмотрим реализацию концепции сохранения-восстановления в приложениями, созданными с помощью AppWizard.

Для SDI-приложения вы должны выполнить следующую последовательность операций, чтобы обеспечить возможность сохранения и восстановления документа.

Создание членов-переменных класса документа, которые будут хранить специфические для данного вида документа данные.

Инициализация этих членов-переменных в методе OnNewDocument( ) класса документа.

Организация отображения текущего состояния документа в методе OnDraw() класса представления.

Включение в класс представления методов, обеспечивающих редактирование документа.

Модификация метода Serialize() класса документа -- включение в него операторов, обеспечивающих сохранение и загрузку данных, которые и представляют собой содержание документа.

Что касается МDI-приложений; то, помимо перечисленных операций, придется сделать кое-что дополнительно, поскольку нужно обеспечить правильный выбор сохраняемого и корректную загрузку восстанавливаемого документов с учетом того, что приложение такого типа работает в течение одного сеанса с множеством документов одновременно. К счастью, большую часть этих функций MFC реализует без участия программиста.

Рассмотрим SDI--приложение My, построенное AppWizard и поддерживающее архитектуру документ/представление.

Определим данные, с которыми работает представление. Добавим в секцию атрибутов класса CMyDoc (в файле MyDoc.h) определение переменной m_message ,типа CString, чтобы этот фрагмент определения класса выглядел следующим образом:

//Атрибуты.

public:

CString m_message;

В данном случае документ содержит единственный объект класса CString-- строку текста. В реальных приложениях данные будут значительно сложнее. Однако этой единственной строки текста хватит, чтобы продемонстрировать особенности технологии обеспечения сохранности документа. Очень часто программисты используют в классе документа открытые члены-переменные вместо закрытых членов, для каждого из которых организуется открытая функция доступа. Это несколько облегчает разработку класса представления, методы которого должны обращаться к членам класса документа. Но в дальнейшем при сопровождении программы и, в частности, ее модификации такой подход несколько усложнит жизнь.

Класс документа также должен обеспечить инициализацию данных при открытии нового документа, что возлагается на метод OnNewDocument( ) этого класса. Вызовите при помощи окна ClassView текст этой функции в окно редактора кода и отредактируйте его. Добавьте оператор инициализации строковой переменной.

BOOL CMyDoc::OnNewDocument()

{if(!CDocument::OnNewDocument())

return FALSE;

m_message = "Default Message";

return TRUE;}

После того, как переменная m_message--член класса документа-- инициализирована, приложение должно вывести содержимое документа в свое окно. Здесь за дело берется метод OnDraw() класса представления. Вывести, текст этой функции в окно редактора кода можно уже известным вам способом при помощи окна Class View. После редактирования функция должна иметь вид:

void CMyView: :OnDraw(CDC* рDС)

{CMyDoc* pDoc = GetDocument();

ASSERT_VALID(pDoc);

pDC->TextOut(20,20, pDoc->m_message);

}

Если оттранслировать приложение My и запустить его на выполнение, вы увидите, что на экране появится сообщение Default Message.

Теперь необходимо обеспечить возможность редактирования. Для того чтобы обеспечить такую возможность, нужно включить в меню Edit приложения пункт Change Message. По этой команде должны запускаться средства, позволяющие пользователю изменить текст документа -- выводимого сообщения.

Щелкните на вкладке Resource в левой части экрана и вызовите окно ResourceView, разверните компонент Menu и дважды щелкните на IDR_MAINFRAME. Теперь можно приступить к редактированию меню. Щелкните на пункте Edit и разверните его. Щелкните на пустом поле внизу списка пунктов этого меню и введите Change &Message. В результате в меню будет добавлен новый пункт.

Теперь вызовите мастер СlassWizard. Он понадобится вам для установления связи между новой командой и текстом программы. В левом окне ClassWizard должен быть подсвечен пункт ID_EDIT_CHANGEMESSAGE. Если это не так, щелкните на этом пункте. В раскрывающемся .списке справа вверху выберите CMyView. Щелкните на COMMAND в окне справа, а затем-- на кнопке Add Function.

Предлагаемое мастером имя функции OnEditChangemessage () нам вполне подходит, так что щелкните на кнопке ОК в появившемся диалоговом окне. Теперь щёлкните на кнопке Edit Code -- заготовка новой функции будет выведена в окне редактора кода. Ее нужно отредактировать.

Void CmyView::OnEditChangemessage,() .{

CTime now = CTime::GetCurrentTime();

CString changetime = now.Format("Changed at %B %d %H:%M:%S");

GetDocument()->m_message = changetime;

GetDocument()->SetModifiedFlag();

Invalidate();}

Эта функция, формирует строку соответственно текущей дате и времени и присваивает ее переменной-члену текущего объекта класса документа. Вызов метода SetModifiedFlag() класса документа сообщит приложению, что содержимое документа изменено. Если такое изменение зафиксировано, приложение будет предупреждать пользователя о наличии несохраненных изменений в текущем документе при попытке его закрыть. И последняя операция -- запуск механизма обновления представления документа на экране, .который производится функцией Invalidate().

Если m_message является закрытой переменной-членом класса документа, понадобится разработать открытый метод SetMessage(), который будет самостоятельно вызывать SetModifiedFlagO. Таким образом, вы будете навсегда избавлены от необходимости напоминать программистам об обязательном обращении к этой функции при модификации объекта класса документа. В этом и состоит преимущество скрупулезного следования принципам объектно-ориентированного программирования.

Метод Serialize() класса документа должен позаботиться о сохранении-восстановлении данных документа. Текст заготовки функции Serialize(), сформиpoвaнный AppWizard, выглядит следующим образом

void CMyDoc::Serialize(CArchive& ar)

{if (ar.IsStoring())

{//}

else{//TODO: сюда вставьте операторы загрузки данных.}}

Поскольку в классе CString (объектом которого является переменная m_message) определены терминальные операторы >> и << для передачи данных в архив и из него, это значительно упрощает сохранение и восстановление данных в объекте класса документа. Добавьте следующий оператор в том месте, где в заготовке стоит инструктирующий комментарий:

ar<< m_message;

Аналогично в том месте текста программы, где должны стоять операторы загрузки, вставьте

ar>> m_message;

Терминальный оператор << пересылает CString m_message в архив, а терминальный оператор >> заносит данные в m_message из архива. До тех пор, пока данные документа сохраняются в члене-- простой переменной (наподобие int или char) или в объекте такого класса, как CString, для которых определены соответствующие терминальные операторы, сохранение и восстановление документа выполняются очень просто. Указанные терминальные операторы определены для следующих простых типов данных.

*BYTE *

*WORD

*int

*LONG

*DWORD

*float

*double

Оттранслируйте приложение My и запустите его. Выберите в меню приложения Edit=>Change Message и убедитесь, что на экране появилась новая строка сообщения, Changed at …. Теперь выберите File->Save и введите имя файла. Опять измените текст сообщения с помощью команды Edit->Change Message. Выберите File->New-- на экране появится предупреждающее сообщение о наличии в документе несохраненных изменений. Вам будет предложено сохранить их на диске прежде, чем открывать новый документ. Теперь выберите File=>0pen и введите имя ранее созданного файла документа (его можно найти и в списке в самом низу меню File). После этого на экране появится ранее сохраненный текст сообщения. Таким образом, вы можете убедиться, что приложение My сохранило документ по вашей команде, а затем восстановило его в прежнем виде.

Если в документ внесены изменения, он сохранен в файле, в него внесены новые изvенения и вызвана команда открыть файл с тем же именем, приложение My не будет выводить запрос Revert to saved document? (Вернуться к сохраненному документу?), как это делают другие программы. Вместо этого перед вами на экране будет самая последняя версия документа. Такой механизм встроен теперь в MFC. Если имя открываемого файла соответствует имени текущего, вы не сможете вернуться к прежней версии документа.

16. Создание класса, обеспечивающего сохранение-восстановление объектов. Разбор примера с сериализацией в классе CMessages

Создание класса, обеспечивающего сохранение-восстановление объектов

Что произойдет, если вы создадите свой собственный класс, объект которого войдет в документ? Как сделать этот объект живучим (в оговоренном выше смысле)?

Предположим, что вы хотите усовершенствовать приложение My таким образом, чтобы для хранения данных документа использовался объект изобретенного вами класса CMessages. Пусть теперь член класса документа, в котором содержатся данные, называется m_messages и он является экземпляром класса CMessages. Этот класс содержит три объекта класса CStгing, каждый из которых должен сохраняться и восстанавливаться при сохранении и загрузке документа. Первый способ обеспечить такую возможность -- индивидуально сохранять и восстанавливать каждую отдельную строку. Текст соответствующей программы представлен ниже

void СMyDoc::Serialize(CArchive& ar)

{

if (ar. IsStoring())

{

ar << m_messages.m_message1;

ar << m_messages.m_message2;

ar << m_messages.m_message3;

}

else

ar >> m_essages.m_essagel;

ar >> m_messages.m_message2;

ar >> m_messages.m_message3;

Такую программу можно написать в том случае, если, во-первых, все три члена класса CMessages являются открытыми (объявлены как publiс) и, во-вторых, известна реализация самого класса. Если в дальнейшем класс CMessages будет некоторым образом изменен, придется переписать и эту функцию. Если же вы до конца верны моральному кодексу строителя объектно-ориентированных программ, то непременно согласитесь, что функции сохранения и восстановления данных должны быть инкапсулированы в самом классе CMessages. Конечно, это потребует определенной предварительной подготовки. Основные этапы создания класса, который может самостоятельно организовать сохранение-восстановление (в документации на MFC применяется термин serialise -- сериализация) собственных членов-переменных, перечислены ниже.

1.Объявите класс как производный от CObject.

2.В объявление класса включите макрос DECLARE SERIAL.

3.В реализацию класса включите макрос IMPLEMENT_SERIAL.

4.Перегрузите метод Serialize(), унаследованный от базового класса.

5.Объявите для нового класса среди прочих "пустой" конструктор по умолчанию.

Далее мы проанализируем приложение, в котором именно по этой схеме создаются объекты, обладающие свойством живучести.

Изменим приложение My следующим образом. Класс документа будет содержать класс CMessages. Это приложение будет иметь команду меню Edit->Change Messages, которая изменяет все три строки. Новая программа сможет сохранять и восстанавливать документы, для чего будут использованы пункты Save и Open меню File.

Добавьте в секцию атрибутов класса документа определение переменной, чтобы этот фрагмент файла MyDoc.h выглядел следующим образом:

//Атрибуты.

public:

CMessages m_messages;

Следующий шаг--создание класса CMessages.

Для создания этого класса нужно выбрать в меню среды разработки Insert->New Class. В поле со списком Class type диалогового окна New Class выберите Generic Class (порождающий класс). В поле Name введите имя нового класса CMessages. Ниже введите имя базового класса Cobject, а в столбце As оставьте предлагаемую по умолчанию установку publiс.

В результате будут созданы два файла-- файл заголовка Messages.h и файл реализации Messages.срр. В каждый из них будут введены заготовки программного кода. Возможно, будет выведено предупреждающее сообщение о том, что среда разработки не может найти файл заголовка для класса CObject. Если такое случится, можете смело щелкать на ОК, поскольку все системные файлы заголовков MFC всегда доступны компилятору без включения директив. Переключитесь в окне редактора кода на файл MyDoc.h и добавьте в него перед определением класса директиву:

#include "Messages.h"

В результате при трансляции класса документа компилятору будет доступно определение класса CMessages. Теперь вернитесь к тексту в файле Messages.h и добавьте следующие строки:

DECLARE SERIAL(CMessages)

protected:

CString m_message1;

CString m_message2;

CString m_message3;

public:

void SetMessage(UINT msgNum, CString msg);

CString GetMessage(UINT msgNum);

void Serialize(CArchive& ar);

Макрос DECLARE_SERIAL() обеспечивает выполнение ряда дополнительных функций -- MFC использует этот макрос для того, чтобы включить в определение класса объявления дополнительных членов (переменных и функций), которые необходимы для реализации живучести объектов класса.

Далее объявлены члены-переменные класса: три объекта класса CString. Обратите внимание, что они объявлены как защищенные -- protected. Следующими идут открытые (public) функции-члены. SetMessage() имеет два аргумента -- индекс строки, в которую заносятся данные, и собственно записываемая строка символов. Эта функция позволяет изменить состояние объекта класса. GetMessage()-- это сопряженная с предыдущей функция, которая позволяет программе прочесть содержимое любой строки объекта. Ее единственный аргумент-- индекс считываемой строки. И наконец, в нашем классе перегружается метод Serialize(). Эта функция -- сердце живучего объекта. Реализация ее уникальна для каждого класса.

Файл Messages.cpp -- реализация методов класса CMessages

Void CMessages::SetMessage(UINT msgNum, CString msg)

{

switch (msgNum)

{

case 1:

m_message1=msg;

break;

case 2:

m_message2 = msg;

break;

case 3:

m_message3 = msg;

break;

}

}

CString CMessages::GetMessage(UINT msgNum)

{

switch (msgNum)

{

case 1:

return m_message1;

case 2:

return m_message2;

case 3:

eturn m_message3;

default:

return "";

}

}

void CMessages::Serialize(CArchive& ar)

{

CObject::Serialize(ar);

if (ar.IsStoring())

{

ar << m_message1 << m_message2 << m_message3;

}

else

{

ar >> m_message1 >> m_message2 >> m_message3;

}

}

Функции SetMessage() и GetMessage() простым способом реализуют то, что от них требуется. Рассмотрим функцию Serialize(). Обратите внимание на то, что первый оператор в теле функции-- это вызов одноименного метода базового класса CObject. Это стандартный прием, который используется во многих функциях, перегружающих одноименные функции базового класса. В данном случае -- это просто дань дисциплине, поскольку метод CObject::Serialize() ничего не выполняет (он пуст). Но, тем не менее, воспитайте в себе привычку всегда вызывать одноименный метод класса-родителя, поскольку не всегда класс происходит прямо от CObject (является прямым наследником CObject) и неизвестно, что делает Serialize() в каком-нибудь другом классе, ребенком которого вы решите объявить свой класс.

После вызова родительской версии Serialize() сохраняет или восстанавливает данные так же, как мы это делали в классе документа. Поскольку члены данных, которые нужно сохранять-восстанавливать, есть объекты класса CString, можно использовать терминальные операторы >> и << для передачи данных на диск и с диска.

В самом начале файла Messages.срр после директив include вставьте строку IMPLEMENT_SERIAL(CMessages, CObject, 0)

Макрос IMPLEMENT_SERIAL() сопряжен с DECLARE_SERIAL(). Он обеспечивает реализацию функций, которые и обеспечивают живучесть объектов класса. Три аргумента макроса (имя класса, имя класса-родителя и номер схемы (schema number)) -- это нечто вроде номера версии. В большинстве случаев в качестве номера схемы можно задавать 0 или 1.

Использование класса CMessages в программе

Теперь, когда класс CMessages создан, к нему смогут обращаться методы классов документа и представления приложения My. Разверните в окне ClassView класс CMyDoc и, дважды щелкнув на имени метода OnNewDocument(), вызовите его текст в окне редактора кода. Вместо строк комментария TODO вставьте следующие строки:

m_messages.SetMessage(1,"Default Message 1")

m_messages.SetMessage(2, "Default Message 2")

m_messages.SetMessage(3, "Default Message 3")

Поскольку методы класса документа не могут напрямую обращаться к защищенным членам класса CMessages, каждый из них инициализируется функцией SetMessage() этого класса.

Теперь разверните в окне ClassView класс CMyView и, дважды щелкнув на имени метода OnDraw(), вызовите его текст в окне редактора кода. После редактирования текст этого метода должен выглядеть следующим образом:

void CMyView::OnDraw(CDC* pDC)

{

CMyDoc* pDoc = GetDocument();

ASSERT_VALID(pDoc);

pDC->TextOut(20, 20, pDoc->m_messages.GetMessage(1));

pDC->TextOut(20, 40, pDoc->m_messages.GetMessage(2));

pDC->TextOut(20, 60, pDoc->m_messages.GetMessage(3));}

Теперь внесем изменения в метод OnEditChangemessages() класса представления. Этот метод будет изменять содержимое документа, обращаясь к методам доступа и к переменным класса CMessages.

void CMyView::OnEditChangemessages()

{CMyDoc* pDoc = GetDocument()

CTime now = CTime::GetCurrentTime();

CString changetime = now. Format( "Changed at %B %d %H:%M:%S");

pDoc->m_messages.SetMessage(1,CString(“String 1”) + changetime);

pDoc->m_messages.SetMessage(2,CString(“String 2”) +changetime);

pDoc->m_messages.SetMessage(3,CString(“String 3”) +changetime);

pDoc->SetModifiedFlag();

Invalidate();}

Теперь предстоит доопределить функцию Serialize() -- член класса документа приложения, в котором данные из объекта m_messages должны записываться-считываться с диска. Это выполняется на удивление просто -- вызывается одноименная функция-член класса, которому принадлежит объект, содержащий данные документа.

void CMyDoc::Serialize(CArchive&ar)

{m_messages.Serialize(ar);

if (ar. IsStoring())

{// TODO: сюда вставьте операторы сохранения данных.}

else {//TODO: сюда вставьте операторы загрузки данных.}}

Как видно, после вызова метода Serialize() для объекта m_messages, функции Serialize() -- члену класса документа больше и делать нечего. Обратите внимание, что при вызове m_messages.Serialize() в качестве единственного аргумента передается ссылка на объект класса CArchive.

17. Непосредственное чтение и запись файлов. Класс CFile. Методы класса CFile, режимы доступа к файлу

Непосредственное чтение и запись файлов

Хотя использование встроенной в MFC технологии сохранения-восстановления данных и обеспечивает основные требования приложения при работе с файлами, иногда необходимо реализовать нестандартные процедуры управления файловой системой, не укладывающиеся в рамки этой технологии. Например, может возникнуть необходимость вывести информацию в файл, из которого не нужно снова считывать данные в объекты программы, или тот способ записи-считывания, который реализуется в функции Serialize(), вас не устраивает, поскольку там возможен только последовательный доступ к файлу (ввод-вывод в поток). В этих случаях можно использовать знакомые всем, кто когда-либо программировал в среде DOS, методики программирования файловых операций -- непосредственное создание файла, чтение и запись информации в файл. Но даже если вы и решитесь снизойти до такого уровня программирования задач управления файлами, средства MFC все равно облегчат вам жизнь. Для непосредственного управления процессами ввода-вывода в файл в распоряжение программиста MFC предоставляет класс CFile и производные от него.

Класс CFile

Включенный в состав MFC класс CFile инкапсулирует все функции, связанные с обработкой файлов любого типа. Собираетесь ли вы использовать обычный последовательный способ записи-чтения данных или организовать файл с произвольным доступом к данным, в любом случае можно использовать методы класса CFile. При этом последовательность операций очень напоминает прежние С-программы, за исключением того, что класс скрывает некоторые их детали. В результате несколько снижается количество операторов, но принципиально это прежний хорошо знакомый подход. Теперь, в частности, создать файл для чтения можно, используя единственный оператор.

Функция	Назначение
Конструктор	Создает экземпляр класса CFilе. Если передать аргумент, имя файла открывает заданный файл
Деструктор	Уничтожает экземпляр класса CFile. Если соответствующий файл открыт, закрывает, его перед удалением экземпляра класса
Abort ()	Немедленно закрывает файл, не обращая внимания на ошибки
Close()	Закрывает файл
Duplicate()	Создает экземпляр класса для дубликата файла
Flush()	Сбрасывает данные из потока
GetFileName()	Считывает имя файла
GetFilePath()	Считывает полный путь файла
GetFileTitle()	Считывает имя файла без расширения (file title)
GetLength()	Считывает длину файла
GetPosition()	Считывает текущую позицию в файле
GetStatus()	Считывает статус файла
LockRange()	Блокирует фрагмент файла для доступа со стороны других процессов
Open()	Открывает файл
Read()	Считывает данные из файла
Remove()	Стирает файл
Rename()	Переименовывает файл
Seek()	Переставляет указатель текущей позиции в файле
SeekToBegin()	Устанавливает указатель текущей позиции, на начало файла
SeekToEnd()	Устанавливает указатель текущей позиции на конец файла
SetFilePath( )	Устанавливает путь к файлу
SetLength()	Устанавливает длину файла
SetStatus()	Устанавливает статус файла
UnlockRange()	Снимает блокировку фрагмента файла
Write()	Записывает данные в файл

Как видно из приведенной таблицы, набор методов класса CFile предоставляет широкие возможности для работы с файлами.

Чтобы получить доступ к файлу, сначала надо создать объект класса CFile. Конструктор класса позволяет сразу после создания такого объекта открыть файл. Но можно открыть файл и позднее, воспользовавшись методом Open.

18. Использование на примере основных методов класса CFile (Открыть файл, записать в файл, считать из файла). Использование стандартных диалоговых панелей для открытия и записи в файл

Открытие, создание и закрытие файлов

После создания объекта класса CFile можно открыть файл, вызвав метод Open. Методу надо указать путь к открываемому файлу и режим его использования. Прототип метода Open имеет следующий вид:

virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags,

CFileException* pError=NULL);

Метод Open возвращает не нулевое значение, если файл открыт и нуль в случае ошибки. Ошибка при открытии файла может случиться, например, если методу Open указан для чтения несуществующий файл.

В качестве параметра lpszFileName надо указать имя открываемого файла. Можно указать только имя файла или полное имя файла, включающее полный путь к нему.

Второй параметр nOpenFlags определяет действие, выполняемое методом Open с файлом, а также атрибуты файла. Ниже представлены некоторые возможные значения параметра nOpenFlags:

CFile::modeCreate - Создается новый файл. Если указанный файл существует, то его содержимое стирается, и длина файла устанавливается равной нулю.

CFile::modeNoTruncate - Этот файл предназначен для использования совместно с файлом CFile::modeCreate. Если создается уже существующий файл, то его содержимое не будет удалено.

CFile::modeRead - Файл открывается только для чтения.

...