| netlib.narod.ru | < Назад | Оглавление | Далее > |
На основе полученных знаний мы напишем приложение DirectDraw для просмотра BMP-файлов. Программа BmpView отображает диалоговое окно, в котором пользователь выбирает BMP-файл. Затем она выводит список всех видеорежимов, пригодных для просмотра выбранного изображения. Если выбрать видеорежим и нажать кнопку Display, программа BmpView переходит в заданный режим и отображает содержимое BMP-файла. Если изображение не помещается на экране, его можно прокрутить с помощью клавиш: стрелок, Home, End, Page Up и Page Down. Диалоговое окно для выбора файла изображено на рис. 5.7.
Рис. 5.7. Диалоговое окно для выбора файла в программе BmpView
Обратите внимание на то, что в диалоговом окне отображаются размеры выбранного файла, а глубина пикселей определяет, какие видеорежимы могут использоваться для его отображения. На рисунке выбрано 8-битное изображение, поэтому в список включены только 8-битные режимы. Если выбрать 24-битное изображение, то список состоял бы только из беспалитровых режимов.
Наше знакомство с программой BmpView затрагивает следующие вопросы:
Первые два вопроса мы уже обсудили, осталось лишь рассмотреть код. Хотя два последних вопроса и не имеют прямого отношения к теме, о них тоже стоит поговорить.
До выхода DirectX 5 библиотека DirectDraw не позволяла размещать в видеопамяти поверхности, ширина которых превышала ширину первичной поверхности. В DirectX 5 это ограничение снято, но лишь для видеоустройств, поддерживающих такую возможность.
Поверхности, находящиеся в системной памяти, могут иметь произвольную ширину, но обычно им недоступны преимущества аппаратного ускорения. Если в нашей программе пользователь выбирает BMP-файл и видеорежим, ширина которого меньше ширины изображения, скорее всего, нам придется работать с системной памятью. Для работы с видеопамятью необходимо, чтобы выполнялись следующие условия:
Для программ просмотра изображений (таких как BmpView) скорость работы не особенно важна, так что нас устроит и такой вариант. Если по какой-то причине скорость является критичной, большое изображение всегда можно разбить на несколько малых поверхностей, разместить их в видеопамяти и обновлять экран с помощью нескольких блит-операций.
Работать с диалоговыми окнами Windows в полноэкранном приложении оказывается не так уж просто. Разумеется, полноэкранному приложению нужен интерфейс, но стоит ли для этого использовать знакомый интерфейс Windows — вопрос спорный. Решение этой проблемы можно выбрать из трех основных вариантов:
В первом варианте вам придется самостоятельно управлять переключением страниц и палитрами с учетом Windows GDI. GDI не поддерживает DirectDraw, так что независимо от того, какая страница видеопамяти отображается в данный момент, диалоговые окна GDI всегда выводятся на «настоящей» первичной поверхности, или поверхности GDI. В беспалитровых режимах вывод GDI выглядит правильно и без вмешательства с вашей стороны, но в палитровых режимах отсутствие поддержки DirectDraw в GDI дает о себе знать — GDI продолжает выводить диалоговые окна в системной палитре Windows, не подозревая о том, что в данный момент может действовать другая палитра. Решение зависит от требований, предъявляемых приложением к палитре.
В программе BmpView мы будем управлять механизмом переключения страниц и восстанавливать системную палитру Windows для правильного отображения диалоговых окон. Вы увидите, как это делается, при изучении кода BmpView.
Второй вариант — восстанавливать видеорежим и рабочий стол Windows перед отображением диалогового окна. Он встречается в некоторых коммерческих продуктах; например в игре MechWarrior 2 фирмы Activision для заставок, воспроизведения видеороликов и вступительного инструктажа используется стандартный интерфейс Windows. Затем, с началом миссии, игра берет на себя все управление видеокартой и не пользуется никакими интерфейсными компонентами Windows. После завершения миссии поверхность рабочего стола снова восстанавливается. В этой игре данная методика работает неплохо.
Версия MechWarrior 2, о которой я говорю, проектировалась для чипов 3Dfx. Для видеоустройств, построенных на таких чипах, вывод диалоговых окон в DirectDraw невозможен, потому что 3Dfx являются вторичными видеоустройствами, и GDI ничего не знает об их существовании. Поэтому команда разработчиков Activision не могла выбрать первый вариант и отображать диалоговые окна в DirectDraw.
Третья стратегия (создание нестандартных интерфейсов на базе DirectDraw) оказывается самой трудоемкой. Разработка нестандартных управляющих элементов давно превратилась в отдельную отрасль программной индустрии, и мало кто из разработчиков позволяет себе тратить время на создание кнопок, ползунков и списков, когда с приложением и без того хватает хлопот. С другой стороны, этот вариант позволяет создать интерфейс, спроектированный специально для вашего приложения. Теоретически этот интерфейс может быть столь же привлекательным и впечатляющим, как и само приложение.
В программе BmpView используется первый вариант. Перед выводом диалогового окна на рис. 5.7 мы отображаем поверхность GDI и восстанавливаем системную палитру.
В программе BmpView, как и в других программах этой книги, класс окна приложения является производным от класса DirectDrawWin. К сожалению, по нашему соглашению об именах имя производного класса образуется из имени приложения и суффикса Win. Следовательно, класс окна приложения BmpView называется BmpViewWin, что выглядит несколько неуклюже. Объявление класса BmpViewWin приведено в листинге 5.5.
|
Листинг 5.5. Класс BmpViewWin |
class BmpViewWin : public DirectDrawWin
{
public:
BmpViewWin();
protected:
//{{AFX_MSG(BmpViewWin)
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnDestroy();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
private:
int SelectInitialDisplayMode();
BOOL CreateCustomSurfaces() { return TRUE; }
void DrawScene();
void RestoreSurfaces();
void GetSystemPalette();
void ShowDialog();
BOOL LoadBmp();
void PageUp();
void PageDown();
void Home();
void End();
void Left(int inc = 4);
void Right(int inc = 4);
void Up(int inc = 4);
void Down(int inc = 4);
private:
BmpDialog* bmpdialog;
LPDIRECTDRAWPALETTE syspal;
CString fullfilename;
CString filename;
CString pathname;
CRect displayrect;
LPDIRECTDRAWSURFACE bmpsurf;
CRect bmprect;
int x,y;
int xscroll, yscroll;
int xlimit, ylimit;
BOOL update_screen;
DisplayModeArray palettemode, nonpalettemode;
};
|
Единственной открытой функцией класса является конструктор, используемый для инициализации переменных. Далее мы объявляем четыре обработчика сообщений:
Функция OnKeyDonw() обрабатывает нажатия нескольких клавиш, среди которых клавиши со стрелками, Home, End, Page Up, Page Down, Enter, пробел и Esc.
Функции OnCreate() и OnDestroy() предназначены соответственно для инициализации и освобождения структур данных приложения. В частности, функция OnCreate() создает диалоговое окно для выбора BMP-файла, а функция OnDestroy() уничтожает его.
Далее следуют объявления нескольких закрытых переменных. Функция SelectInitialDisplayMode() похожа на версию, созданную DirectDraw AppWizard и использованную в прошлых программах, но в нее внесены некоторые изменения. Кроме выбора исходного видеорежима, эта функция сохраняет текущую палитру Windows с помощью функции GetSystemPalette() (которая объявляется несколькими строками ниже функции SelectInitialDisplayMode()).
Функция CreateCustomSurfaces() объявляется и определяется в объявлении класса. В отличие от других программ, рассмотренных нами, BmpView не отображает никаких вспомогательных поверхностей, поэтому эта функция не делает ничего. Однако из-за того, что функция DirectDrawWin::CreateCustomSurfaces() является чисто виртуальной, нам приходится объявить и определить ее минимальную реализацию.
Функция DrawScene() отвечает за графический вывод и переключение страниц. Поскольку нашей программе незачем постоянно обновлять экран, функция DrawScene() делает это лишь в ответ на пользовательский ввод. Этим она отличается от других программ, в которых экран обновлялся непрерывно. Функция RestoreSurfaces() восстанавливает поверхности в случае их потери.
Функция ShowDialog() выводит диалоговое окно для выбора BMP-файла. Функция LoadBmp() по имени, полученному из диалогового окна, загружает BMP-файл на поверхность и инициализирует переменные x, y, xscroll, yscroll, xlimit и ylimit. Эти переменные предназначены для позиционирования поверхности в случае, если размер поверхности BMP-файла превышает размеры первичной поверхности.
Затем мы объявляем восемь функций, вызываемых при нажатии конкретных клавиш:
Класс содержит несколько переменных, часть из которых упоминалась выше. Их назначение рассматривается при описании функций.
Перед тем как инициализировать DirectDraw, класс DirectDrawWin вызывает функцию SelectDriver(), чтобы производные классы могли выбрать драйвер DirectDraw при наличии нескольких вариантов. В программе BmpView мы отказываемся от этой возможности и позволяем выбрать первичный драйвер по умолчанию. Это сделано потому, что для вывода диалоговых окон используется механизм GDI, а GDI может выводить только на первичное видеоустройство (которому соответствует первичный драйвер DirectDraw).
Следующим этапом инициализации приложения является вызов функции SelectInitialDisplayMode(), которую мы обязаны переопределить. Наша версия SelectInitialDisplayMode() выбирает видеорежим с параметрами 640x480x16. Исходный видеорежим не так уж важен, потому что он, скорее всего, будет переопределен пользователем при выборе BMP-файла. Однако функция SelectInitialDisplayMode() (см. листинг 5.6) выполняет две дополнительные задачи.
|
Листинг 5.6. Функция BmpViewWin::SelectInitialDisplayMode() |
int BmpViewWin::SelectInitialDisplayMode()
{
DisplayModeDescription desc;
int i, nummodes = GetNumDisplayModes();
DWORD w,h,d;
for (i = 0;i < nummodes; i++)
{
GetDisplayModeDimensions( i, w, h, d );
desc.w = w;
desc.h = h;
desc.d = d;
desc.desc.Format("%dx%dx%d", w, h, d);
if (d == 8)
palettemode.Add(desc);
else
nonpalettemode.Add(desc);
}
DWORD curdepth = GetDisplayDepth();
for (i = 0; i < nummodes; i++)
{
GetDisplayModeDimensions(i, w, h, d);
if (w == 640 && h == 480 && d == curdepth)
return i;
}
for (i = 0;i < nummodes; i++)
{
GetDisplayModeDimensions(i, w, h, d);
if (d == curdepth)
return i;
}
for (i = 0; i < nummodes; i++)
{
GetDisplayModeDimensions(i, w, h, d);
if (w == 640 && h == 480)
return i;
}
GetSystemPalette();
return 0;
}
|
Помимо выбора исходного видеорежима функция SelectInitialDisplayMode() используется для подготовки двух массивов: в первом хранятся сведения о палитровых (palettemode), а во втором — о беспалитровых (nonpalettemode) видеорежимах. Мы воспользуемся этими массивами позднее, при отображении диалогового окна. Когда пользователь выбирает файл с палитровым изображением, в список включаются только палитровые режимы; для беспалитровых режимов дело обстоит аналогично. Обратите внимание — в подготовленные массивы (коллекции структур DisplayModeDescription) включены строки, отображаемые в диалоговом окне.
Функция SelectInitialDisplayMode() также используется для вызова функции GetSystemPalette(), создающей палитру DirectDraw на базе системной палитры. Функция GetSystemPalette() выглядит так:
void BmpViewWin::GetSystemPalette()
{
PALETTEENTRY pe[256];
HDC dc = ::GetDC(0);
if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)
{
GetSystemPaletteEntries(dc, 0, 256, pe);
ddraw2->CreatePalette(DDPCAPS_8BIT, pe, &syspal, 0);
}
::ReleaseDC(0, dc);
}
С помощью функции Win32 GetSystemPaletteEntries() мы получаем содержимое текущей палитры Windows и создаем по ее образцу палитру DirectDraw функцией CreatePalette() интерфейса DirectDraw. Указатель на созданную палитру syspal позднее будет применяться для восстановления системной палитры; это обеспечивает правильное отображение диалоговых окон Windows в 8-битных видеорежимах.
Следующий шаг инициализации приложения, заслуживающий нашего внимания, — функция OnCreate(). В функции OnCreate(), переопределенной классом BmpViewWin, происходит создание и отображение диалогового окна:
int BmpViewWin::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (DirectDrawWin::OnCreate(lpCreateStruct) == -1)
return -1;
ShowDialog();
return 0;
}
Функция ShowDialog() вызывается при запуске приложения и при выборе нового файла. ShowDialog() подготавливает DirectDraw к отображению диалогового окна, выводит окно, получает информацию о выбранном BMP-файле и выбранном видеорежиме и отображает содержимое файла. Функция ShowDialog() приведена в листинге 5.7.
|
Листинг 5.7. Функция ShowDialog() |
void BmpViewWin::ShowDialog()
{
CRect displayrect = GetDisplayRect();
if (displayrect.Width() < 640)
ddraw2->SetDisplayMode(640, 480, 8, 0, 0);
if (GetDisplayDepth() == 8)
{
ClearSurface(backsurf, 0);
primsurf->SetPalette(syspal);
}
else
{
BltSurface(backsurf, bmpsurf, x, y);
}
ddraw2->FlipToGDISurface();
ShowCursor(TRUE);
if (bmpdialog == 0)
{
bmpdialog = new BmpDialog();
bmpdialog->SetArrays(&palettemode, &nonpalettemode);
}
if (bmpdialog->DoModal() == IDCANCEL)
{
PostMessage(WM_CLOSE);
return;
}
fullfilename = bmpdialog->fullfilename;
filename = bmpdialog->filename;
pathname = bmpdialog->pathname;
int index = bmpdialog->GetIndex();
DWORD w,h,d;
if (bmpdialog->FilePalettized())
{
w = palettemode[index].w;
h = palettemode[index].h;
d = palettemode[index].d;
}
else
{
w = nonpalettemode[index].w;
h = nonpalettemode[index].h;
d = nonpalettemode[index].d;
}
if (GetDisplayDepth() == 8)
primsurf->SetPalette(palette);
ActivateDisplayMode(GetDisplayModeIndex(w, h, d));
LoadBmp();
ShowCursor(FALSE);
}
|
Функция ShowDialog() прежде всего проверяет, что текущий видеорежим имеет разрешение не менее 640x480. Из обсуждения функции SelectInitialDisplayMode() нам известно, что при инициализации приложения это условие заведомо выполняется, однако функция ShowDialog() также вызывается при каждом отображении BMP-файла. Если в данный момент установлен режим низкого разрешения, то перед тем, как продолжать, мы переходим в режим 640x480x8. Это обусловлено тем, что режимы низкого разрешения часто являются режимами Mode X, а GDI в таких режимах не может правильно отображать диалоговые окна.
Далее мы готовимся к отображению диалогового окна. Для палитровых режимов мы очищаем вторичный буфер и устанавливаем сохраненную ранее системную палитру, не пытаясь выводить диалоговое окно вместе с текущим изображением. Для беспалитровых режимов текущее изображение копируется на вторичный буфер и выводится за диалоговым окном.
| СОВЕТ |
Диалоговое окно и изображение Чтобы организовать совместный вывод текущего изображения и диалогового окна в палитровом видеорежиме, вам придется сократить 256 элементов палитры изображения до 236, добавить новые цвета в середину палитры (системные цвета занимают по 10 элементов в начале и в конце палитры) и пересчитать пиксели изображения в соответствии с внесенными изменениями. Обычно это ведет к снижению качества изображения, но присутствие диалогового окна все равно отвлекает внимание пользователя. Чтобы восстановить прежнее изображение, необходимо сохранить предыдущие варианты изображения и палитры. |
Вызов функции FlipToGDISurface() гарантирует, что вывод GDI будет присутствовать на экране. Кроме того, мы включаем курсор мыши (отключенный при запуске приложения классом DirectDrawWin), чтобы для работы с диалоговым окном можно было пользоваться мышью.
Далее мы создаем экземпляр класса BmpDialog, если он не был создан ранее. Класс-оболочка BmpDialog создается ClassWizard, он предназначен для отображения диалогового окна и работы с ним. Класс содержит код для работы с управляющими элементами окна и реакции на действия пользователя. Код класса BmpDialog здесь не рассматривается, так как он не имеет никакого отношения к DirectDraw.
Обратите внимание: при создании диалогового окна мы вызываем функцию SetArrays() и передаем ей массивы palettemode и nonpalettemode в качестве аргументов. Эта функция передает диалоговому окну информацию о видеорежимах, предназначенных для отображения как палитровых, так и беспалитровых изображений.
Диалоговое окно отображается функцией DoModal(). Пользователь сможет нажать кнопку Display лишь после того, как будет выбран BMP-файл и видеорежим. При этом мы сохраняем имя и путь выбранного BMP-файла и определяем параметры выбранного видеорежима. Если же пользователь закрывает диалоговое окно, мы посылаем сообщение WM_CLOSE и выходим из функции, завершая приложение.
Наконец, функция ActivateDisplayMode() активизирует выбранный видеорежим, функция LoadBmp() загружает содержимое BMP-файла, а курсор мыши отключается.
Чтобы лучше понять, как происходит загрузка файла, необходимо рассмотреть функцию LoadBmp(), которая не только загружает BMP-файл, но и инициализирует механизм прокрутки. Функция LoadBmp() приведена в листинге 5.8.
|
Листинг 5.8. Функция LoadBmp() |
BOOL BmpViewWin::LoadBmp()
{
CWaitCursor cur;
LPDIRECTDRAWSURFACE surf;
surf = CreateSurface(filename, TRUE);
if (surf)
{
if (bmpsurf)
bmpsurf->Release();
bmpsurf = surf;
}
else
{
TRACE("failed to load new file\n");
return FALSE;
}
displayrect = GetDisplayRect();
TRACE("display: %d %d\n", displayrect.right, displayrect.bottom);
GetSurfaceRect(bmpsurf, bmprect);
TRACE("surface: %d %d\n", bmprect.right, bmprect.bottom);
int mx = displayrect.Width() - bmprect.Width();
if (mx < 0)
{
xscroll = TRUE;
xlimit = mx;
x = 0;
}
else
{
xscroll = FALSE;
x = mx / 2;
}
int my = displayrect.Height() - bmprect.Height();
if (my < 0)
{
yscroll = TRUE;
ylimit = my;
y = 0;
}
else
{
yscroll = FALSE;
y = my / 2;
}
update_screen = TRUE;
return TRUE;
}
|
Сначала функция LoadBmp() создает объект MFC CWaitCursor, чтобы на время ее работы на экране отображался курсор Windows в виде песочных часов. Затем она вызывает функцию CreateSurface() и передает ей в качестве аргумента имя выбранного BMP-файла. Реализация CreateSurface() рассматривалась ранее в этой главе, поэтому мы знаем, что эта функция загружает указанный BMP-файл на новую поверхность.
Затем LoadBmp() определяет параметры новой поверхности и текущий активный видеорежим и использует полученные данные для инициализации переменных класса BmpViewWin, связанных с прокруткой и позиционированием поверхностей. Если размеры поверхности меньше размеров видеорежима, поверхность центрируется на экране; если поверхность больше, следует разрешить ее прокрутку. Переменные x и y определяют текущую позицию на поверхности, а переменные xlimit и ylimit ограничивают диапазон прокрутки. Логические переменные xscroll и yscroll показывают, разрешена ли горизонтальная и вертикальная прокрутка поверхности.
Наконец, логической переменной update_screen присваивается значение TRUE; оно говорит о том, что функция DrawScene() должна обновить первичную поверхность. О функции DrawScene() речь пойдет в следующем разделе.
Функция DrawScene() обновляет экран в зависимости от состояния логической переменной update_screen. Если переменная update_screen равна FALSE, предполагается, что содержимое первичной поверхности не устарело, и делать ничего не нужно. Функция DrawScene() выглядит так:
void BmpViewWin::DrawScene()
{
if (update_screen && bmpsurf)
{
ClearSurface(backsurf, 0);
BltSurface(backsurf, bmpsurf, x, y);
primsurf->Flip(0, DDFLIP_WAIT);
update_screen = FALSE;
}
}
Поскольку текущее положение поверхности рассчитывается в другом месте программы, а функция BltSurface() при необходимости автоматически выполняет отсечение, функция DrawScene() реализуется просто. Если переменная update_screen равна TRUE и существует поверхность для вывода, экран обновляется. Если поверхность не заполняет экран целиком, содержимое вторичного буфера стирается; если заполняет, то в стирании буфера нет необходимости. Затем функция BltSurface() копирует поверхность на вторичный буфер, а функция Flip() отображает изменения на экране. После того как обновление будет завершено, переменной update_screen присваивается значение FALSE.
Давайте посмотрим, как в нашей программе организована обработка ввода. Нажатые клавиши обрабатываются функций OnKeyDown(), которая выглядит так:
void BmpViewWin::OnKeyDown(UINT key, UINT nRepCnt, UINT nFlags)
{
switch (key)
{
case VK_UP:
Up();
break;
case VK_DOWN:
Down();
break;
case VK_LEFT:
Left();
break;
case VK_RIGHT:
Right();
break;
case VK_HOME:
Home();
break;
case VK_END:
End();
break;
case VK_PRIOR:
PageUp();
break;
case VK_NEXT:
PageDown();
break;
case VK_ESCAPE:
case VK_SPACE:
case VK_RETURN:
ShowDialog();
break;
}
DirectDrawWin::OnKeyDown(key, nRepCnt, nFlags);
}
С первого взгляда на листинг OnKeyDown() можно разве что понять, какие клавиши обрабатываются программой, потому что вся содержательная работа поручается другим функциям. Обратите внимание — при нажатии клавиш Esc, пробел и Enter вызывается одна и та же функция ShowDialog(). Это облегчает вызов диалогового окна после вывода изображения.
Остальные восемь функций, вызываемых функцией OnKeyDown(), изменяют положение поверхности во время прокрутки:
Каждая из этих функций определяет положение поверхности по значениям переменных x, y, xlimit, ylimit, xscroll и yscroll. Код всех восьми функций приведен в листинге 5.9.
|
Листинг 5.9. Функции смещения поверхности |
void BmpViewWin::Up(int inc)
{
if (!yscroll)
return;
if (y + inc < 0)
{
y += inc;
update_screen = TRUE;
}
else
{
y = 0;
update_screen = TRUE;
}
}
void BmpViewWin::Down(int inc)
{
if (!yscroll)
return;
if (y - inc >= ylimit)
{
y -= inc;
update_screen = TRUE;
}
else
{
y = ylimit;
update_screen = TRUE;
}
}
void BmpViewWin::Left(int inc)
{
if (!xscroll)
return;
if (x + inc < 0)
{
x += inc;
update_screen = TRUE;
}
else
{
x = 0;
update_screen = TRUE;
}
}
void BmpViewWin::Right(int inc)
{
if (!xscroll)
return;
if (x - inc >= xlimit)
{
x -= inc;
update_screen = TRUE;
}
else
{
x = xlimit;
update_screen = TRUE;
}
}
void BmpViewWin::Home()
{
if (xscroll && x != 0)
{
x = 0;
update_screen = TRUE;
}
if (yscroll && y != 0)
{
y = 0;
update_screen = TRUE;
}
}
void BmpViewWin::End()
{
if (yscroll)
{
y = -(bmprect.Height() - displayrect.Height());
update_screen = TRUE;
}
if (xscroll)
{
x = -(bmprect.Width() - displayrect.Width());
update_screen = TRUE;
}
}
void BmpViewWin::PageUp()
{
if (yscroll)
{
if (y - displayrect.Height() > 0)
{
y -= displayrect.Height();
update_screen = TRUE;
}
else
{
y = 0;
update_screen = TRUE;
}
}
}
void BmpViewWin::PageDown()
{
if (yscroll)
{
if (y + displayrect.Height() <= ylimit)
{
y += displayrect.Height();
update_screen = TRUE;
}
else
{
y = ylimit;
update_screen = TRUE;
}
}
}
|
Обработчикам клавиш со стрелками (Up(), Down(), Left(), Right()) можно передать необязательный аргумент, который определяет шаг прокрутки. Как видно из определения класса BmpViewWin (см. листинг 5.5), по умолчанию шаг прокрутки равен 4.
| netlib.narod.ru | < Назад | Оглавление | Далее > |