return;

}

Остальные функции в программе List служат для вызова диалогового окна; в котором пользователь вводит текст, отображения окна About и вывода сообщений об ошибках.

Содержание отчета:

1.Цель работы;

2.Исходный текст программы;

3.Результаты работы программы (главное окно в ОС Windows);

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

ЛАБОРАТОРНАЯ РАБОТА №3

"Реестр ОС Windows"

Цель работы: Изучение принципов разработки программы, позволяющей производить запись и считывание данных с реестра ОС Windows (на примере программы Reg_Ops).

Задание к лабораторной работе:

1. Перед запуском программы Reg_Ops открыть с помощью проводника Windows, менеджера файлов или любой другой программы просмотра файл Special.REG. Вызванная при этом утилита RegEdit создаст несколько дополнительных записей в разделе HKEY_LOCAL_MACHINE\SOFTWARE\ системного реестра. Содержимое текстового файла Special.REG представлено ниже.

REGEDIT4

[HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo]

[HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo\Charlie Brown] ''Password"="@ABCDGCGJ"

"Status"=dword:000003e9

[HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo\Henry Ford] "Password"="B@@EC"

25

"Status"=dword:000003ea

[HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo\Billy Sol Estes] "Password"="ABDABBCGE"

"Status"=dword:000003eb

[HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo\Thomas Alva Edison] "Password"="AA@@F"

"Status"=dword:000003ec

[HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo\Blaise Pascal] "Password"="ACBBDEGE"

"Status"=dword:000003ed

[HKEY_LOCAL_MACHINE\SOFTWARE\Not Very

Secret]

"Secret Key"="Rumplestiltskin"

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

2. Рассмотреть исходный текст программы Reg_Ops. Программа начинается с вызова метода OnInitDialog, который использует функцию RegCreateKey для открытия дескриптора личного раздела приложения в корневом разделе HKEY_LOCAL_MACHINE.

BOOL CReg_OpsDlg::OnInitDialog ()

{

CDialog::OnInitDialog() ;

...

// начинается с открытия разделов для записи данных в реестр

RegCreateKey ( HKEY_LOCAL_MACHINE, "SOFTWARE \ Registry demo", &m_hRegKey );

ResetButtons() ;

// инициализация поля со списком

InitializeListBox() ;

return TRUE; // возвращается значение TRUE, если фокус не // устанавливается на элементе управления

}

Поскольку в списке содержатся имена пользователей, флаги состояния и ключи для проверки паролей, программа записывает эту информацию в раздел

HKEY_LOCAL_MACHINE, а не в раздел HKEY_USERS. Если нужно зарегистрировать информацию о привилегиях конкретного пользователя, ее следует записать в раздел HKEY_CURRENT_USER. Такая информация будет

26

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

3. Рассмотреть режим чтения данных из разделов реестра. С помощью переменной m_hRegKey программа инициализирует содержимое списка, читая записи из подразделов реестра (см. файл Reg_OpsDlg.CPP).

BOOL CReg_OpsDlg::InitializeListBox()

{

DWORD dwName, dwSubkeys, dwIndex = 0; long lResult;

TCHAR szBuff[MAX_PATH+l] ; CString csBuff;

EnableButtons ( FALSE );

lResult = RegQueryInfoKey( m_hRegKey, NULL, NULL, NULL, &dwSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ;

if( lResult == ERROR_SUCCESS ) dwIndex = dwSubkeys;

else

ReportError( lResult );

Прежде чем приступить к чтению содержимого подразделов используется API-функция RegQueryInfoKey, которая определяет, сколько подразделов содержит раздел HKEY_LOCAL_MACHINE\SOFTWARE\Registry Demo.

Функция RegQueryInfoKey имеет несколько аргументов, но всем ненужным аргументам можно просто присвоить значение NULL, как это сделано в приведенном выше фрагменте. Такой подход дает возможность запросить только одно значение, не заботясь о параметрах, которые не интересуют.

Если для инициализации реестра будут использованы данные, которые содержатся в файле Special.REG, функция RegQueryInfoKey сообщит о наличии пяти подразделов.

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

27

RegCreateKey( m_hRegKey, szBuff, ShKeyItem );

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

ulSize = sizeof( m_dwNameStatus );

lResult = RegQueryValueEx ( hKeyltem, "Status", NULL, &ulType, (LPBYTE) &m_dwNameStatus, &ulSize );

Указанная выше функция RegQueryValueEx запрашивает значение, содержащееся в именованном параметре Status. Вместе с этим значением переменная-член ulType возвращает также идентификатор соответствующего типа данных в виде длинного целого без знака. Информация о размере данных будет получена посредством переменной-члена ulSize. Независимо от того, что собой представляют запрашиваемые данные - значение типа DWORD, строковое значение, двоичный массив или данные любого другого типа, адрес получающей их переменной всегда преобразуется в формат указателя на байт.

Затем, чтобы убедиться в корректности выполнения функции, произвести проверку значения lResult. В случае некорректного ее завершения на экране появляется сообщение об ошибке.

if( lResult != ERROR_SUCCESS ) ReportError( lResult );

К этому моменту уже получен из подраздела код состояния, а также имя самого подраздела. Прежде чем цикл будет продолжен для следующего подраздела, эти значения необходимо задействовать путем размещения их соответственно в качестве строкового элемента списка ComboListbox и индекса данного элемента.

nIndex = m_cbNamesList.AddString( m_csNameEntry ); m_cbNamesList.SetItemData( nIndex, m dwNameStatus );

}

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

}

while( lResult != ERROR_NO_MORE_ITEMS ); return TRUE;

}

29

Подпрограмма ConfirmPassword демонстрирует процедуру чтения параметра реестра в виде строкового значения. В этой подпрограмме имя, прочитанное из списка, используется для открытия дескриптора раздела, а затем для чтения пароля.

BOOL CReg_OpsDlg::ConfirmPassword()

{

HKEY hKeyItem; ULONG ulSize, ulType; long lResult;

TCHAR szBuff[MAX_PATH+1]; CString csBuff, csPassword;

RegCreateKey ( m_hRegKey, m_csNameEntry, &hKeyItem ); ulSize = sizeof( szBuff );

lResult = RegQueryValueEx( hKeyItem, "Password", NULL, &ulType, (LPBYTE) szBuff, &ulSize );

if(lResult != ERROR_SUCCESS )

{

ReportError( lResult ) ; return FALSE;

}

CEnterPassword *pDlg == new CEnterPassword(); if( pDlg->DoModal() == IDOK )

csPassword = theApp.Encrypt( pDlg->m_csPassword );

else

return FALSE;

return( csPassword == szBuff );

}

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

4. Рассмотреть режим записи данных в разделы реестра. Открыть раздел с помощью функции RegCreateKey. Для этого, сначала вызвать функцию RegOpenKey. Если указанный раздел уже существует, то подготовить его для записи новой информации, в противном случае - создать его.

После открытия или создания соответствующего раздела производится вызов функции RegSetValueEx, которая записывает информацию в реестр.

Подпрограмма AddToRegistry содержит два примера использования функции RegSetValueEx для записи данных в реестр. Первый раз функция RegSetValueEx применяется для записи строкового значения с указанием типа

REG_SZ:

30

BOOL CReg_OpsDlg::AddToRegistry()

{

HKEY hKeyNew;

RegCreateKey( m_hRegKey, m_csNameEntry, ShKeyNew ) ; RegSetValueEx( hKeyNew, "Password", NULL, REG_SZ,

(LPBYTE)(LPCTSTR)m_csPassword, m_csPassword.GetLength()+1 );

Поскольку указывается тип REG_SZ, к аргументу, задающему размер значения, необходимо добавить единицу - в таком случае будет включен завершающий нулевой символ, который не учитывается в значении, возвращаемом функцией GetLength.

Ранее указывалось, что функции для работы с реестром не распознают классов библиотеки MFC, в том числе и класс CString, однако в представленном примере в качестве аргументов использованы две ссылки на этот класс. Причем в первом случае значение приведено к типу LPCSTR, определяющему его как массив символов, во втором же случае передается целочисленное значение, возвращаемое функцией-членом.

Во второй операции с функцией RegSetValueEx необходимо записать значение типа DWORD:

RegSetValueEx( hKeyNew, "Status", NULL, REG_DWORD, (LPBYTE)&m_dwNameStatus, sizeof( m_dwNameStatus) );

return TRUE;

}

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

5. Рассмотреть подпрограмму системных сообщений об ошибках. В данном случае для интерпретации сообщений об ошибках, возвращаемых функциями RegQueryInfoKey, RegEnumKey и RegQueryValueEx, применяется функция ReportError. При вызове функции ReportError ей в качестве аргумента передается код ошибки, возвращаемый любой другой функцией, которая осуществляет обращение к реестру. В функции ReportError вызывается функция

FormatMessage с флагом FORMAT_MESSAGE_FROM_SYSTEM, которая возвращает строку с разъяснением соответствующей системной ошибки. Флаг

FORMAT_MESSAGE_ALLOCATE_BUFFER позволяет использовать допустимый указатель буфера, реально не выделяя его. Функция FormatMessage сама управляет выделением памяти, руководствуясь размером сообщения. При использовании флага FORMAT_MESSAGE_ALLOCATE_BUFFER после завершения работы необходимо вызвать функцию LocalFree и освободить память, выделенную для размещения буфера.

31

определенными знаниями о реестре (не слишком глубокими) - только при таком условии будет присвоен соответствующий статус.

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

Ниже представлен список имен, содержащихся в файле Special.REG, и для каждого из них указан пароль.

Содержание отчета:

1.Цель работы;

2.Исходный текст программы;

3.Результаты работы программы (диалоговое окно в ОС Windows);

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

ЛАБОРАТОРНАЯ РАБОТА №4

"Буфер обмена ОС Windows"

Цель работы: Изучение принципов работы с буфером обмена. (На примере программы ClipBoard).

Задание к лабораторной работе:

1. Запустить программу ClipBoard. Данная программа демонстрирует запись в буфер обмена и чтение из него данных трех различных типов: текста, растрового изображения и метафайла. Меню программы содержит два основных подменю, Data To Clipboard и Data from Clipboard, каждое из которых предлагает весьма "прозаический" набор команд, а именно Write и

Retrieve.

Команда Write Bitmap осуществляет простейшую операцию захвата экрана (по крайней мере, фрагмента экрана размером 640х480) в виде

33

растрового изображения и записи этого изображения в буфер обмена. Команда Write Text копирует в буфер обмена простую строку текста.

2. Рассмотреть механизм чтения и записи текста. Текстовые операции являются простейшими операциями, которые выполняются с буфером обмена.

Запись текста. Поскольку программа ClipBoard является одновременно и источником, и приемником данных, первый шаг при работе с ней заключается в передаче текстовой информации в буфер обмена. В качестве записываемого текста выбрана фиксированная строка "The quick brown fox jumps over the lazy red dog".

Механизм обработки текста реализован в виде функции, которая вызывается с двумя параметрами: дескриптором приложения hwnd и указателем строки текста lpText.

BOOL TextToClipboard( HWND hwnd, LPSTR lpText )

{

int i, wLen; GLOBALHANDLE hGMem; LPSTR lpGMem;

В функции TextToClipboard используются четыре локальных переменных, но пояснений требуют только две последние из них. Переменная hGMem содержит глобальный дескриптор блока памяти, который пока не был выделен. Вторая переменная, lpGMem, служит указателем блока памяти.

После инициализации переменной wLen и присвоения ей значения длины текстовой строки дескриптор hGMem становится идентификатором глобального блока памяти, выделенного для хранения копии текста. Однако обратите внимание, что значение переменной wLen на единицу больше длины строки, поскольку в строку входит еще и завершающий пустой символ. В буфер обмена текст всегда записывается в формате ASCIIZ (или ANSIZ):

wLen = strlen( lpText );

hGMem = GlobalAlloc( GHND, (DWORD) wLen + 1 ); lpGMem = GlobalLock( hGMem );

Наконец, переменной lpGMem присваивается указатель блока памяти, полученный в результате выполнения функции GlobalLock. Но не забывайте, что спецификация GHND объявляет этот блок как перемещаемый. Функция GlobalLock временно предотвращает перемещение блока памяти операционной системой.

Вторая особенность спецификации GHND заключается в том, что выделенный блок памяти освобождается от своего текущего содержимого и заполняется нулями. Таким образом, следующая операция - это копирование в выделенный блок памяти локальной строки, заданной указателем lpText:

34

for( i=0; i<wLen; i++ ) *lpGMem = *lpText++;

GlobalUnlock( hGMem );

return( TransferToClipboard( hwnd, hGMem, CF_TEXT ) );

}

После копирования текста вызывается функция GlobalUnlock, которая отменяет блокировку дескриптора hGMem, разрешая перемещение и повторное выделение блока памяти. Если бы блок памяти был перемещен до копирования текста, указатель lpGMem стал бы недействительным.

В завершение процесса передачи данных вызывается рассмотренная выше функция TransferToClipboard с указанием дескриптора блока hGMem, флага CF_TEXT и дескриптора окна приложения.

Чтение текста. Чтение текста из буфера обмена осуществляется столь же просто, как и запись, однако отдельная процедура при этом не вызывается, а действия выполняются в ответ на сообщение WM_PAINT. Это позволяет приложению при необходимости обновлять окно.

Операции чтения начинаются с открытия буфера обмена и вызова APIфункции GetClipboardData, которая возвращает дескриптор блока памяти, принадлежащего буферу:

OpenClipboard( hwnd);

hTextMem = GetClipboardData( CF_TEXT ); lpText = GlobalLock( hTextMem );

Как и при записи данных в буфер обмена, функция GlobalLock блокирует область памяти и ее адрес сохраняется в переменной lpText. Но на этот раз содержимое строки копируется из области памяти (переменная lpText) в локальную переменную TextStr не в цикле, а напрямую, с помощью функции lstrcpy:

lstrcpy( TextStr, lpText ); GlobalUnlock( hTextMem ); CloseClipboard();

Наконец, функция GlobalUnlock снимает блокировку области памяти, а функция CloseClipboard завершает сеанс работы с буфером обмена. Важно помнить, что область памяти никогда не должна оставаться заблокированной и вызов функции GlobalLock всегда должен сопровождаться вызовом

GlobalUnlock.

35

3. Рассмотреть механизм чтения и записи растровых изображений. В программе ClipBoard содержится пример передачи посредством буфера обмена растрового изображения. Эта часть программы начинается с захвата текущего содержимого экрана, которое передается в буфер обмена в виде растрового изображения. На рис. 4.1 показаны окно программы ClipBoard после выполнения операции захвата экрана.

Рис. 4.1. Захват растрового изображения

Запись растрового изображения. Процесс передачи изображения в буфер обмена начинается с создания в памяти совместимого контекста устройства hdcMem. Затем происходит создание и выбор (также в памяти) совместимого растрового изображения.

hdc = GetDC( hwnd ) ;

hdcMem = CreateCompatibleDC( hdc );

hBitmap = CreateCompatibleBitmap( hdc, 640, 480 ); SelectObject( hdcMem, hBitmap ) ;

Далее происходит копирование изображения из источника (в нашем случае - с экрана) в контекст памяти. Затем вызывается функция TransferToClipboard, которая, собственно, и осуществляет запись в буфер.

StretchBlt( hdcMem, 0, 0, 639, 479,

36

hdc, 0, 0, 639, 479, SRCCOPY ); TransferToClipboard( hwnd, hBitmap, CE_BITMAP ); DeleteDC( hdcMem );

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

Чтение растрового изображения. Аналогичным образом происходит и чтение растрового изображения из буфера обмена. Процесс начинается с открытия буфера и чтения из него дескриптора растрового изображения:

OpenClipboard( hwnd );

hBitmap = GetClipboardData ( CF_BITMAP ) ; hdcMem = CreateCompatibleDC ( hdc ); SelectObject( hdcMem, hBitmap );

Опять-таки, необходим совместимый контекст устройства. Затем функция SelectObject загружает в него изображение.

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

SetMapMode(hdcMem,.GetMapMode( hdc ) );

GetObject( hBitmap, sizeof(BITMAP), (LPSTR) &bm );

Далее изображение с помощью функции BitBlt копируется из контекста памяти в контекст устройства:

BitBlt( hdc, 0, 0, bm.bmWtdth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY );

ReleaseDC( hwnd, hdc ); DeleteDC( hdcMem ); CloseClipboard();

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

4. Рассмотреть механизм чтения и записи метафайлов.

Запись метафайла. В текстовом и декартовых режимах отображения масштаб является фиксированным. Изотропный и анизотропный режимы требуют наличия специальной информации, сопровождающей команды метафайла.

37

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

Структура METAFILEPICT определена в файле WinGDI.H:

typedef struct tagMETAFILEPICT

{

LONG mm; LONG xExt; LONG yExt; HMETAFILE hMF;

}

METAFILEPICT, FAR *LPMETAFILEPICT;

Поле mm содержит идентификатор режима отображения. Поле hMF представляет собой дескриптор набора команд метафайла. Остальные два поля, xExt и yExt, могут содержать два разных типа информации в зависимости от режима отображения.

Для текстового и декартовых режимов в полях xExt и yExt задаются размеры содержащегося в метафайле изображения по горизонтали и по вертикали, в единицах, которые соответствуют режиму отображения.

При использовании изотропного и анизотропного режимов отображения поля xExt и yExt содержат необязательные, рекомендуемые размеры, выраженные в единицах MM_HIMETRIC. Если рекомендуемые размеры не указываются, эти поля могут содержать нулевые значения. Если же поля xExt и yExt имеют отрицательные значения, значит, они представляют соотношения размеров, а не абсолютные размеры.

Функция DrawMetafile создает метафайл в памяти и после создания метафайла следующий шаг заключается в формировании структуры METAFILEPICT в памяти и получении с помощью функции GlobalLock ее указателя lpMFP:

hGMem = GlobalAlloc( GHND, (DWORD) sizeof( METAFILEPICT ) ) ; lpMFP = (LPMETAFILEPICT) GlobalLock( hGMem ) ;

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

lpMFP->mm = MM_ISOTROPIC;

lpMFP->xExt = 200; // рекомендуемые размеры // lpMFP->yExt = 200; // в единицах MM_HIMETRIC // lpMFP->hMF = hMetaFile;

38

Далее остается только разблокировать память и передать дескриптор метафайла в буфер обмена.

GlobalUnlock( hGMem ) ;

TransferToClipboard( hwnd, hGMem, CF_METAFILEPICT );

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

OpenClipboard( hwnd );

hGMem = GetClipboardData( CF_METAFILEPICT ); lpMFP = (LPMETAFILEPICT) GlobalLock( hGMem );

Теперь переменная lpMFP содержит указатель блока памяти, в котором находится метафайл, или, точнее, структуры METAFILEPICT, которая, в свою очередь, хранит указатель собственно метафайла.

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

SaveDC( hdc );

CreateMapMode( hdc, lpMFP, cxWnd, cyWnd ) ;

Далее информация, которая содержится в структуре METAFILEPICT, передается на обработку функции CreateMapMode. Это делается потому, что расшифровка информации о режиме отображения и о размерах - задача довольно сложная.

Функция CreateMapMode вызывается с четырьмя параметрами, которые задают дескриптор контекста устройства для приложения, указатель структуры METAFILEPICT и размеры окна приложения.

BOOL CreateMapMode( HDC hdc, LPMETAFILEPICT lpMFP, int cxWnd, int cyWnd )

{

long lMapScale;

int nHRes, nVRes, nHSize, nVSize; SetMapModet hdc, lpMFP->mm );

if( lpMFP->mm!=MM_ISOTROPIC&&lpMFP->mm!= MM_ANISOTROPIC

)

return( TRUE ) ;

Сначала функция CreateMapMode устанавливает режим отображения, заданный для метафайла. Если задано какое-либо другое значение, не

39

MM_ISOTROPIC или MM_ANISOTROPIC, функция просто завершает свою работу, не выполняя никаких действий.

Если режим отображения является изотропным или анизотропным, функция CreateMapMode должна осуществить дополнительные операции. Вопервых, вызывается функция GetDeviceCaps, которая возвращает горизонтальный и вертикальный размеры экрана, а также разрешение.

nHRes = GetDeviceCaps( hdc, HORZRES ) ; nVRes = GetDeviceCaps( hdc, VERTRES ) ; nHSize = GetDeviceCaps( hdc, HORZSIZE ); nVSize = GetDeviceCaps( hdc, VERTSIZE ) ;

Последующие действия зависят от значений полей xExt и yExt, которые могут быть положительными, отрицательными или нулевыми.

Если размеры полей заданы посредством положительных значений, они воспринимаются как рекомендуемые размеры изображения в единицах MM_HIMETRIC. В этом случае вызывается функция SetViewportExtEx, которая соответствующим образом задает размеры области просмотра.

if( lpMFP->xExt > 0 )

SetViewportExtEx( hdc,(int)((long) lpMFP->xExt * nHRes / nHSize / 100 ), (int)((long) lpMFP->yExt * nHRes / nHSize / 100 ), NULL );

Если указаны отрицательные значения, содержимое полей интерпретируется как масштабный коэффициент. Поэтому сначала производится расчет масштаба по отношению к контексту устройства.

else

if( lpMFP->xExt < 0 )

{

lMapScale = min( ( 100L * (long) cxWnd * nHSize / nHRes / -lpMFP->xExt ), (100L * (long) cyWnd * nVSize / nVRes /-lpMFP->yExt ) );

Вычисляются два масштаба: по оси Х и по оси Y. Однако в качестве значения lMapScale берется меньшая из двух величин, чтобы результирующее изображение точно помещалось на экране. Теперь функция SetViewportExtEx вызывается еще раз - для согласования размеров изображения и области просмотра.

SetViewportExtEx( hdc,(int)((long) -lpMFP->xExt * lMapScale * nHRes / nHSize / 100 ),(int)((long) -lpMFP->yExt * lMapScale * nVRes / nVSize / 100 ), NULL ); }

40

приложение Win32, работающее в режиме командной строки. Программа ожидает, когда в командной строке будет задано имя файла, имя пользователя и параметр + (доступ разрешен) или - (доступ запрещен).

2. Рассмотреть исходный код программы. Предложенный код позволяет понять, как осуществляется установка или изменение атрибутов безопасности на уровне объектов в операционной системе Windows NT. Поэкспериментировать с программой, изменив ее таким образом чтобы запретить доступ к данному объекту со стороны всех пользователей или, наоборот, чтобы разрешить всеобщий доступ к нему. Изменить владельца файла. Настроить программу для работы с другими объектами, для этого модифицировать DACL.

Содержание отчета:

1.Цель работы;

2.Исходный текст модифицированной программы (согласно задания);

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

ЛАБОРАТОРНАЯ РАБОТА №6

"Обработка исключений"

Цель работы: Изучение принципов обработки исключений в программе. (На примере программы Exceptions).

Задание к лабораторной работе:

1. Запустить программу Exceptions. Данная программа содержит ряд примеров обработки исключений различного типа. Пример, который необходимо запустить, можно выбрать из меню программы.

Simple Handler - Демонстрирует простейшую структуру блоков try/catch. Nested Handlers - Демонстрирует вложенную структуру блоков try/catch.

Failed Catch - Отключает возможность перехвата ошибки доступа к памяти; может потребовать последующей перезагрузки компьютера.

Resource Exception - Ошибка, обусловленная загрузкой несуществующего устройства.

User Exception - Генерирует пользовательское исключение.

42

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

2. Рассмотреть механизм простейшего обработчика исключений. Блок try/catch перехватывает исключение при вызове процедуры ForceException, которая порождает исключение доступа к памяти. На рис. 6.1 показано окно программы, сообщения в котором позволяют отслеживать ход выполнения процедуры.

Рис. 6.1. Окно, предназначенное для наблюдения за работой простейшего обработчика исключений

В примере исключения перехватываются внутри блока catch (...) и не приводят к системной ошибке.

void CExceptionsView::OnExceptionsSimplehandler()

{

CDC *pDC = GetDC();

CSize cSize = pDC->GetTextExtent( "A", 1 ); // получить вертикальный размер текста

int vSize = cSize.cy, iLine = 0; CString csText;

Каждый из обработчиков начинается с команды получения контекста устройства, а затем вызывает функцию GetTextExtent, предназначенную для определения размера строки текста по вертикали. Это значение используется для разделения строк при отображении сообщений. Кроме того, вызываются

43

функции Invalidate и OnPaint, посредством которых удаляется текст, оставшийся от предыдущих примеров.

Invalidated;

OnPaint (); // удаляют весь предшествующий текст

csText = "Starting process";

pDC->TextOut( 10, vSize *iLine++, csText ); try

{

csText = "In try block";

pDC->TextOut( 50, v3ize*iLine++, csText ); csText = "About to cause exception"; pDC->TextOut( 50, vSize*iLine++, csText ); ForceException (); // показана ранее

Несмотря на то, что исключение происходит в отдельной процедуре, выполнение блока try приостанавливается и управление передается блоку catch (...). Поэтому следующая строка текста не будет отображаться в окне программы (см. рис. 3.1). Выполнение программы возобновится в блоке catch, где имеется другое сообщение.

csText = "This line will not display because execution has passed " "to the catch block";

pDC->TextOut( 50, vSize*iLine++, csText );

}

catch (...) // перехватывать все исключения!!!

{

csText = "In catch all block"; pDC->TextOut( 50, vSize*iLine++, csText );

}

csText = "End of process";

pDC->TextOut( 10, vSize*iLine++, csText );

}

3. Рассмотреть механизм обработчика вложенного исключения. Второй пример демонстрирует использование вложенных исключений путем размещения одного блока try/catch внутри другого, внешнего блока. Кроме того, внутренний блок содержит набор команд catch, которые оперируют различными классами, производными от CException. Наконец, оператор throw во внутреннем блоке catch передает перехваченное исключение внешнему блоку catch.

void CExceptionsView::OnExceptibnsNestedhandlers()

{

44

CDC *pDC = GetDC() ;

CSize cSize = pDC->GetTextExtent( "A", 1 ); int vSize = cSize.cy, iLine = 0;

CString csText;

csText = "Starting process"; pDC->TextOut( 50, vSize*iLine++, csText ); try

{

csText = "In outer try block"; pDC->TextOut ( 50, vSize*iLine++, csText ); try

{

csText = "In inner try block"; pDC->TextOut( 90, vSize*iLine+.+, csText ); csText = "About to cause exception ..."; pDC->TextOut( 90, vSize*iLine++, csText );

ForceException ();

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

csText = "This line will not display because execution " "has passed to the catch block";

pDC->TextOut( 50, vSize*iLine++, csText );

}

Далее следует набор блоков catch, каждый из которых предназначен для перехвата исключения, тип которого определяется классом, производным от CException. Но тип исключения, задействованного в данном примере (ошибка доступа к памяти), не относится ни к одному из этих классов. Поэтому реальный перехват не произойдет до тех пор, пока не будет найден подходящий обработчик.

Все операторы catch имеют практически одно и то же тело (различаются лишь выводимой на экран строкой), поэтому достаточно рассмотреть одну структуру:

45

csText = "CMemoryException cause: "; e->GetErrorMessage( szCause, 255 ); csText += szCause;

pDC->TextOut( 90, vSize*iLine++, csText );

}

catch ( CFileException *e ) // ошибка при работе с. файлом

{

...

}

catch( CArchiveException *e ) // ошибка, допущенная при

// операции архивации/сериализации

{

...

}

catch( CResourceException *e ) // ошибка, допущенная при

// выделении ресурса

{

...

}

//с базами данных (DAO-классы)

{

...

}

catch( CDBException *e ) // исключения, связанные

// с базами данных (ODBC-классы)

{

...

}

46

*/

Вслед за этим следует блок catch (CException *e). В противном случае компилятор воспринял бы предыдущие блоки как ошибочные.

catch ( CException *e ) // должен следовать после предыдущих блоков, { // иначе компилятор выдаст код ошибки

TCHAR szCause[255] ; csText = "CException cause: ";

e->GetErrorMessage( szCause, 255 ); csText += szCause; pDC->TextOut( 90, vSize*iLine++, csText );

}

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

csText = "In inner catch all block: "; pDC->TextOut( 90, vSize*iLine++, csText );

csText = "Throwing exception to outer catch block: "; pDC->TextOut( 90, vSize*iLine++, csText );

throw; // передает исключение внешнему блоку catch, // приведенному ниже

}

Исключение, произошедшее во внутреннем блоке try, перехватывается внутренним блоком catch и передается внешнему блоку catch. Оператор throw предотвращает выполнение фрагмента программы, который следует после

47

блоков try/catch. Аналогичная обработка происходит автоматически во внутреннем блоке try при генерации исходного исключения. Единственное различие между ними заключается в том, что при входе программы во внутренний блок catch внешний блок try исполняться не будет. Это дает дополнительную возможность проконтролировать ход выполнения приложения и позволяет при необходимости предотвратить выполнение последующих операторов программы.

csText = "This line will not display because execution has been " "thrown to the outer catch block";

pDC->TextOut( 50, vSize*iLine++, csText );

}

catch(...) // перехват всех сообщений!!!

{

csText = "In outer catch all block, catching thrown exception"; pDC->TextOut( 50, vSize*iLine++, csText );

}

csText = "End of process";

pDC->TextOut (10, vSize*iLine++, csText );

}

На рис. 6.2 представлен отчет, который генерируется во время выполнения модуля Nested Handlers.

Рис. 6.2. Отчет, генерируемый в процессе выполнения примера Nested Handlers

4. Рассмотреть пример неудачной обработки исключения. Модуль Failed Catch демонстрирует, что происходит в том случае, когда блоки try/catch пытаются защитить выполнение определенного фрагмента программы, однако не могут правильно перехватить исключение (программа наталкивается на

48

csText = "In catch block";

pDC->TextOut( 50, vSize*iLine++, csText ); csText = _T("CException cause: "); e->GetErrorMessage( szCause, 255 ); csText += szCause;

}

Следует отметить, что выполнение модуля Failed Catch может привести к возникновению ошибки в системной памяти, что потребует перезагрузки системы. Но в любом случае будет получено предупреждающее сообщение.

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

Если необходимо предотвратить ошибку следует убрать знаки комментария в блоке catch(...).

csText = "In catch all block"; pDC->TextOut( 50, vSize*iLine++, csText );

}

*/

csText = "End of process";

pDC->TextOut( 10, vSize*iLine++, csText );

}

5. Рассмотреть механизм исключения "Загрузка несуществующего ресурса". Не все исключения генерируются системой автоматически. Во многих случаях исключение пользователю необходимо породить самостоятельно. Такая потребность возникает, когда обнаруживается неправильный результат выполнения функции или нужно перенаправить поток выполнения в обход последующих операторов. Эту задачу проще всего решить путем генерации исключения. Блок catch перехватит его, выдаст сообщение или осуществит иного рода обработку.

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

50

выводят несуществующие записи строковой таблицы. Эта ошибка сама по себе не порождает исключения. Просто в случае отсутствия искомой записи оператор LoadString возвращает строку нулевой длины. Программа Resource Exception генерирует исключение при наличии этой ошибки.

Следующий пример начинается с внутреннего и внешнего блоков try и демонстрирует применение оператора throw. Во внутреннем блоке try делается попытка загрузить строковый ресурс.

void CExceptionsView::OnExceptionsResourceexception()

{

CDC *pDC = GetDC() ;

CSize cSize = pDC->GetTextExtent( "A", 1 ); int vSize = cSize.cy, iLine = 0;

CString csText, csMsg;

csText = "Starting process"; pDC->TextOut( 10, vSize*iLine++, csText ); try

{

csText = "In outer try block"; pDC->TextOut( 50, vSize*iLine++, csText ); try

{

csText = "In inner try block"; pDC->TextOut( 90; vSize*iLine++, csText ); csText = "About to cause exception ..."; pDC->TextOut( 90, vSize*iLine++, csText );

if( ! csText.LoadString ( IDS_NON_STRING ) ) AfxThrowResourceException() ;

pDC->TextOut( 90, vSize*iLine++, csText );

}

При успешном выполнении функции LoadString программа отобразила бы загруженную строку. Но в строковой таблице нет соответствующей записи, хотя файл Resource.H содержит определение идентификатора этого ресурса. Поэтому вызывается функция AfxThrowResourceException, порождающая исключение, которое приводит к выполнению следующих блоков catch.

catch( CResourceException *e ) // ошибка выделения ресурса

{

TCHAR szCause[255];

csText = "CResourceException cause: "; e->GetErrorMessage( szCause, 255 );

51

csText += szCause;

pDC->TextOut( 90, vSize*iLine++, csText );

}

В этом блоке исключение перехватывается классом CResourceException, который передает сообщение о недоступности запрашиваемого ресурса "A required resource was unavailable" (рис. 6.4).

catch( CException *e )// данный блок должен следовать после

//предыдущих блоков,

{// иначе компилятор выдаст код ошибки

TCHAR szCause[255];

csText = "CException cause: "; e->GetErrorMessage( szCause, 255 ); csText += szCause;

pDC->TextOut( 90, vSize*iLine++, csText );

}

catch(...) // перехват всех исключений!!!.

{

csText = "In inner catch all block: "; pDC->TextOut( 90, vSize*iLine++, csText );

csText = "Throwing exception to outer catch block: "; pDC->TextOut( 90, vSize*iLine++, csText );

throw; // передает исключение внешнему блоку catch

}

Рис. 6.4. Окно, содержащее сообщения, которые возникают в процессе порождения исключения, связанного с ресурсом

Следует обратить внимание на тот факт, что блок catch(. ..) содержит оператор throw, а обработчик CResourceException - нет. Поскольку исключение

52

перехватывается (и обрабатывается) обработчиком CResourceException, оператор throw не выполняется. Поэтому внешний блок try продолжает выполнение и отображает следующее сообщение.

csText = "Still in the outer try block. This line displays because"; pDC->TextOut( 50, vSize*iLine++, csText );

csText = "execution was not thrown to the outer catch block"; pDC->TextOut( 50, vSize*iLine++, csText );

csText = "In outer catch all block, catching thrown exception"; pDC->TextOut( 50, vSize*iLine++, csText );

}

csText = "End of process";

pDC->TextOut( 10, vSize*iLine++, csText );

}

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

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

Исключения должны происходить не обязательно в той же процедуре, где расположены блоки try/catch. Рассмотреть следующий пример:

BOOL CExceptionsView::UserException()

В данном фрагменте кода функция UserException отображает окно сообщения (рис. 6.5), в котором приведена информация об ошибке, а затем функция AfxThrowUserException генерирует исключение.

Функция UserException вызывается из следующей подпрограммы, содержащей блоки try/catch:

void CExceptionsView::OnExceptionsUserexception()

{

CDC *pDC = GetDC();

53

CSize cSize = pDC->GetTextExtent( "A", 1 ); int vSize = cSize.cy, iLine = 0;

CString csText, csMsg;

csText = "Starting process"; pDC->TextOut( 10, vSize*iLine++, csText ); try

{

csText = "In try block, about to call UserException()"; pDC->TextOut( 50, vSize*iLine++, csText );

if ( UserException() )

{

csText = "In try block, the XDR Veng operation succeeded (impossible) ";

pDC->TextOut( 50, vSize*iLine++, csText );

}

csText = "Continuing try block"; pDC->TextOut( 50, vSize*iLine++, csText );

}

Рис. 6.5. Окно, содержащее сообщения, которые возникают в процессе генерации пользовательского исключения

Поскольку предполагается, что функция UserException должна породить исключение, сообщение об успешном выполнении операции никогда не появится. Если за этим процессом проследить пошагово, то станет ясно, что функция UserException не возвращает результирующего значения, поскольку выполнение передается непосредственно обработчикам catch.

catch( CUserException *e )

54

{

TCHAR szCause[255];

csText = "In CUserException catch block"; pDC->TextOut( 50, vSize*iLine++, csText ); csText = "CUserException cause: "; e->GetErrorMessage( szCause, 255 ); csText += szCause;

pDC->TextOut( 90, vSize*iLine++, csText );

}

В обработчике CUserException причина исключения идентифицируется как '"unknown" (неизвестная). В конце концов, класс CUserException не может же знать, почему было сгенерировано исключение. Но с помощью пользовательских производных классов можно обеспечить механизм, выявляющий причину возникновения исключений различных типов.

catch( CException *e )

{

TCHAR szCause[255] ;

csText = "In CException catch block (unexpected)"; pDC->TextOut ( 50, vSize*iLine++, csText ) ; csText = "CException cause: "; e->GetErrorMessage( szCause, 255 );

csText += szCause;

pDC->TextOut ( 90, vSize*iLine++, csText );

}

csText = "End of process";

pDC->TextOut( 10, vSize*iLine++, csText ); return;

}

Содержание отчета:

1.Цель работы;

2.Исходный текст подпрограмм;

3.Результаты работы подпрограмм (главные окна в ОС Windows);

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

ЛАБОРАТОРНАЯ РАБОТА №7 "Динамический обмен данными"

55

Цель работы: Изучение принципов разработки программы, позволяющей использовать динамический обмен данными (На примере программы

DDE_Demo).

Задание к лабораторной работе:

1. Запустить программу DDE_Demo. Результат работы программы представлен на рис.7.1. В результате исполнения создаются пять экземпляров приложения, взаимодействующих друг с другом. Каждый из экземпляров можно свернуть или даже убрать с экрана (сделать невидимым), но все они останутся активными вне зависимости от состояния и размеров их окон.

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

Рис. 7.1. Пять экземпляров приложения, взаимодействующих посредством DDE

2. Рассмотреть исходный код программы. В функции WinMain происходит инициализация приложения путем вызова функции InitApplication из файла Template.I. Далее вызывается DDEML-функция DdeInitialize, которая устанавливает функцию обратного вызова для управления графиком DDEсообщений:

int WINAPI WinMain( HINSTANCE hInstance, HINSTAKCE hPrevInstance,

56

LPSTR lpCmdLine, INT nCmdShow )

{

…

if( DdeInitialize( &idInst, (PFNCALLBACK) DdeCallback, APPCMD_FILTERINITS | CBF_SKIP_CONNECT_CONFIRMS |

CBF_FAIL_SELFCONNECTIONS | CBF_FAIL_POKES, 0 ) ) return(FALSE); // не продолжать при наличии ошибки

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

APPCMD_FILTERINITS - Фильтруются все приложения за исключением тех, имена которых совпадают с нашим собственным именем сервиса.

CBF SKIP_CONNECT_CONFIRMS - При установлении подключения подтверждающие сообщения не посылаются.

CBF_FAIL_SELFCONNECTIONS - Не допускается подключение приложения к самому себе.

CBF FAIL_POKES - Не допускаются транзакции XTYP_POKE.

Если по каким-либо причинам не удается установить функцию обратного вызова, приложение возвращает значение FALSE и прекращает свою работу (но это событие маловероятно).

Далее производится вызов функции CreateWindow. В случае возникновения ошибки перед выходом из приложения принимаются меры по вызову функции DdeUninitialize:

hinst = hInstance;

hwnd = CreateWindow( szAppName, szAppTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL );

if( ! hwnd )

{

DdeUninitialize ( idInst ); return ( FALSE ) ;

}

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

57

break; case 5:

xLoc = 0; yLoc = 250; break;

}

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

3. Подготовить приложения к подключению. Вызвать функции ShowWindow и UpdateWindow. Перед началом традиционного цикла передачи сообщений необходимо выполнить несколько действий, обязательных при работе с DDEML.

hszAppName = DdeCreateStringHandle( idInst, szAppTitle, 0 );

Сначала необходимо создать дескриптор строки с именем приложения. Аргумент idInst, который был получен ранее с помощью функции DdeInitialize, идентифицирует экземпляры приложения. Последний аргумент указывает кодовую страницу (по умолчанию - CP_WINANSI). В случае использования Unicode-версии DDEML следует указать кодовую страницу CP_WINUNICODE.

Далее функция RegisterClipboardFormat возвращает дескриптор формата данных, после чего с помощью функции DdeConnectList делается попытка установить соединение с остальными DDE-приложениями.

hFormat = RegisterClipboardFormat( szAppTitle );

hConvList = DdeConnectList( idInst, hszAppName, hszAppName, hConvList, NULL ) ;

Если ни одно из DDE-приложений не имеет имени и темы, совпадающих с заданными значениями, список диалогов hConvList остается пустым до тех пор, пока не появится приложение, с которым можно установить соединение.

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

DdeNameService( idInst, hszAppMame, 0, DMS_REGISTER );

После установки DDE-соединений начинается обычный цикл сообщений, который будет продолжаться вплоть до прекращения работы данного экземпляра приложения.

while( GetMessage( &msg, NULL, 0, 0 ) )

{

59

TranslateMessage( smsg ); DispatchMessage( smsg ) ;

}

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

DestroyWindow( hwnd ) ;

UnregisterClass( szAppTitle, hInstance );

4. Рассмотреть реакцию приложений на сообщения. Первая выполняемая транзакция - это XTYP_CONNECT. Поскольку уже были заданы параметры фильтрации (посредством функции DdeInitialize), любые поступающие запросы на подключение предназначены текущему DDE-приложению и могут быть приняты путем возвращения значения TRUE.

case XTYP_CONNECT: return( TRUE ) ;

Кроме того, поскольку транзакции XTYP_WILDCONNECT не обрабатываются, попытки установить "обобщенные" подключения автоматически завершатся неудачно.

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

case XTYP_ADVSTART:

return( (UINT) wFmt == hFormat && hszItem == hszAppName );

Если какой-либо из аргументов не соответствует требованиям, возвращается значение FALSE и диалог прекращается. Транзакция XTYP_REGISTER уведомляет о появлении нового приложения; в ответ обновляется список подключений hConvList и передается сообщение

XTYP_ADVSTART.

case XTYP_REGISTER:

hConvList = DdeConnectList( idInst, hszItem, hszAppName, hConvList, NULL );

PostTransaction( NULL, 0, XTYP_ADVSTART ); UpdateWindow( hwnd ) ;

return ( TRUE ) ;

60

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

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

case XTYP_DISCONNECT: InvalidateRect( hwnd, NULL, TRUE ); break;

Следующие два типа транзакций, XTYP_ADVREQ и XTYP_REQUEST, ожидают ответа в виде информационного сообщения. Во многих DDEприложениях эти транзакции подразумевают передачу данных в текстовом формате (с разделителями), совместимом с форматом CF_TEXT.

case XTYP_ADVREQ: case XTYP_REQUEST:

return ( DdeCreateDataHandle ( idInst, (PBYTE) &DataOut, sizeoft DataOut ),

0, hszAppName, hFormat, 0 ) ) ;

Функция DdeCreateDataHandle используется для получения дескриптора блока данных. Передаваемые данные имеют тип UINT (32-разрядное целое беззнаковое число), причем номер экземпляра исходного приложения, iInst, находится в старшем байте старшего слова, а остальные данные записаны в младшем слове. Формирование этих данных осуществляется процедурой WndProc и будет описано немного позже.

Когда приложение выступает в роли клиента, а не сервера, в ответ на транзакцию XTYP_ADVDATA происходит обратный процесс. С помощью функций DdeGetData и DdeSetUserHandle выполняется преобразование полученных данных в приемлемый формат.

case XTYP_ADVDATA:

if( DdeGetData( hData, (PBYTE) &DataIn, sizeof(DataIn), 0 ) ) DdeSetUserHandle( hConv, QID_SYNC, DataIn );

InvalidateRect( hwnd, NULL, TRUE ); return ( DDE_FACK ) ;

Функция DdeGetData копирует данные в локальный буфер DataIn, после чего вызывается функция DdeSetUserHandle для связывания локального буфера с дескриптором диалога hConv. Этот процесс упрощает выполнение асинхронных транзакций (они будут рассмотрены позже) и запускается в подпрограмме WndProc при вызове функции DdeQueryConvInfo в ответ на

61

сообщение WM_PAINT, когда в цикле опрашиваются все участники текущего диалога.

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

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

case XTYP_EXECUTE:

pszExec = DdeAccessData( hData, sdwSize ); if( pszExec )

{

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

Если параметр pszExec не равен NULL (т.е. указывает на строку), следующий этап заключается в определении запрашиваемой команды.

if( ! stricmp( "PAUSE", pszExec ) ) PauseAutomatic( hwnd );

else

if( ! stricmpt "RESUME", pszExec ) ) ResumeAutomatic( hwnd );

Здесь представлены только две возможные команды, которые описываются ключевыми словами PAUSE (пауза) и RESUME (продолжить) и вызывают соответствующие подпрограммы.

Поскольку операторы switch/case могут принимать только целочисленные аргументы, приходится выполнять серию операторов if/else для проверки строк. При большом количестве операций проверки это может привести к усложнению структуры программы.

В качестве альтернативного варианта предлагается воспользоваться циклической проверкой совпадения строковых аргументов с фиксированными записями в таблице строк с последующим использованием найденного номера строки в операторе switch/case.

5. Рассмотреть технологию DDE в процедуре WndProc, которая управляет работой программы DDE_Demo. При создании каждого экземпляра приложения

62

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

Подпрограмма обработки сообщения WM_TIMER - это первое место, где происходит вызов DDE-функций. Она начинается с обновления переменной

LocalStock:

case WM_TIMER: if( random( 2 ) )

LocalStock += random( 100 );

else

LocalStock -= min( (UINT) random) 100 ), LocalStock ); DataOut = ( iInst << 24 ) + LocalStock;

Далее происходит обновление переменной DataOut, которая задает пользовательский формат данных, предназначенный для передачи. Значение переменной образуется путем размещения номера экземпляра приложения iInst в старшем байте старшего слова, а переменной LocalStock - в младшем слове,

Когда данные готовы, выполняется функция DdePostAdvise, уведомляющая другие приложения о наличии данных. Передаваемое сообщение принимается другими участниками диалога с помощью функции

DdeCallback в виде транзакции XTYP_ADVDATA.

DdePostAdvise( idInst, hszAppName, hszAppName ); SetRect( &rc, 0, 0, cxText, cyText );

InvalidateRect( hwnd, &rc, TRUE ) ; UpdateWindow( hwnd ) ;

break;

После выдачи DDE-транзакции экземпляр приложения передает инструкции для обновления своего собственного окна, чтобы отобразить в нем новые данные.

Транзакцию подключения можно также выполнить в ответ на сообщение

WM_PAINT.

hConv = DdeQueryNextServer( hConvList, 0 ); while ( hConv )

{

ciData.cb = sizeof(CONVINFO); DdeQueryConvInfo( hConv, QID_SYNC, &ciData );

63

Первые два модуля, Mci.C и Mmio.C, содержат общие процедуры для выполнения основных операций с аудиофайлами, например, их записи и воспроизведения. Модуль WinMain.C создает и регистрирует окно программы и управляет диалоговым окном About. Четвертый модуль, ShowWave.C, в ответ на команды пользователя вызывает соответствующие функции. Модуль GraphWin.C управляет графическим представлением звукового сигнала, которое отображается в центре окна программы (рис. 8.1). В лабораторной работе рассмотрим только модули, обеспечивающие обработку звука - Mci и Mmio.

Рис. 8.1. Окно программы ShowWave

2. Рассмотреть модуль МСI. В модуле МСI сосредоточены все обращения к функции mciSendCommand и сформированы отдельные процедуры для каждого командного сообщения. Все процедуры являются короткими и в основном следуют такой базовой схеме:

•инициализация блока параметров;

•передача команды;

•проверка ошибок;

•возвращение результата.

Все восемь процедур, содержащиеся в модуле, описаны в начале Mci.C: ОТКРЫТЫЕ ФУНКЦИИ

ЗАКРЫТАЯФУНКЦИЯ

ReportMciError вывод сообщения об ошибке

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

67

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

Все мультимедийные устройства реагируют на сообщения MCI_OPEN и MCI_CLOSE. Кроме того, все драйверы должны реагировать еще на три сообщения: MCI_GETDEVCAPS, MCI_STATUS и MCI_INFO, каждое из которых запрашивает информацию об устройстве.

Каждая команда MCI_OPEN сопровождается структурой

MCI_OPEN_PARMS, которая определена в файле Mmsystem.H:

/* блок параметров для командного сообщения MCI_OPEN */ typedef struct tagMCI_OPEN_PARMS

{

} MCI_OPEN_PARMS;

Во всех параметрических структурах присутствует поле dwCallback. Оно используется совместно с флагом MCI_NOTIFY. Любой вызов функции mciSendCommand, запрашивающий уведомление, должен содержать дескриптор окна в младшем слове поля dwCallback. Таким образом, по завершении операции система может отправить сообщение MM_MCINOTIFY заданному окну. При рассмотрении модуля ShowWave.C вы увидите, как следует реагировать на подобное уведомление.

При открытии устройства поле wDeviceID должно оставаться пустым; подсистема WinMM назначает идентификатор открываемому устройству и записывает этот идентификатор в данное поле. После открытия любого устройства целесообразно сразу сохранить его идентификатор.

В поле lpcstrDeviceType указывается тип устройства. Он берется из системного реестра, в котором содержатся записи, подобные приведенным ниже:

AVIVideo : REG_SZ : mciavi32.dll WaveAudio : REG_SZ : mciwave.dll Sequencer : REG_SZ : mciseq.dll CDAudio : REG_SZ : mcicda.dll

Для воспроизведения WAV-файлов программе Show Wave необходимо устройство типа WaveAudio.

68

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

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

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

Все поля блока параметров заполнять не обязательно. Так, можно задать только имя элемента и позволить системе самостоятельно выбрать соответствующее устройство по расширению имени файла - скажем, проигрыватель WAV-файлов или синтезатор для MID-файлов. Если вы хотите получить информацию о любом устройстве, можно открыть его, указав его тип без задания элемента. Флаги функции mciSendCommand сообщают системе, какие поля следует прочитать. Например:

/*-------------------------------------------------------------

OPEN DEVICE

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

--------------------------------------------------------------*/ BOOL OpenDevice( HWND hWnd, LPSTR lpszFileName,

MCIDEVICEID *lpmciDevice )

{

DWORD dwRet; MCI_OPEN_PARMS mciOpenParms;

/* открытие комбинированного устройства */ mciOpenParms.lpstrDeviceType = "waveaudio"; mciOpenParms.lpstrElementName = lpszFileName;

MCI_OPEN_TYPE | MCI_OPEN_ELEMENT, // флаги (DWORD)(LPVOID) &mciOpenParms ); // блок параметров

if( dwRet != 0 )

{

ReportMCIError( hWnd, dwRet ); return( FALSE );

}

69

/* задание возвращаемых значений */ *lpmciDevice = mciOpenParms.wDeviceID; return( TRUE );

}

Первый параметр функции mciSendCommand может иметь только нулевое значение, так как устройство не открыто и ему не присвоен идентификатор. В третьем параметре содержится комбинация двух флагов. Первый из них, MCI_OPEN_TYPE, дает системе команду прочитать поле lpstrDeviceType из блока параметров, поскольку в этом поле записана соответствующая строка. Второй флаг, MCI_OPEN_ ELEMENT, дает команду прочитать поле lpstrElementName. Поскольку мы не указали флаг MCI_OPEN_ALIAS, система будет игнорировать любое значение, содержащееся в поле lpstrAlias.

Функция OpenDevice возвращает значения TRUE или FALSE, свидетельствующие об успешности ее выполнения. Кроме того, при успешном завершении функция возвращает в третьем параметре идентификатор устройства. Идентификатор устройства необходим для выполнения последующих операций, например для закрытия устройства.

/*--------------------------------------------------------

CLOSE DEVICE

Закрытие мультимедийного устройства

------------------------------------------------------------*/

void CloseDevice( HWND hWnd, MCIDEVICEID mciDevice )

{

DWORD dwRet;

dwRet = mciSendCommand( mciDevice, MCI_CLOSE, MCI_WAIT, (DWORD) NULL );

if( dwRet != 0 )

{

ReportMCIError( hWnd, dwRet ) ;

}

return;

}

Функция CloseDevice принимает идентификатор устройства. Никаких других данных ей не нужно; команда MCI_CLOSE даже не использует блок параметров.

Задание формата времени. Когда программа ShowWave приказывает устройству waveaudio воспроизвести звук, она всегда задает позицию в файле, с которой следует начать воспроизведение. С помощью полосы прокрутки, которая имеется в основном окне программы, пользователь может

70

перемещаться по файлу, т.е. начинать его воспроизведение с любой позиции. Программа ShowWave и драйвер устройства должны "договориться" о единицах измерения позиции в файле.

Такими единицами измерения могут быть байты, выборки и миллисекунды. С интуитивной точки зрения в качестве единиц измерения целесообразно использовать миллисекунды. Как говорилось выше, оцифровка производится с постоянной частотой, поэтому каждой миллисекунде оцифрованного звука соответствует одно и то же количество выборок. Например, в случае звука, оцифрованного с частотой 22,5 кГц, за одну миллисекунду происходит приблизительно 22 выборки. Вследствие этого в программе ShowWave выбран формат MM_FORMAT_MILLISECONDS. Выбор формата означает передачу сообщения MCI_SET с блоком параметров

MCI_SET_PARMS.

/* блок параметров для сообщения MCI_SET */ typedef struct tagMCI_SET_PARMS

Поле dwTimeFormat может принимать значения MM_FORMAT_BYTES, MM_FORMAT_SAMPLES или MM_FORMAT_MILLISECONDS. В программе

ShowWave стереозвук не воспроизводится, поэтому поле dwAudio мы игнорируем.

/*-----------------------------------------------------------------------

SET TIME FORMAT

Задание формата времени. Мы применяем формат миллисекунд (а не байтов или выборок).

------------------------------------------------------------------------*/ BOOL SetTimeFormat( HWND hWnd, MCIDEVICEID mciDevice )

{

DWORD dwRet; MCI_SET_PARMS mciSetParms;

/* задание формата времени (миллисекунды) */ mciSetParms.dwTimeFormat = MCI_FORMAT_MILLISECONDS; dwRet = mciSendCommand( mciDevice, MCI_SET,

MCI_SET_TIME_FORMAT,(DWORD)(LPVOID)&mciSetParms)

;

if( dwRet != 0 )

{

71

ReportMCIError ( hWnd, dwRet ) ; return ( FALSE ) ;

}

Флаг MCI_SET_TIME_FORMAT указывает системе на необходимость прочитать значение в поле dwTimeFormat структуры mciSetParms.

Воспроизведение звука. Командное сообщение MCI_PLAY инициирует воспроизведение аудиофайла. Блок параметров для этой команды называется

MCI_PLAY_PARAMS.

/* блок параметров для сообщения MCI PLAY */ typedef struct tagMCI_PLAY_PARMS

{

DWORD dwCallback; // окно для получения сообщений MM_MCINOTIFY

По умолчанию команда Play начинает воспроизведение с текущей позиции в файле и продолжает его до конца, однако флаги dwFrom и dwTo, если они установлены, заставляют подсистему WinMM начать и закончить воспроизведение в других позициях. Начальную и конечную позиции можно выразить в байтах, выборках или миллисекундах, но вы должны заранее "предупредить" драйвер устройства о том, какие единицы измерения будут использоваться. По умолчанию драйверы работают с миллисекундами.

/*--------------------------------------------------

BEGIN PLAYBACK

------------------------------------------------------*/

BOOL BeginPlay(HWND hWnd, MCIDEVICEID mciDevice, DWORD dwFrom)

{

DWORD dwRet; MCI_PLAY_PARMS mciPlayParms;

/* установка формата времени (миллисекунды) */ if( ! SetTimeFormat( hWnd, mciDevice ) )

{

return( FALSE ) ;

}

//По завершении воспроизведения в окно обратного

//вызова передается уведомляющее сообщение MM_MCINOTIFY.

//При этом оконная процедура закрывает устройство. mciPlayParms.dwCallback = (DWORD)(LPVOID) hWnd; mciPlayParms.dwFrom = dwFrom;

72

dwRet = mciSendCommand( mciDevice, MCI_PLAY, MCI_FROM | MCI_NOTIFY, (DWORD)(LPVOID) &mciPlayParms

);

if (dwRet != 0)

{

ReportMCIError( hWnd, dwRet ); return( FALSE );

Флаг MCI_FROM сигнализирует о присутствии определенного значения в поле dwFrom. Флаг MCI_NOTIFY приказывает системе отправить уведомление в конце воспроизведения. Аудиофайлы могут быть достаточно большими, поэтому мы позволяем подсистеме WinMM воспроизводить запись в фоновом режиме, пока программа ShowWave выполняет следующую процедуру. Когда подсистема WinMM обнаруживает, что достигнут конец WAV-файла, она отправляет сообщение MM_MCINOTIFY окну, указанному в поле dwCallback. (При рассмотрении процедуры ShowWave_WndProc обратите внимание на обработчик сообщения).

Уведомление не поступает до тех пор, пока устройство воспроизведения не достигнет конца аудиофайла или позиции, заданной параметром dwTo. В аргументе wParam уведомляющее сообщение содержит код завершения, который говорит о том, выполнена ли операция нормально, или же она прервана либо подавлена другой командой, адресованной к данному устройству, или же не выполнена вообще из-за ошибки устройства. В младшем слове аргумента lParam содержится идентификатор устройства.

Остановка воспроизведения. Команда MCI_STOP прерывает выполнение текущей операции. Если пользователь, начав воспроизведение длинного аудиофайла, затем принимает решение не прослушивать его до конца, он может щелкнуть на кнопке Stop. При этом передается сообщение MCI_STOP, которое отменяет воспроизведение. Подобно команде MCI_CLOSE, в сообщении MCI_STOP не используется блок параметров.

/*-------------------------------------------------

STOP PLAY Прекращение воспроизведения

---------------------------------------------------------*/

void StopPlay( HWND hWnd, MCIDEVICEID mciDevice )

{

DWORD dwRet;

dwRet = mciSendCommand(mciDevice, MCI_STOP, MCI_WAIT, (DWORD)NULL );

if( dwRet != 0 )

73

{

ReportMCIError( hWnd, dwRet );

}

return;

}

Если в сообщении MCI_STOP передать команду MCI_NOTIFY вместо MCI_WAIT, оконная процедура получит два уведомления. Первое из них, MCI_NOTIFY_ABORTED, говорит о том, что воспроизведение завершилось, не достигнув конечной точки файла. Второе уведомление, MCI_NOTIFY_SUCCESSFUL, сообщает об успешном выполнении команды

Stop.

Запись звука. На звуковых картах обычно есть разъем для подключения микрофона, что позволяет записывать звук прямо на жесткий диск. Сообщение MCI_RECORD заставляет устройство WaveAudio принимать входной сигнал от микрофона.

/* блок параметров для сообщения MCI_RECORD */ typedef struct tagMCI_RECORD_PARMS

Поля dwFrom и dwTo указывают область в существующем файле, куда должна быть записана информация. В новом файле имеет значение только поле dwTo - новые записи должны всегда начинаться с нулевой позиции. Без флага MCI_TO и значения dwTo запись продолжается до тех пор, пока не будет заполнен весь диск или пока драйвер устройства не получит команду Stop. (Для создания нового файла следует в качестве параметра имени файла в сообщении MCI_OPEN указать пустую строку - " ").

/*-----------------------------------

BEGIN RECORD

------------------------------------------*/

BOOL BeginRecord ( HWND hWnd, MCIDEVICEID mciDevice, DWORD dwTo )

{

DWORD dwRet; MCI_RECORD_PARMS mciRecordParms;

/* установка формата времени (миллисекунды) */

if ( ! SetTimeFormat ( hWnd, mciDevice ) )

{

return( FALSE ) ;

74

}

//Осуществить запись в течение заданного времени

//(в миллисекундах) . По завершении записи в окно

//обратного вызова поступает уведомление MM_MCINOTIFY.

//При этом оконная процедура сохраняет запись

//и закрывает устройство. mciRecordParms.dwCallback = (DWORD)(LPVOID) hWnd; mciRecordParms.dwTo = dwTo;

dwRet = mciSendCommand( mciDevice, MCI_RECORD, MCI_TO | MCI_NOTIFY, (DWORD)(LPVOID) &mciRecordParms ) ;

if( dwRet != 0 )

{

ReportMCIError( hWnd, dwRet ); return ( FALSE ) ;

}

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

/* блок параметров для сообщения MCI SAVE */ typedef struct tagMCI_SAVE_PARMS

{

DWORD dwCallback; // окно для получения сообщений MM_MCINOTIFY LPCTSTR lpfilename; // имя файла на диске

} MCI_SAVE_PARMS;

Строка в поле lpfilename содержит имя результирующего файла.

/*-------------------------------------

SAVE RECORD Сохранение звукозаписи

----------------------------------------*/

BOOL SaveRecord( HWND hWnd, MCIDEVICEID mciDevice, LPSTR lpszFileName )

{

DWORD dwRet; MCI_SAVE_PARMS mciSave Farms ;

//Сохранение записанных данных в указанный файл.

//Перед продолжением работы программа ожидает

//завершения операции записи. mciSaveParms.lpfilename = lpszFileName;

75

dwRet = mciSendCommand( mciDevice, MCI_SAVE, MCI_SAVE_FILE | MCI_WAIT, (DWORD)(LPVOID) &mciSaveParms ) ;

if( dwRet != 0 )

{

ReportMCIError( hWnd, dwRet ) ; return( FALSE ) ;

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

Процедура обработки ошибок использует две строки. Первая из них представляет собой название программы, которое будет отображаться в заголовке окна. Эта строка загружается из ресурса строковой таблицы. Вторая - это сообщение об ошибке, получаемое непосредственно от MCI. Функция mciSendCommand возвращает код ошибки, который программа ShowWave записывает в переменную dwRet. Если результирующее значение не равно 0, значит, произошла ошибка, и программа ShowWave вызывает функцию

ReportMCIError. Функция mciGetErrorString возвращает строку,

соответствующую коду ошибки, который содержится в переменной dwRet.

В файле Mmsystem.H определено приблизительно 90 кодов различных ошибок. Некоторые из них, например MCIERR_INVALID_DEVICE_ID, могут произойти в любой момент; другие, такие как MCIERR_CANNOT_LOAD_DRIVER, возникают только при выполнении определенных команд (в данном случае команды Open). Некоторые ошибки характерны только для определенных устройств. В частности, ошибка

MCIERR_WAVES_OUTPUTSINUSE свидетельствует о том, что все аудиоустройства в настоящий момент заняты.

/*-------------------------------------

REPORT MCI ERROR

Сообщить пользователю о возникшей MCI-ошибке

---------------------------------------------------------------*/

static void ReportMClError( HWND hWnd, DWORD dwError )

{

HINSTANCE hInstance;

char szErrStr[MAXERRORLENGTH];

char szCaption[MAX_RSRC_STRING_LEN]; hInstance = GetWindowInstance( hWnd );

LoadString( hInstance, IDS_CAPTION, szCaption, sizeof(szCaption) ); mciGetErrorString( dwError, szErrStr, sizeof(szErrStr) );

76

MessageBox( hWnd, szErrStr, szCaption, MB_ICONEXCLAMATION | MB_OK );

return;

}

3. Рассмотреть модуль ММIO. Если бы программа ShowWave только записывала и воспроизводила звуки, модуль ММIO не использовался бы. Но нам необходимо также манипулировать данными непосредственно в аудиофайлах. В частности, для графического отображения звукового сигнала необходимо читать выборки из WAV-файла. Кроме того, поскольку пользователь имеет возможность модифицировать звукозаписи, находящиеся в памяти, иногда программа ShowWave должна сохранять данные в виде нового файла. Модуль ММIO содержит одну функцию для чтения данных, одну - для записи и одну - для обработки ошибок, связанных с файлами.

Чтение WAV-файла. Функция ReadWaveData загружает все данные из WAV-файла в память. Она выполняет следующие операции:

•открытие файла;

•поиск WAVE-блока;

•поиск вложенного fmt-блока и проверка того, в подходящем ли формате записан звук;

•поиск вложенного data-блока и загрузка его в память;

•закрытие файла.

/*---------------------------------------------------

READ WAVE DATA Чтение звукозаписи из RIFF-файла в память. Возвращает TRUE при успешном заполнении буфера;

в противном случае возвращается FALSE.

Если функция возвращает TRUE, значит, в последних трех параметрах содержится информация о новом буфере.

77

/* открытие файла для чтения */

hmmio = mmioOpen( lpszFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );

if (hmmio == NULL)

{

ReportError( hWnd, IDS_CANTOPEHFILE ) ; return( FALSE ) ;

}

Команда mmioOpen принимает три входных параметра: имя файла, структуру с дополнительными параметрами и флаги для обозначения операций. Дополнительные параметры нужны только для изменения размера буфера, для открытия файла в памяти и для указания пользовательской процедуры чтения файла. Поскольку функция ReadWaveData не выполняет ни одну из этих операций, второй параметр равен NULL.

Флаг MMIO_ALLOCBUF включает буферизацию ввода/вывода. Другой флаг, MMIO_READ, задает открытие файла только для чтения. Функция mmioWrite вернет сообщение об ошибке при записи в файл, открытый с установленным флагом MMIO_READ.

/* выделяет из файла блок WAVE */ mmckinfoWave.fccType = mmioFOURCC('W,'А','V,'Е'); if

(mmioDescend(hmmio,&mmckinfoWave,NULL,MMIO_FINDRIFF)!=0)

{

ReportError( hWnd, IDS_NOTWAVEFILE ); mmioClose ( hmmio, 0 ) ;

return( FALSE ) ;

}

/* поиск вложенного блока формата */ mmckinfoFmt.ckid = mmioFOURCC('f,'m','t',' ');

if( mmioDescend( hmmio, &mmckinfoFmt, &mmckinfoWave, MMIO_FINDCHUNK ) != 0)

{

ReportError( hWnd, IDS_CORRUPTEDFILE ); mmioClose ( hmmio, 0 );

return( FALSE ) ;

}

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

78

Для поиска первого фрагмента заполняется только одно поле информационной структуры: fccType. Поле ckid (идентификатор блока) должно содержать значение RIFF, но флаг MMIO_FINDRIFF и так указывает цель этого поиска. Команда mmioDescend распознает также еще три флага: MMIO_FINDCHUNK, MMIO_FINDRIFF и MMIO_FINDLIST. Флаг

MMIO_FINDCHUNK указывает, что поиск необходимо осуществлять по содержимому поля ckid, а остальные флаги говорят о том, что поле fccType соответствует блоку RIFF или LIST.

Функция mmioDescend принимает четыре параметра: дескриптор файла, описание искомого блока, описание его родительского блока и несколько флагов. Блоки RIFF не имеют родительских блоков, поэтому третье поле мы оставляем пустым (значение NULL). Блок формата всегда является вложенным в другой родительский блок. Вложенные блоки могут быть только у блоков RIFF и LIST.

Для поиска вложенного блока формата мы записываем значение fmt в информационную структуру искомого блока и значение WAVE в информационную структуру родительского блока. По достижении конца текущего блока WAVE функция mmioDescend прекратит поиск метки fmt. Это может случиться только в том случае, если файл поврежден и его нельзя использовать, поскольку интерпретировать блок WAVE без спецификаций его формата невозможно.

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

/* чтение вложенного блока формата */ lFmtSize = (LONG)sizeof( pcmWaveFormat );

if( mmioRead( hmmio, (LPSTR)&pcmWaveFormat, lFmtSize ) != lFmtSize )

{

ReportError( hWnd, IDS_CANTREADFORMAT ) ; mmioClose ( hmmio, 0 );

return( FALSE ) ;

}

/* выход из вложенного блока в родительский блок */ if( mmioAscend( hmmio, SmrnckinfoFrnt, 0 ) != 0 )

{

ReportError( hWnd, IDS_CANTREADFORMAT ); mmioClose ( hmmio, 0 ) ;

return( FALSE ) ;

}

/* проверка того, действительно ли файл представляет собой WAV-файл в 8-разрядном РСМ-формате (моно) */

if((pcmWaveFormat.wf.wFormatTag!=WAVE_FORMAT_PCM)|| ( pcmWaveFormat .wf.nChannels != 1 ) ||

( pcmWaveFormat.wBitsPerSample != 8 ))

79

{

ReportError ( hWnd, IDS_UNSUPPORTEDFORMAT ); mmioClose( hmmio, 0 );

return( FALSE ) ;

}

Функция mmioRead требует задания дескриптора файла, указателя буфера памяти, а также количества байтов. Поле lFmtSize содержит информацию о количестве байтов в структуре PCMWAVEFORMAT, которое будет загружено из дискового файла функцией mmioRead.

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

Для простоты анализа программы Show Wave мы ограничились только 8- битовыми монозаписями. Чтобы изменить эти параметры, нужно добавить несколько дополнительных переменных и изменить подпрограмму, управляющую работой полосы прокрутки.

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

/* поиск блока данных */ mmckinfoData.ckid = mmioFOURCC('d','а','t','а');

if( mmioDescend ( hmmio, &mmckinfoData, &mmckinfoWave, MMIO_FINDCHUNK ) != 0 )

{

ReportError( hWnd, IDS_CORRUPTEDFILE ); mmioClose ( hmmio, 0 ) ;

return( FALSE ) ;

}

/* определение размера блока данных */ lDataSize = (LONG)mmckinfoData.cksize;

if( lDataSize == 0 )

{

ReportError( hWnd, IDS_NOWAVEDATA ) ; mmioClose( hmmio, 0 );

return( FALSE );

}

/* выделение и блокирование памяти */

lpData = GlobalAllocPtr( GMEM_MOVEABLE, lDataSize ); if( ! lpData )

{

ReportError( hWnd, IDS_OUTOFMEMORY ); mmioClose( hmmio, 0 ) ;

return( FALSE ) ;

80

}

/* чтение блока данных */

if( mmioRead( hmmio, (LPSTR)lpData, IDataSize ) != lDataSize )

{

ReportError( hWnd, IDS_CANTREADDATA ); GlobalFreePtr( lpData );

mmioClose( hmmio, 0 ) ; return( FALSE ) ;

}

Поиск блока data осуществляется аналогично поиску блока fmt. Функция mmioDescend записывает в переменную mmckinfoData информацию о размере блока данных. Параметр lDataSize сообщает, какой объем памяти должен быть выделен и сколько байтов необходимо прочитать из файла.

Для завершения процедуры ReadWaveData нужно закрыть файл и вернуть три значения: указатель нового объекта в памяти, количество байтов данных в этом объекте, а также частоту оцифровки:

/* закрыть файл */ mmioClose( hmmio, 0 );

/* задание возвращаемых значений */ *lplpWaveData = lpData; *lpdwWaveDataSize = (DWORD)lDataSize;

*lpdwSamplesPerSec = pcmWaveFormat.wf.nSamplesPerSec; return( TRUE ) ;

}

Запись WAV-файла. Функция WriteWaveData переносит звукозапись из буфера в памяти в файл на диске. Когда пользователь изменяет существующие аудиоданные или записывает новые, функция WriteWaveData сохраняет результат. Она выполняет следующие операции:

•открывает файл;

•создает блок RIFF формата WAVE;

•создает вложенный блок format и заполняет его поля размера и данных;

•создает вложенный блок data и заполняет его поля размера и данных;

•перемещает указатель текущей позиции в конец файла/что приводит к записи полного размера старшего блока;

•закрывает файл.

/*------------------------------------------------

WRITE WAVE DATA

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

81

/* открыть файл для записи */

hmmio = mmioOpen( lpszFileName, NULL, MMIO_ALLOCBUF | MMIO_WRITE | MMIO_CREATE );

if( hmmio == NULL )

{

ReportError( hWnd, IDS_CANTOPENFILE ); return( FALSE ) ;

}

/* создать блок RIFF формата WAVE */ mmckinfoWave.fccType = mmioFOURCC( 'W','A','V,'E' );

if( mmioCreateChunk(hmmio, SmmckinfoWave, MMIO CREATERIFF)!= 0

)

{

ReportError( hWpd, IDS_CANTWRITEWAVE ); mmioClose( hmmio, 0);

return( FALSE ) ;

}

Флаги команды mmioOpen сообщают системе о том, что мы хотим буферизовать операции с файлом, осуществлять запись, а не чтение, и что необходимо создать файл, если он еще не существует. Функция mmioCreateChunk предполагает задание трех параметров: дескриптора файла, структуры с описанием нового блока и необязательного флага, определяющего тип блока.

Структура MMCKINFO имеет поле, называющееся dwDataOffset. Функция mmioCreateChunk записывает в него значение, указывающее позицию внутри файла, в которой начинается область данных нового блока.

Функция mmioCreateChunk не может вставлять новые блоки в середину файла. Если указатель текущей позиции находится не в конце файла, запись произойдет поверх старых данных.

Сформировав основной блок RIFF, на следующем этапе создаем и инициализируем вложенный блок format:

82

/* сохранение размера вложенного блока format */ lFmtSize = (LONG)sizeoft pcmWaveFormat );

//Создание вложенного блока format.

//Поскольку размер этого блока нам известен,

//указываем его в структуре MMCKINFO,

//чтобы функции не пришлось снова определять

//размер блока при выходе из него. mmckinfoFmt.ckid = mmioFOURCC( 'f', 'm', 't', ' ' ); mmckinfoFmt.cksize = lFmtSize;

if (mmioCreateChunk( hmmio, &mmckinfoFmt, 0 ) != 0)

{

ReportError( hWnd, IDS_CANTWRITEFORMAT ) ; mmioClose( hmmio, 0 ) ;

return ( FALSE ) ;

}

/* инициализация структуры PCMWAVEFORMAT */ . pcmWaveFormat.wf.wFormatTag = WAVE_FORMAT_PCM; pcmWaveFormat.wf.nChannels = 1; pcmWaveFormat.wf.nSamplesPerSec = dwSamplesPerSec; pcmWaveFormat.wf.nAvgBytesPerSec = dwSamplesPerSec; pcmWaveFormat.wf.nBlockAlign =1; pcmWaveFormat.wBitsPerSample = 8;

/* запись вложенного блока format */

if( mmioWrite( hmmio, (LPSTR)&pcmWaveFormat, lFmtSize ) != lFmtSize

)

{

ReportError( hWnd, IDS_CANTWRITEFORMAT ); mmioClose( hmmio, 0 );

return ( FALSE ) ;

}

/* выход из вложенного блока format */ if( mmioAscend( hmmio, smmckinfoFmt, 0 ) != 0 )

{

ReportError( hWnd, IDS_CANTWRITEFORMAT ); mmioClose ( hmmio, 0 ) ;

return( FALSE );

}

He забывайте, что каждый блок содержит метку, размер и некоторые данные. Функция mmioCreateChunk оставляет место для записи размера, но если значение поля cksize равно 0, это место остается пустым до тех пор, пока следующая команда mmioAscend не закроет новый блок. Обычно функция mmioAscend должна рассчитывать объем данных, возвращаться в поле размера и заполнять его вычисленным значением, а затем снова перемещаться к концу

83

области данных. Задавая размер данных, мы предотвращаем ненужные перемещения по файлу, устраняя лишние обращения к диску.

По умолчанию в глобальной переменной dwSamplesPerSecond содержится значение 22050 (22,05 кГц), которое изменяется при загрузке нового файла с помощью функции ReadWaveData. (При выборе команды New из меню File происходит сброс этого значения.) Поскольку программа ShowWave ограничивается работой с монозаписями, характеризующимися разрядностью выборки 8 битов, каждая выборка всегда содержит 1 байт данных. Поэтому мы можем записать одно и то же значение в поля nSamplesPerSecond и nAvgBytesPerSecond переменной pcmWaveForm.

Поле nBlockAlign указывает, сколько байтов заполняется одной выборкой. Размер выборки должен быть округлен к значению ближайшего байта. Например, 12-разрядные выборки будут записываться в двух байтах. Четыре бита в каждом блоке окажутся лишними, но при загрузке их в память заполнение дополнительных разрядов ускоряет доступ к данным. Центральный процессор всегда читает информацию из памяти не отдельными битами, а целыми байтами и словами.

У вас может возникнуть вопрос, зачем нужно вызывать функцию mmioAscend, ведь при выполнении операции записи указатель текущей позиции уже переместился в конец блока формата. Это делается, опять-таки, для ускорения доступа к данным. Область данных блока всегда должна содержать четное число байтов, поэтому данные должны быть размещены по границам слов (2 байта). Если данные содержат нечетное число байтов, завершающая команда mmioAscend добавляет недостающий байт. Если количество байтов данных четное, команда mmioAscend не выполняет никаких действий. После функции mmioCreateChunk всегда желательно вызывать команду mmioAscend.

Записав блок format, мы должны повторить те же самые операции для создания блока data:

/* запись размера вложенного блока data */ lDataSize = (LONG)dwWaveDataSize;

/*создание вложенного блока data, содержащего выборки*/ mmckinfoData.ckid = mmioFOURCC( 'd', 'a', 't', 'a' ); mmckinfoFmt.cksize = lDataSize;

if( mmioCreateChunk ( hmmio, &mmckinfoData, 0 ) != 0 )

{

ReportError( hWnd, IDS_CANTWRITEDATA); mmioClose ( hmmio, 0 ) ;

return( FALSE ) ;

}

/* запись вложенного блока data */

if( mmioWrite( hmmio, lpWaveData, lDataSize ) != lDataSize )

{

ReportError( hWnd, IDS_CANTWRITEDATA );

84

mmioClose ( hmmio, 0 ) ; return( FALSE ) ;

}

/* выход из вложенного блока data */

if( mmioAscend( hmmio, &mmckinfoData, 0 ) != 0 )

{

ReportError( hWnd, IDS_CANTWRITEDATA ); mmioClose( hmmio, 0 );

return( FALSE ) ;

}

Команда mmioAscend осуществляет переход в конец вложенного блока data, но при этом мы остаемся в пределах основного блока RIFF. Следовательно, функция mmioCreateChunk вызывалась три раза, a mmioAscend - только дважды.

/* при выходе из блока WAVE происходит запись его размера */ if( mmioAscend( hmmio, &mmckinfoWave, 0 ) != 0)

{

ReportError( hWnd, IDS_CANTWRITEWAVE ); mmioClose( hmmio, 0 ) ;

return( FALSE );

}

/* закрыть файл */ mmioClose ( hmmio, 0 ) ; return( TRUE ) ;

}

Перед созданием каждого вложенного блока мы записываем значение размера в поле cksize, поэтому подсистема WinMM знает размер блока с самого начала. Но для первого, родительского, блока мы задали только формат WAVE. Заключительная команда mmioAscend завершает создание первого блока. Она вычисляет размер блока и записывает его сразу после метки RIFF в начале файла.

Обработка ошибок. Команда mciGetErrorString оперирует только теми ошибками, которые возвращаются функцией mciSendCommand, а для процедур ввода/вывода нет эквивалентной функции генерации сообщений об ошибках. Мы ввели собственные сообщения в файл ShowWave.RC и написали функцию ReportError, которая отображает эти сообщения.

/*---------------------------------------

REPORT ERROR Выдает сообщение об ошибке

-------------------------------------------*/

static void ReportError( HWND hWnd, int iErrorID )

85

{

HINSTANCE hInstance;

char szErrStr[MAX_RSRC_STRING_LEN] ; char szCaption [MAX_RSRC_STRING_LEN] ; hInstance = GetWindowInstance( hWnd ) ;

LoadString( hInstance, iErrorID, szErrStr, sizeof (szErrStr) ); LoadString( hInstance, IDS_CAPTION, szCaption, sizeof(szCaption) ); MessageBox( hWnd, szErrStr, szCaption, MB_ICONEXCLAMATION |

MB_OK );

return;

}

Содержание отчета:

1.Цель работы;

2.Исходный текст программы;

3.Результаты работы программы (главное окно в ОС Windows);

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

86