Windows api описание


Содержание

Windows API Index

The following is a list of the reference content for the Windows application programming interface (API) for desktop and server applications.

Using the Windows API, you can develop applications that run successfully on all versions of Windows while taking advantage of the features and capabilities unique to each version. (Note that this was formerly called the Win32 API. The name Windows API more accurately reflects its roots in 16-bit Windows and its support on 64-bit Windows.)

User Interface

The Windows UI API create and use windows to display output, prompt for user input, and carry out the other tasks that support interaction with the user. Most applications create at least one window.

Основы программирования для Win32 API

Материал рассматривается на примере пакета Borland C++ 5.5 command line tools

Стартовая функция WinMain

Программа на Си для Windows, как и для любой другой платформы, должна обязательно содержать некоторую «стартовую» функцию, которой передается управление при запуске программы. Вообще говоря, имя такой «стартовой» функции может различаться в различных компиляторах, но исторически сложилось так (а, кроме того, имеются еще и стандарты ANSI и ISO, к которым, правда, производители коммерческих компиляторов типа Microsoft и Borland/Inprise относятся без особого трепета), что такой функцией является: У этой функции может быть до трех параметров:

  • argc — количество параметров в командной строке (включая имя программы),
  • argv — массив строк-параметров (argv[0] — имя программы),
  • env — массив строк-переменных окружения.

Многие компиляторы для Windows «понимают» такую стартовую функцию. Однако при этом они создают хотя и 32-битное, но консольное приложение. Пример 1 (example1.cpp): Компилируем: Запускаем:

При использовании стандартных библиотек (stdio, stdlib и т. п.) вам не потребуется никаких лишних телодвижений по сравнению с обычными методами написания программ на Си. Если же ваша цель — 32-битное приложение с графическим интерфейсом, то черное консольное окошко будет вас раздражать. Пример (example2.cpp):

В общем, чтобы получить нормальное приложение без каких-либо «довесков» типа консольного окошка, используется другая стартовая функция:

  • hInst — дескриптор для данного экземпляра программы,
  • hpi — в Win32 не используется (всегда NULL),
  • cmdline — командная строка,
  • ss — код состояния главного окна.

Пример (example3.cpp):

Кроме того, компилятору и компоновщику нужно сообщить о том, что вы делаете графическое приложение. Для bcc32 это опция -tW:

Если же вы соскучитесь по черному консольному окошку, его можно в любой момент создать при помощи вызова Win32 API

О типах, о функциях

Как известно, в Си есть лишь три базовых типа ( char , int , float/double ) и еще несколько их вариаций с модификаторами signed/unsigned , short/long . Однако фирме Microsoft зачем-то понадобилось описывать функции Win32 API с помощью переопределенных типов:

Кроме перечисленных простых типов, практически ни один вызов Win32 API не обходится без «штучек» с «ручками» — переменных типа handle («ручка»), которые идентифицируют некоторый объект («штучку»). Такие «ручки» принято называть дескрипторами. Реально такая переменная представляет собой всего лишь указатель на некоторую системную структуру или индекс в некоторой системной таблице.

При заполнении различных структур часто требуется указать такую «ручку» от какой-нибудь «штучки». Очень часто вместо конкретного дескриптора допустимо передавать значение NULL , означающее, что вы еще не обзавелись такой «штучкой» или собираетесь использовать «штучку» по умолчанию.

В стандартных версиях Си для функций используются два варианта соглашения о передаче параметров: соглашение языка Си (параметры функции помещаются в стек в порядке обратном их описанию, очистку стека производит вызывающая процедура) и соглашение языка Паскаль (параметры функции помещаются в стек в (прямом) порядке их описания, очистку стека производит вызываемая процедура). Для этих соглашений использовались, соответственно, модификаторы cdecl и pascal . При описании функций Win32 API используется модификатор WINAPI , а для описания пользовательских функций обратного вызова — модификатор CALLBACK . Оба этих модификатора являются переопределением специального модификатора _stdcall , соответствующего соглашению о передаче параметров, использующегося исключительно в Win32 API, — Standard Calling Convention (параметры функции помещаются в стек в порядке обратном их описанию, очистку стека производит вызываемая процедура).

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

Окно приложения может содержать строку заголовка title bar (1), строку меню menu bar (2), системное меню system menu (3), кнопку сворачивания окна minimize box (4), кнопку разворачивания окна maximize box (5), рамку изменения размеров sizing border (6), клиентскую область client area (7), горизонтальную и вертикальную полосы прокрутки scroll bars (8):

Меню, строка заголовка с системными кнопками, системное меню, рамка изменения размеров и полосы прокрутки относятся к области окна, называемой неклиентской областью (non-client area). С неклиентской областью Windows справляется сама, а вот за содержимое и обслуживание клиентской области отвечает приложение.

Кроме главного окна, приложение может использовать еще и другие типы окон: управляющие элементы (controls), диалоговые окна (dialog boxes), окна-сообщения (message boxes). Управляющий элемент — окно, непосредственно обеспечивающее тот или иной способ ввода информации пользователем. К управляющим элементам относятся: кнопки, поля ввода, списки, полосы прокрутки и т.п. Управляющие элементы обычно не болтаются сами по себе, а проживают в каком-либо диалоговом окне. Диалоговое окно — это временное окно, напичканное управляющими элементами, обычно использующееся для получения дополнительной информации от пользователя. Диалоговые окна бывают модальные (modal) и немодальные (modeless). Модальное диалоговое окно требует, чтобы пользователь обязательно ввел обозначенную в окне информацию и закрыл окно прежде, чем приложение продолжит работу. Немодальное диалоговое окно позволяет пользователю, не закрывая диалогового окна, переключаться на другие окна этого приложения. Окно-сообщение — это диалоговое окно предопределенного системой формата, предназначенное для вывода небольшого текстового сообщения с одной или несколькими кнопками. Пример такого окна показан в Примере 3.

В отличие от традиционного программирования на основе линейных алгоритмов, программы для Windows строятся по принципам событийно-управляемого программирования (event-driven programming) — стиля программирования, при котором поведение компонента системы определяется набором возможных внешних событий и ответных реакций компонента на них. Такими компонентами в Windows являются окна. С каждым окном в Windows связана определенная функция обработки событий. События для окон называются сообщениями. Сообщение относится к тому или иному типу, идентифицируемому определенным кодом (32-битным целым числом), и сопровождается парой 32-битных параметров ( WPARAM и LPARAM ), интерпретация которых зависит от типа сообщения. В заголовочном файле windows.h для кодов сообщений определены константы с интуитивно понятными именами:

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

Для стандартных управляющих элементов (библиотека Common Controls Library — COMCTL32.DLL) в Windows имеются предопределенные обработчики событий, которые при наступлении интересных событий сообщают всяческую полезную информацию окну, содержащему этот управляющий элемент. Стандартная библиотека Common Dialog Box Library (COMDLG32.DLL) содержит несколько готовых весьма полезных диалоговых окон с обработчиками: диалоги выбора файла, настроек печати, выбора шрифта, выбора цвета и др. Кроме того, любая среда разработки (VisualBasic, Delphi, VisualC++ и т.п.) навязывает разработчику дополнительный набор готовых управляющих элементов и диалогов — иногда достаточно удобных, иногда не очень.

Структура программы

Программа для Win32 обычно состоит из следующих блоков:

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

  • UINT style — стиль (поведение) класса окон,
  • WNDPROC lpfnWndProc — процедура обработки событий окна,
  • int cbClsExtra — размер дополнительной памяти в системной структуре класса для данных пользователя,
  • int cbWndExtra — размер дополнительной памяти в системной структуре окна для данных пользователя,
  • HINSTANCE hInstance — дескриптор модуля (экземпляра программы), в котором реализована процедура обработки,
  • HICON hIcon — дескриптор иконки окна,
  • HCURSOR hCursor — дескриптор курсора мыши для окна,
  • HBRUSH hbrBackground — дескриптор «кисточки» для закрашивания фона окна,
  • LPCSTR lpszMenuName — имя ресурса, содержащего меню окна,
  • LPCSTR lpszClassName — имя класса.

Класс регистрируется при помощи функции: При успешном завершении функция возвращает целочисленный код, соответствующий строке-имени класса в общесистемной таблице строк (такой код называется атомом). При ошибке возвращается 0.

Для создания окна вызывается функция:

Вместо параметров x, y, nWindth, nHeight допустимо передавать константу CW_USEDEFAULT , позволяющую операционной системе задать эти числа по ее усмотрению.

Интерпретация кода стиля определяется классом окна. Стиль определяет не только оформление окна, но и его поведение. Общие для всех классов константы стилей (при необходимости объединяются операцией побитовое ИЛИ):

  • WS_DISABLED — при создании окно заблокировано (не может получать реакцию от пользователя);
  • WS_VISIBLE — при создании окно сразу же отображается (не надо вызывать ShowWindow );
  • WS_CAPTION — у окна есть строка заголовка;
  • WS_SYSMENU — у окна есть системное меню;
  • WS_MAXIMIZEBOX — у окна есть кнопка разворачивания;
  • WS_MINIMIZEBOX — у окна есть кнопка сворачивания;
  • WS_SIZEBOX или WS_THICKFRAME — у окна есть рамка изменения размеров;
  • WS_BORDER — у окна есть рамка (не подразумевает изменение размеров);
  • WS_HSCROLL или WS_VSCROLL — у окна есть горизонтальная или вертикальная прокрутка;
  • WS_OVERLAPPED или WS_TILED — «перекрываемое» окно — обычное окно с рамкой и строкой заголовка;
  • WS_POPUP — «всплывающее» окно;
  • WS_OVERLAPPEDWINDOW — «перекрываемое» окно с системным меню, кнопками сворачивания/разворачивания, рамкой изменения размеров, короче, типичный стиль для главного окна приложения.

Во время выполнения функции CreateWindow процедуре обработки событий окна посылается сообщение WM_CREATE . При успешном выполнении функции возвращается дескриптор созданного окна, при неудаче — NULL.

После создания окна неплохо бы сделать его видимым (отобразить), если только оно не создано со стилем WS_VISIBLE: Второй параметр этой функции — код состояния отображения окна. В качестве этого кода можно взять значение четвертого параметра, с которым была запущена функция WinMain . Другие возможные значения этого параметра:

  • SW_SHOW — отобразить и активировать окно;
  • SW_HIDE — скрыть окно;
  • SW_MAXIMIZE — развернуть окно на весь экран;
  • SW_RESTORE — активировать окно и отобразить его в размерах по умолчанию;
  • SW_MINIMIZE — свернуть окно.

Если перед вызовом этой функции окно было видимым, функция возвращает TRUE , если же окно было скрыто — FALSE .

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

Windows использует два способа доставки сообщений процедуре обработки событий окна:

  • непосредственный вызов процедуры обработки событий (внеочередные или неоткладываемые сообщенияnonqueued messages);
  • помещение сообщения в связанный с данным приложением буфер типа FIFO, называемый очередью сообщенийmessage queue (откладываемые сообщенияqueued messages).

К внеочередным сообщениям относятся те сообщения, которые непосредственно влияют на окно, например, сообщение активации окна WM_ACTIVATE и т.п. Кроме того, вне очереди сообщений обрабатываются сообщения, сгенерированные различными вызовами Win32 API, такими как SetWindowPos , UpdateWindow , SendMessage , SendDlgItemMessage .

К откладываемым сообщениям относятся сообщения, связанные с реакцией пользователя: нажатие клавиш на клавиатуре, движение мышки и клики. Чтобы извлечь сообщение из очереди, программа вызывает функцию Эта функция возвращает FALSE , если получено сообщение WM_QUIT , и TRUE в противном случае. Очевидно, что условием продолжения цикла обработки событий является результат этой функции. Если приложение хочет завершить свою работу, оно посылает само себе сообщение WM_QUIT при помощи функции Ее параметр — статус выхода приложения. Обычно эта функция вызывается в ответ на сообщение об уничтожении окна WM_DESTROY .

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

Процедура обработки сообщений окна должна быть объявлена по следующему прототипу: Значения параметров: hw — дескриптор окна, которому предназначено сообщение, msg — код сообщения, wp и lp — 32-битные параметры сообщения, интерпретация которых зависит от кода сообщения. Зачастую старший/младший байт или старшее/младшее слово параметров сообщения несут независимый смысл, тогда удобно использовать определенные в windows.h макросы:

Например, сообщение WM_COMMAND посылается окну в трех случаях:

  1. пользователь выбрал какую-либо команду меню;
  2. пользователь нажал «горячую» клавишу (accelerator);
  3. в дочернем окне произошло определенное событие.

При этом параметры сообщения интерпретируются следующим образом. Старшее слово параметра WPARAM содержит: 0 в первом случае, 1 во втором случае и код события в третьем случае. Младшее слово WPARAM содержит целочисленный идентификатор пункта меню, «горячей» клавиши или дочернего управляющего элемента. Параметр LPARAM в первых двух случаях содержит NULL , а в третьем случае — дескриптор окна управляющего элемента.

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

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

Все описанное в данном параграфе суммируется в примере 4 (example4.cpp):

Приведенный пример создает окно с кнопкой «My button», при нажатии на которую вылезает окно-сообщение:

Ресурсы

Ресурсы — это бинарные данные, добавляемые в исполняемый файл при компоновке программы. К стандартным ресурсам относятся: иконки, курсоры, меню, диалоги, растровые изображения (BMP), векторные изображения (EMF), шрифты, таблицы горячих клавиш, таблицы строк, информация о версии программы или модуля. В процессе разработки программы ресурсы описывают в отдельном текстовом файле — файле описания ресурсов (расширение .rc), — а затем при помощи компилятора ресурсов переводят в бинарный вид и добавляют в исполняемый файл на этапе компоновки исполняемого файла. Использование ресурсов значительно облегчает работу программиста по визуализации графических примитивов интерфейса программы.


Файл описания ресурсов состоит из операторов, объединяемых в блоки. Один оператор занимает одну строку файла. Допускается использовать комментарии, определяемые так же, как в программе на языке Си. Файл описания ресурсов перед компиляцией так же обрабатывается препроцессором, поэтому в нем можно использовать директивы препроцессора ( #include , #define , . ) и макроопределения. В сложных «блочных» описаниях ресурсов вместо ключевых слов BEGIN и END можно использовать < и >, соответственно.

Иконки, картинки и курсоры мыши можно описать двумя способами (квадратные скобки не являются частью синтаксиса оператора и означают необязательный элемент): Здесь nameID — численный или строковой идентификатор; RESOURCETYPE — ключевое слово, обозначающее тип ресурса: ICON , BITMAP или CURSOR ; load-option и mem-option — всякие неинтересные в данный момент опции, которые можно спокойно пропустить; filename — имя файла, содержащее соответствующий ресурс.

Эти ресурсы можно внедрить в виде шестнадцатеричных кодов непосредственно в файл ресурсов:

Следует отметить, что первая иконка в ресурсах будет использоваться «Проводником» как иконка исполняемого файла.

Меню описывается следующим образом: Здесь item-definitions — один из трех операторов: Параметры операторов имеют следующий смысл: text — текст пункта меню или подменю (может содержать комбинации \t — табуляция, \a — выравнивание по правому краю, & — следующий символ подчеркивается, обозначает «горячую» клавишу для указанного пункта меню); result — целочисленный идентификатор пункта меню, посылаемый окну-владельцу через сообщение WM_COMMAND при выборе этого пункта меню; optionlist — необязательный список опций, разделенных запятой или пробелом:

  • CHECKED — рядом с пунктом меню отображается галочка,
  • GRAYED — пункт меню неактивен (не может быть выбран) и отображается серым цветом и др.

Доступ к ресурсам, скомпонованным с исполняемым файлом, можно получить при помощи следующих функций: Первый параметр этих функций — дескриптор экземпляра программы, второй — идентификатор соответствующего ресурса. Если ресурс идентифицируется не именем, а числом, то следует использовать макрос, объявленный в windows.h : Например:

Для закрепления полученных сведений, давайте добавим к примеру 4 какую-нибудь иконку и такое меню:

Для этого создаем файл ресурсов (example4a.rc):

Для перевода файла описания ресурсов в бинарный вид используется компилятор ресурсов Borland Resource Compiler: В результате получается файл example4a.res, который потребуется в процессе компоновки.

Илон Маск рекомендует:  Обрезаем длинную строку

В примере 4 надо изменить строки на

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

Обратите внимание: среди команд меню не используется код 1, который отведен кнопке «My button». Это типичная практика назначать всем дочерним элементам окна и командам меню разные численные идентификаторы, что облегчает обработку сообщения WM_COMMAND .

Компиляция и компоновка сложных проектов

Теперь компоновка программы будет более сложной, поэтому bcc32 с этой задачей не справится. В этом примере компилятор будет использоваться только для компилирования (запускаем с ключом ): В результате получаем объектный файл example4a.obj.

Чтобы собрать все части программы вместе, придется запускать компоновщик вручную (ilink32 или tlink32). В командной строке компоновщика указываются следующие параметры:

  • options — о допустимых опциях можно узнать, запустив компоновщик без параметров. Нам потребуются:
    • -aa — тип приложения «графическое для Win32» (другие варианты: -ap — консольное приложение, -ad — драйвер);
    • -Tpe — формат выходного файла «.EXE» (другой вариант: -Tpd — «.DLL»);
    • -L путь — путь для поиска библиотек и объектных файлов (обычно: -Lc:\bcc55\lib).
  • objfiles — список объектных файлов, из которых составляется программа, разделенных пробелом или знаком «+». Этот список должен начинаться с борландовского инициализационного объектного файла: c0w32.obj — для графического приложения под Win32 или c0x32.obj — для консольного приложения.
  • exefile — имя исполняемого файла, который получится в результате компоновки.
  • mapfile — имя файла, который после компиляции будет содержать карту сегментов вашей программы (оно вам надо? если нет, здесь делаем «пусто», а в опциях указываем -x, чтобы компоновщик не замусоривал рабочий каталог этой фигней).
  • libfiles — список библиотек, в которых надо искать не определенные в программе функции, разделенных пробелом или знаком «+». Как минимум, надо указать import32.lib, которая содержит код подключения к стандартным библиотекам Win32 API: kernel32.dll, user32.dll, gdi32.dll, advapi32.dll и др. Если вы используете какие-либо функции стандартных библиотек языка Си (stdlib, stdio, . ), надо указать еще cw32.lib.
  • deffile — файл параметров модуля (module definition file). Это текстовый файл, в котором определяются различные настройки компилируемой программы типа: размеры сегментов стека, кода, данных, «заглушка» (что будет происходить при попытке запуска программы в DOS) и проч. Если не указывать этот файл, компоновщик выберет вполне приличные для большинства случаев параметры по умолчанию.
  • resfiles — файлы ресурсов (разделяются пробелом или знаком «+»).

Компоновщик ilink32 умеет работать в пошаговом (инкрементирующем) режиме incremental linking, при этом он создает несколько файлов состояний (*.IL?). При последующих попытках компиляции он использует их, так что процесс компиляции занимает меньше времени. Чтобы отключить пошаговую компиляцию и не замусоривать рабочий каталог этими файлами, следует указать опцию -Gn. Например, если при отключенной пошаговой компиляции программа компилируется 8 секунд, то первая компиляция в пошаговом режиме займет 25 секунд, а все последующие — не более 2 секунд.

Итак, компонуем модифицированный пример 4:

Если все сделано правильно, первое, что становится сразу заметным — у исполняемого файла появилась иконка:

Эта же иконка отображается в строке заголовка главного окна программы. Под строкой заголовка отображается созданное нами меню. При выборе любой команды меню появляется окно-сообщение с кодом команды. При выборе команды «Exit» программа завершается.

Если ваш проект состоит из множества файлов, то компилировать и компоновать их вручную становится затруднительно. В таких случаях используются сценарии компиляции, которые обрабатываются программой make. Сценарий компиляции — текстовый файл с именем Makefile , описывающий зависимости между различными файлами проекта, следующего формата:

Сценарий компиляции должен содержать как минимум одно правило. Строка с командами обязательно должна начинаться с отступа табуляцией. В качестве имени правила обычно выступает имя файла, который получится в результате выполнения команд в теле правила. Зависимости — необязательный список имен файлов, разделенных пробелами, от которых зависит данное правило. Если при вызове make окажется, что хотя бы один файл из этого списка новее, чем файл-результат правила, то выполняются все команды из этого правила. В качестве зависимостей могут указываться имена файлов-названия других правил. Тогда make будет выполнять рекурсивную проверку зависимостей. Make не выполняет команды из правила, если все файлы-зависимости старее файла-результата.

Если не указывать в качестве файлов-зависимостей example4a.rc и example4a.cpp, то make не станет ничего делать, когда файл example4a.exe уже существует. Тем не менее, приведенный пример — не совсем удачный сценарий компиляции. Если мы изменим только файл ресурсов, make все равно будет перекомпилировать исходный текст. Если мы изменим только исходный текст, make будет перекомпилировать еще и ресурсы. С учетом этого замечания, более удачным будет следующий сценарий:

Если в командной строке make не указано иное, то make пытается выполнить первое правило из сценария. Именно поэтому первым правилом стоит example4a.exe — результат, который мы хотим получить после компиляции всего проекта.

Если написать подходящий сценарий компиляции, то для компиляции вашего проекта придется набирать лишь команду:

Диалоговые окна

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

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

Для создания модального диалога используется функция DialogBox , а для создания немодального диалога — CreateDialog :

Параметры: hInst — дескриптор экземпляра программы (модуля, в котором находится шаблон); template — имя ресурса, описывающего диалог; parent — дескриптор родительского окна; DlgFunc — диалоговая функция следующего формата: Параметры диалоговой функции такие же, как у обычной функции обработки событий. Отличие этой функции — она вызывается из предопределенной функции обработки событий для диалоговых окон. Она должна вернуть значение TRUE , если обработала переданное ей сообщение, или FALSE в противном случае. Она ни в коем случае не должна сама вызывать DefWindowProc .

При создании диалогового окна диалоговая процедура получает сообщение WM_INITDIALOG . Если в ответ на это сообщение процедура возвращает FALSE , диалог не будет создан: функция DialogBox вернет значение -1 , а CreateDialog — NULL .

Модальное диалоговое окно блокирует указанное в качестве родительского окно и появляется поверх него (вне зависимости от стиля WS_VISIBLE ). Приложение закрывает модальное диалоговое окно при помощи функции Приложение должно вызвать эту функцию из диалоговой процедуры в ответ на сообщение от кнопок «OK», «Cancel» или команды «Close» из системного меню диалога. Параметр result передается программе как результат возврата из функции DialogBox .

Немодальное диалоговое окно появляется поверх указанного в качестве родительского окна, но не блокирует его. Диалоговое окно остается поверх родительского окна, даже если оно неактивно. Программа сама отвечает за отображение/сокрытие окна (с помощью стиля WS_VISIBLE и функции ShowWindow ). Сообщения для немодального диалогового окна оказываются в основной очереди сообщений программы. Чтобы эти сообщения были корректно обработаны, следует включить в цикл обработки сообщений вызов функции:

Если эта функция вернула TRUE , то сообщение обработано и его не следует передавать функциям TranslateMessage и DispatchMessage .

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

Шаблон диалогового окна в ресурсах задается следующим образом:

В начале блока описания диалога задается: nameID — целочисленный или строковой идентификатор ресурса, x , y — координаты диалога на экране (или относительно родительского окна), width , height — размер диалога. Координаты и размеры диалога и всех элементов внутри него задаются в диалоговых единицах (dialog units). Одна горизонтальная диалоговая единица соответствует 1/4 средней ширины символа в системном шрифте. Одна вертикальная диалоговая единица соответствует 1/8 средней высоты символа в системном шрифте.

После заголовка блока идет ряд необязательных операторов-параметров диалога (property-statements) в любом порядке:

В качестве стиля диалога можно применять все перечисленные для обычных окон стили. Обычно выбирают: WS_POPUP , WS_SYSMENU , WS_CAPTION , а также WS_BORDER для немодального диалога и DS_MODALFRAME — для модального. Кроме того, можно использовать DS_SETFOREGROUND , чтобы при отображении диалога перевести его на передний план, даже если его родительское окно неактивно.

В теле шаблона (control-statements) перечисляются составляющие его управляющие элементы. Один из возможных вариантов оператора: Здесь text — текст управляющего элемента (заголовок), id — целочисленный идентификатор элемента 0. 65535 (внутри одного диалога идентификаторы всех элементов должны различаться), class — имя класса, к которому принадлежит управляющий элемент, style — стиль управляющего элемента, x , y , width , height — положение и размер диалогового элемента относительно клиентской области диалога в диалоговых единицах.

Вот пример диалога, содержащего простое статическое текстовое поле и кнопку «OK»:

Добавим этот диалог к ресурсам примера 4. В текст программы добавим две глобальных переменных:

Присвоим переменной h значение дескриптора экземпляра программы в самом начале функции WinMain . Это значение нам потребуется для вызова функции DialogBox .

Изменим обработчик сообщения WM_COMMAND следующим образом:

Теперь в текст программы необходимо добавить диалоговую процедуру:

При создании диалога вызывается процедура SetDlgItemText , меняющая содержание текстового поля в диалоге (элемент с , генерирующая сообщение WM_COMMAND с >Функция DlgProc должна быть определена или описана до ссылки на нее в вызове DialogBox .

Управляющие элементы

Управляющие элементы, как и другие окна, принадлежат тому или иному классу окон. Windows предоставляет несколько предопределенных классов управляющих элементов. Программа может создавать управляющие элементы поштучно при помощи функции CreateWindow или оптом, загружая их вместе с шаблоном диалога из своих ресурсов. Управляющие элементы — это всегда дочерние окна. Управляющие элементы при возникновении некоторых событий, связанных с реакцией пользователя, посылают своему родительскому окну сообщения-оповещения (notification messages) WM_COMMAND или WM_NOTIFY .

Как и любое другое окно, управляющий элемент может быть скрыт или отображен при помощи функции ShowWindow . Аналогично, управляющий элемент может быть блокирован или разблокирован при помощи функции: В качестве второго параметра передается флаг TRUE (разблокировать) или FALSE (блокировать). Функция возвращает значение TRUE , если перед ее вызовом окно было заблокировано. Узнать текущий статус блокирования окна можно при помощи функции: которая возвращает значение TRUE , если окно разблокировано.


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

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

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

Для управляющих элементов внутри диалогов специальный смысл имеют стили WS_TABSTOP и WS_GROUP . Если в диалоге имеются управляющие элементы со стилем WS_TABSTOP , то при нажатии пользователем на клавишу [Tab] (или [Shift]+[Tab]), текущий активный элемент диалога будет терять фокус и передавать его следующему за ним (или предыдущему) ближайшему элементу со стилем WS_TABSTOP . С помощью стиля WS_GROUP элементы диалога можно объединять в группы. Группа элементов начинается с элемента со стилем WS_GROUP и заканчивается элементом, после которого идет элемент со стилем WS_GROUP , или последним элементом в диалоге. Внутри группы только первый элемент должен иметь стиль WS_GROUP . Windows допускает перемещение внутри группы при помощи клавиш-стрелок.

Классы предопределенных управляющих элементов: «STATIC» Статический управляющий элемент представляет собой текстовую метку или прямоугольник. Не предоставляет пользователю ни средств ввода, ни вывода. Примеры:

Соответствующее описание ресурсов: Для текстовых статиков со стилями SS_LEFT , SS_RIGHT или SS_CENTER существуют более простые операторы объявления ресурсов: Чтобы поменять текст статика ему можно послать сообщение WM_SETTEXT ( wp=0 ; lp=(LPARAM)(LPCSTR)lpsz — адрес строки) или использовать функции: Чтобы сменить иконку или картинку нетекстового статика, надо послать ему сообщение STM_SETIMAGE ( wp=(WPARAM)fImageType — тип изображения: IMAGE_BITMAP или IMAGE_ICON ; lp=(LPARAM)(HANDLE)hImage — дескриптор иконки или картинки). «BUTTON» Кнопка — это небольшое прямоугольное дочернее окно, обычно имеющее два состояния: нажато/отпущено или включено/выключено. Пользователь меняет состояние этого элемента щелчком мыши. К этому классу относятся: кнопки-«давилки» (push buttons), кнопки-«галочки» (check boxes), «радио»-кнопки (radio buttons) и специальный тип групповых рамочек (group boxes). Примеры:

Соответствующее описание ресурсов: Для кнопок существуют более простые операторы объявления ресурсов: Разница между стилями BS_xxx и BS_AUTOxxx заключается в том, что при щелчке по AUTO -кнопкам Windows сама автоматически переключает их состояние. Для не AUTO -кнопок это надо делать вручную в диалоговой процедуре, послав сообщение BM_SETCHECK ( wp=(WPARAM)fCheck — флаг: BST_UNCHECKED , BST_CHECKED или BST_INDETERMINATE (для BS_3STATE -кнопок); lp=0 ) или при помощи функций: Автоматические радио-кнопки должны быть объединены в группу при помощи стиля WS_GROUP , чтобы Windows корректно их обрабатывала.
Проверить состояние кнопки можно, послав ей сообщение BM_GETCHECK ( wp=0; lp=0 ) или вызовом функции: При щелчке мыши по кнопке она присылает родительскому диалогу сообщение-оповещение WM_COMMAND ( HIWORD(wp)=BN_CLICKED; LOWORD(wp)=(int) >). «EDIT» Поле редактирования предназначено для ввода пользователем текста с клавиатуры. Щелчком мыши внутри элемента пользователь передает этому элементу фокус ввода (input focus). При этом внутри элемента появляется текстовый курсор — мигающая каретка. Пользователь может использовать мышь для перемещения каретки по полю редактирования и выделению текста в этом поле. Примеры:

Соответствующее описание ресурсов: Стиль ES_WANTRETURN означает, что кнопка [Enter] будет обрабатываться самим элементом, а не передаваться диалогу. Благодаря этому стилю оказался возможен переход на новую строчку для предложения «Она съела кусок. » (на картинке).
По умолчанию текстовые поля позволяют вводить столько текста, сколько может отобразиться в рамках поля. Чтобы предоставить пользователю возможность ввести больше текста, надо использовать стиль ES_AUTOHSCROLL (и ES_AUTOVSCROLL для многострочных полей).
Для текстовых полей существует более простой оператор объявления ресурсов: Чтобы поменять содержимое текстового поля, программа вызывает функцию SetDlgItemText . Чтобы получить текущее содержимое текстового поля, используется функция: Чтобы узнать размер строки в текстовом поле, надо послать элементу сообщение WM_GETTEXTLENGTH ( wp=0; lp=0 ).
Текстовое поле посылает родительскому диалогу следующие сообщения-оповещения WM_COMMAND ( LOWORD(wp)=(int) >):

  • HIWORD(wp)=EN_KILLFOCUS — текстовое поле потеряло фокус (фокус передан другому элементу диалога);
  • HIWORD(wp)=EN_SETFOCUS — текстовое поле получило фокус;
  • HIWORD(wp)=EN_CHANGE — пользователь изменил текст в поле;
  • HIWORD(wp)=EN_ERRSPACE — закончилось место, отведенное под текстовый буфер управляющего элемента.

«LISTBOX» Окно-список используется для отображения списка имен (например, имен файлов). Пользователь может, просматривая список, выделить один или несколько элементов щелчком мыши. При выделении того или иного элемента списка, он подсвечивается, а родительскому окну посылается сообщение-оповещение. Для очень больших списков могут использоваться полосы прокрутки. Примеры:

Соответствующее описание ресурсов: или в короткой форме: Для добавления элемента к списку следует послать ему сообщение LB_ADDSTRING ( wp=0; lp=(LPARAM)(LPCSTR)lpsz — строка для добавления). Для того, чтобы заполнить один из списков, показанных на рисунке, в обработчик сообщения WM_INITDIALOG в диалоговую процедуру был вставлен такой фрагмент: Кроме этого, список «понимает» следующие сообщения:

  • LB_DELETESTRING ( wp=(WPARAM)index; lp=0 ) — удалить элемент с указанным номером;
  • LB_INSERTSTRING ( wp=(WPARAM)index; lp=(LPARAM)(LPCSTR)lpsz ) — вставить указанную строку в список как элемент с индексом index;
  • LB_FINDSTRING ( wp=(WPARAM)indexStart; lp=(LPARAM)(LPTSTR)lpszFind ) — найти элемент, содержащий указанную строку (поиск ведется, начиная с элемента indexStart), результат сообщения — номер элемента, удовлетворяющего критерию, или LB_ERR ;
  • LB_GETCOUNT ( wp=0; lp=0 ) — количество элементов в списке;
  • LB_GETCURSEL ( wp=0; lp=0 ) — выделенный элемент в списке;
  • LB_RESETCONTENT ( wp=0; lp=0 ) — удалить все элементы из списка.

Окно-список посылает родительскому диалогу следующие сообщения-оповещения WM_COMMAND ( LOWORD(wp)=(int) >):

  • HIWORD(wp)=LBN_DBLCLK — пользователь дважды щелкнул мышью по списку;
  • HIWORD(wp)=LBN_SELCHANGE — пользователь выделил другой элемент в списке (или отменил выделение).

«COMBOBOX» Комбобокс — это помесь поля редактирования с окном-списком. Этот элемент содержит поле редактирование и список, который может отображаться все время либо «выпадать» при нажатии на кнопку рядом с полем редактирования. Есть три основных типа комбобоксов:

  • «выпадающий» комбобокс ( CBS_DROPDOWN ) содержит поле редактирования и «выпадающий» список;
  • «выпадающий» список ( CBS_DROPDOWNLIST ) не содержит поля для изменения текста;
  • простой комбобокс ( CBS_SIMPLE ) содержит поле редактирования и обычный список.

Обратите внимание, что в ресурсах значение высоты элемента определяет размер поля редактирования вместе с «выпавшим» списком по вертикали. Короткий вариант этого же объявления ресурсов: Для работы с комбобоксами существуют сообщения, аналогичные списковым: CB_ADDSTRING , CB_DELETESTRING , CB_INSERTSTRING , CB_FINDSTRING , CB_GETCOUNT , CB_GETCURSEL , CB_RESETCONTENT .
Комбобокс посылает родительскому диалогу сообщение оповещение WM_COMMAND со следующими кодами оповещения:

  • CBN_SELCHANGE , когда пользователь выделяет другую строку в комбобоксе (бывает полезным для простых комбобоксов);
  • CBN_SELENDOK , когда пользователь выбрал элемент в выпадающем списке и щелкнул мышкой по выделению (подтвердил выделение), для простых комбобоксов посылается перед каждым CBN_SELCHANGE ;
  • CBN_SELENDCANCEL , когда пользователь закрыл выпадающий список, так и не выбрав никакой элемент;
  • CBN_DROPDOWN , когда открывается выпадающий список;
  • CBN_CLOSEUP , когда выпадающий список был закрыт по той или иной причине.
Илон Маск рекомендует:  Комбинация нескольких градиентов

Кроме предопределенных управляющих элементов, Windows предоставляет еще набор стандартных управляющих элементов посредством библиотеки Common Controls Library (COMCTL32.DLL). Чтобы воспользоваться ей, в тест программы надо включить заголовочный файл commctrl.h и добавить в блок инициализации программы вызов функции:

Управляющие элементы из этой библиотеки, как правило, посылают сообщения-оповещения родительскому диалогу через сообщение WM_NOTIFY ( wp=(int) > — указатель на структуру со специльными параметрами сообщения-оповещения).

Классы управляющих элементов из Common Controls Library: List View Controls ( WC_LISTVIEW ) Элемент просмотра списков — это окно отображающее совокупность элементов. Каждый элемент может быть представлен текстовой меткой и (необязательно) иконкой. Типичный пример использования этого элемента — программа «Проводник». Содержимое того или иного каталога представляется в виде элемента просмотра списков. Есть четыре основных стиля для этого элемента:

  • крупные иконки — стиль LVS_ICON ;
  • мелкие иконки — стиль LVS_SMALLICON ;
  • список — стиль LVS_LIST ;
  • таблица — стиль LVS_REPORT .

Приведенные в примере списки заполнялись в диалоговой процедуре при инициализации диалога ( WM_INITDIALOG ): Status Windows ( STATUSCLASSNAME ) Поле статуса — это горизонтальное окно в нижней части родительского окна, которое программа обычно использует для отображения каких-либо характеристик, параметров или небольших текстовых сообщений.

В примере 4б можно заменить статическое текстовое поле на поле статуса: При создании поля статуса не требуется указывать ни размер, ни позицию окна, Windows сама выберет эти параметры подходящим образом. Для создания поля статуса можно использовать специальную функцию: С помощью сообщения SB_SETPARTS поле статуса можно разбить на части ( wp=(int)nParts — количество частей; lp=(LPARAM)(int*)widths — указатель на массив размеров частей). В таком случае текст для каждой части поля статуса задается сообщением SB_SETTEXT ( wp=(int)iPart — номер части; lp=(LPARAM)(LPSTR)lpszText — текстовая строка). Пример: Up-Down Controls ( UPDOWN_CLASS ) Управляющий элемент «up-down» представляет собой пару небольших кнопок-стрелок, нажимая которые, пользователь увеличивает или уменьшает значение. Этот элемент, как правило, связывается с элементом-компаньоном (buddy window), обычно реализованным в виде поля редактирования. Для пользователя элемент «up-down» и его компаньон представляются единым управляющим элементом.
Если при создании элемента «up-down» указать стиль UDS_AUTOBUDDY , то компаньоном будет назначен предыдущий управляющий элемент диалога. Программа может также передать дескриптор окна-компаньона при помощи сообщения UDM_SETBUDDY ( wp=(WPARAM)(HWND)hwndBuddy — дескриптор окна-компаньона; lp=0 ). Если элементу «up-down» назначить стиль UDS_SETBUDDYINT , то он будет автоматически менять текст окна-компаньона, представляющий числовое значение.
Другой способ создать элемент «up-down» — использовать функцию Progress Bars ( PROGRESS_CLASS ) Полоса прогресса — это окно, которое программа может использовать для индикации состояния выполнения какой-либо длительной операции. Окно представляет собой прямоугольник, заполняемый системным цветом слева направо.
Каждый раз, когда приложение посылает этому окну сообщение PBM_STEPIT ( wp=0; lp=0 ), заполнение полосы прогресса продвигается дальше вправо на некоторое значение. Tooltip Controls ( TOOLTIPS_CLASS ) Окно-подсказка — всплывающее окно, содержащее строку описательной информации о том или ином элементе интерфейса программы. Таким элементом интерфейса может быть конкретное окно (управляющий элемент) или прямоугольный участок клиентской области какого-либо окна. Большую часть времени подсказка скрыта. Она появляется, когда пользователь задерживат курсор мыши над тем или иным элементом интерфейса программы более, чем на полсекунды. Подсказка скрывается, когда пользователь кликает мышью или уводит курсор с этого элемента. Одно окно-подсказка может обслуживать любое количество элементов интерфейса. Чтобы назначить тому или иному элементу интерфейса программы подсказку, надо окну-подсказке послать сообщение TTM_ADDTOOL ( wp=0; lp=(LPARAM)(TOOLINFO*)lpti — указатель на структуру, содержащую информацию об элементе). Пример:
Property Sheets & Tab Controls Элементы вкладки свойств и переключатели вкладок обычно используются совместно. Пример использования вкладок:

Каждая вкладка содержит свой набор управляющих элементов и может задаваться в ресурсах так же, как и отдельный диалог: Для создания диалога с вкладками используется функция PropertySheet , перед вызовом которой надо заполнить соответствующие системные структуры: Для каждой вкладки может быть своя диалоговая процедура, а может быть общая для всех вкладок (как в этом примере). Trackbars ( TRACKBAR_CLASS ) Ползунок (бегунок) используется, если от пользователя требуется получить дискретное значение из определенного диапазона. Маркер ползунка пермещается на заданное программой значение. Пример ползунка показан на первой вкладке предыдущего примера. Ползунки бывают горизонтальные ( TBS_HORZ ) или вертикальные ( TBS_VERT ). Диапазон значений ползунка задается сообщением TBM_SETRANGE ( wp=(BOOL)fRedraw — перерисовать маркер после изменения диапазона; lp=MAKELONG(lMinimum,lMaximum) — диапазон значений: младшее слово — минимальное значение, старшее слово — максимальное значение). Переместить ползунок можно при помощи сообщения TBM_SETPOS ( wp=TRUE ; lp=(LONG)position — новая позиция ползунка). Чтобы получить текущее значение ползунка, следует послать ему сообщение TBM_GETPOS ( wp=0; lp=0 ). Ползунок оповещает родительское окно о событиях через сообщение WM_HSCROLL ( LOWORD(wp)=ScrollCode — код события; HIWORD(wp)=posistion — позиция маркера ползунка; lp=(HWND)hwndTrackBar — дескриптор элемента). Toolbars ( TOOLBARCLASSNAME ) Панель инструментов — это окно, содержащее набор кнопок, посылающих командное сообщение родительскому окну, когда пользователь щелкает по ним. Как правило, кнопки на панели инструментов соответствуют часто используемым командам меню приложения. Панель инструментов располагается ниже строки меню.

Информация о кнопках передается панели инструментов через структуру TBBUTTON , а для создания окна панели инструментов удобно использовать функцию CreateToolbarEx . Rich Edit Controls ( RICHEDIT_CLASS ) Продвинутое поле редактирования является развитием класса «EDIT» стандартных управляющих элементов. Элементы управления этого класса поддерживают форматирование текста (по отдельным символам и по отдельным абзацам) и позволяют внедрять OLE-объекты. Tree View Controls ( WC_TREEVIEW ) Элемент просмотра дерева позволяет представлять информацию об иерархии некоторых объектов (содержание документа, дерево каталогов файловой системы и т.п.) Каждый объект может быть представлен текстовой меткой и иконкой. Объект может иметь иерархию дочерних объектов, которая раскрывается по щелчку на этом элементе.

Стандартные диалоги

Windows предоставляет набор готовых стандартных диалогов посредством библиотеки Common Dialog Boxes Library (COMDLG32.DLL): диалог открытия и сохранения файла, диалог печати документа, диалог выбора цвета, шрифта и т.п. Чтобы создать один из перечисленных диалогов, надо заполнить определенную структуру и вызвать соответствующую функцию из этой библиотеки:

  • BOOL WINAPI ChooseColor(CHOOSECOLOR* lpcc) — создает диалог, отображающий палитру цветов и позволяющий пользователю выбрать тот или иной цвет или создать свой.
  • BOOL WINAPI ChooseFont(CHOOSEFONT* lpcf) — создает диалог, отображающий имена установленных в системе шрифтов, их кегль, стиль начертания и т.п.
  • BOOL WINAPI GetOpenFileName(OPENFILENAME* lpofn) и BOOL WINAPI GetSaveFileNAme(OPENFILENAME* lpofn) — создают диалог, отображающий содержимое того или иного каталога, и позвояющий пользователю выбрать уникальное имя файла для открытия или сохранения.
  • BOOL WINAPI PrintDlg(PRINTDLG* lppd) — создает диалог, позволяющий пользователю установить различные опции печати, например, диапазон страниц, количество копий и др.
  • BOOL WINAPI PageStupDlg(PAGESETUPDLG* lppsd) — создает диалог, позволяющий пользователю выбрать различные параметры страницы: ориентацию, поля, размер бумаги и т.п.
  • HWND WINAPI FindText(FINDREPLACE* lpfr) — создает диалог, позволяющий пользователю ввести строку для поиска и такие опции, как направление поиска.
  • HWND WINAPI ReplaceText(FINDREPLACE* lpfr) — создает диалог, позволяющий пользователю ввести строку для поиска, строку для замены и опции замены (направление поиска, область поиска).

Все перечисленные диалоги, кроме последних двух, — модальные, т.е. указанная функция не вернет значение, пока пользователь тем или иным способом не закроет диалог. Значение TRUE означает, что пользователь закрыл диалог, нажав на «ОК», а соответствующая структура заполнена новыми значениями. Значение FALSE означает, что пользователь нажал на [Esc], выбрал команду системного меню «Закрыть» или нажал кнопку «Отмена», а соответствующая структура осталась неизменной. Пример использования диалога открытия файла:

Немодальный диалог в качестве главного окна

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

Пример 5 демонстрирует использование немодального диалога в приложении типа «блокнот».

Файл example5.h содержит константы-идентификаторы команд меню и элементов диалога.

Файл example5.rc описывает ресурсы программы: иконку, меню и шаблон диалога.

Файл example5.cpp — текст программы.

Программирование под Windows с использованием Win API

Основные понятия и термины, используемые при разработке Windows приложений

  • USER (16, 32) .dll – функции ввода с клавиатуры мыши, ввод через интерфейс и т.д. (взаимодействие приложений с пользователями и средой Windows).
  • KERNEL (16, 32) .dll – функции операционной системы (память, распределение системных ресурсов, загрузка).
  • GDI (16, 32) .dll – графический интерфейс (функции создания и отображения графических объектов).

GUI (Graphics User Interface) – стандартный графический интерфейс пользователя. Это та часть Windows , которая обеспечивает поддержку аппаратно-независимой графики.

API (Application Program Interface) — интерфейс прикладных программ (набор функций, сосредоточенных в ядре Windows и дополнительных библиотеках).

DLL (Dynamic Link Libraries) — библиотека динамической компоновки. Функции API содержатся в библиотеках динамической загрузки.

DDE – динамический обмен данными .

Нотация Windows («венгерская нотация Чарльза Симони»)

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

  1. мнемоническое значение – идентификатор должен легко запоминаться;
  2. смысловое значение – роль идентификатора должна быть ясна из его названия;
  3. преемственность – похожие объекты должны иметь похожие идентификаторы;
  4. быстрота принятия решения – придумывание, ввод и редактирование идентификатора не должны занимать много времени.

Некоторые префиксы венгерской нотации:

Префикс Значение
A массив
B логический тип (int)
By беззнаковый символьный тип (byte)
C символьный тип (1 байт)
Cb счетчик байтов
Cr цвет
cx,cy короткий тип (short)
Dbl double (с плавающей точкой)
Dw беззнаковое длинное целое число (dword)
Flt float (вещественная с плавающей точкой)
Fn функция
g_ префикс для глобальной переменной (глобальная переменная)
H handle (беззнаковое целое число)
hDC handle (указатель на контекст устройства)
I целое (integer)
Id интегральное значение идентификатора
L длинный тип (long)
Lp длинный указатель
Lpsz дальний указатель на строку, заканчивающуюся нулевым байтом
m_ переменная класса
N short или int
Np ближний указатель
P указатель
Pfn указатель на функцию
Pst указатель на структуру
Psz указатель на строку, заканчивающуюся нулевым байтом
Pv указатель на тип void
S строка
Sz строка, заканчивающая нуль-символом
U беззнаковый символ
Tm текстовая метрика
V тип void
W беззнаковое целое (word, 16-бит)
x, y короткое целое число (координата x или y)

Часто используемые типы данных Windows:

Тип данных Описание
HANDLE определяет идентификатор; 32-разрядное целое, используемое в качестве дескриптора – числа, определяющего некоторый ресурс
HWND определяет идентификатор окна
HDC определяет идентификатор контекста устройства
LONG 32-битовое целое со знаком
LPSTR определяет линейный указатель
NULL
UINT тип данных Win32 (32 бита для Win32)
WCHAR 16-битовый символ UNICODE. Используется для представления символов языков мира

Создание простейшего Windows-приложения с использованием Win API

Элементы Windows-приложения

Построение приложения Windows включает выполнение следующих этапов:


  1. Создание WinMain(. ) и связанных с ней функций на языке C или C++.
  2. Создание описаний меню и всех дополнительных ресурсов, помещение описаний в файл описания ресурсов.
  3. Создание уникальных курсоров, пиктограмм и битовых образов.
  4. Создание диалоговых окон.
  5. Создание файла проекта.
  6. Компиляция и компоновка всего кода.

Простейшая программа. Создание и вывод Windows-окна на экран

Создадим пустой проект Windows- приложения с помощью мастера:

  1. File New Project.
  2. Project types: Win32 Templates: Win32 Project.
  3. Ok.
  4. Установить галочку Empty project.
  5. Добавить в проект файл *.cpp.
  6. Project Properties. Вкладка Configuration Properties General.
  7. Значение поля Character Set устанавливаем Use Multi-Byte Character Set.

Добавим следующий код:

Скомпилируем и запустим программу. На экране появится Windows-окно.

Комментарии к программе

Все приложения Windows должны содержать два основных элемента: функцию WinMain(. ) и функцию окна WndProc .

Функция WinMain(. ) служит точкой входа в приложение. Эта функция отвечает за следующие действия:

  1. регистрацию типа класса окон приложения;
  2. выполнение всех инициализирующих действий ;
  3. создание и инициализацию цикла сообщений приложения;
  4. завершение программы (обычно при получении сообщения WM_QUIT ).

Функция WndProc отвечает за обработку сообщений Windows. Эта часть программы является наиболее содержательной с точки зрения выполнения поставленных перед программой задач. Если мы хотим, чтобы программа обращала на наши действия внимание, то необходимо добавить ветки case для оператора switch в оконную процедуру WndProc . Например, если мы хотим, чтобы наше приложение обращало внимание на щелчок левой кнопкой мыши – добавляем ветку case WM_LBUTTONDOWN . В настоящий момент в оконной процедуре происходит только обработка сообщения WM_DESTROY . Больше Windows-окно пока ничего делать не умеет.

Заголовочный файл windows.h нужен для любой традиционной Windows программы на C. Именно в нем содержатся разные определения констант ( WM_DESTROY и т. д.).

В чем суть WinApi?

Windows API — это самый низкоуровневый интерфейс Windows, доступный прикладному программисту — в том плане, что он на долгосрочной поддержке и не изменится с Windows 11.

Поверх Windows API работают все BOOST и STL.

Пример: читать файл в 130 мегабайт по одному байту. Добавив асинхронного чтения через OVERLAPPED, я сумел это сделать менее чем за 2 секунды (это был поток общего назначения с виртуальными read(), write() и seek(); специализированный прикладной буфер даст ещё выигрыша, но и это хорошо). То же самое через FILE* — не дождался.

Пример второй, всё те же файлы. Дело в том, что Excel захватывает свои файлы на всё время, пока он открыт. Закрывать? — плохой выбор. Добавив один флажок в CreateFile, документы всё-таки стало возможным открывать при работающем Excel.

ЧТО ТАКОЕ WIN32 API?

API (Application Programming Interface) — интерфейс программирования приложений и всегда связан с другим приложением. Например, Microsoft Excel, Lotus Organizer и множество других приложений имеют API. Pазработчики программного обеспечения не покупают программный интерфейс, они строят его при создании приложений.

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

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

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

Win32 API идеально подходит под это описание: он обеспечивает доступ практически ко всем функциям Windows 95/98 и Windows NT. Win32 API помогает Windows 95/98 и Windows NT управлять памятью, различными устройствами, например принтером, обрабатывать события, рисовать на экране диалоговые окна и т. д.

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

Во многих программах, например, Microsoft Excel и Lotus cc:Mail, также используется Win32 API. Если приложению или модулю Windows 9х или Wiindows NT требуется некоторое средство, то обычно вызывается функция Win32 API.

Использование библиотек динамической компоновки

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

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

Одни файлы библиотек динамической компоновки имеют расширение DLL, другие — расширение ЕХЕ. Следующие файлы составляют большую часть Win32 API:

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

Когда нужно использовать Win32 API?

С помощью Win32 API можно использовать в разрабатываемом приложении не только средства VBA или основного приложения, но и те же фунции, что применяет Windows 9х или Windows NT. Эти средства позволяю пример, управлять памятью или создавать диалоговые окна для установки системного времени. Хотя в проекте VBA обычно используется только процент функций Win32 API, однако доступны практически все 100 процентов.

Win32 АPI включает более 1500 функций, поэтому здесь невозможно описать каждое средство. Вместо этого приводится классификация функцией API:

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

Элементы управления Windows. Данная группа функций управляет инструментами управления, используемыми в приложениях Windows, например, полями, кнопками и списками, а также стандартными диалоговыми окнами, такими как диалоговые окна «Открытие файла» и «Печать».

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

Илон Маск рекомендует:  Атрибут longdesc в HTML

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

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

Языковая поддержка. Данная группа обеспечивает языковую поддержку для Windows 9х, Windows NT и их приложений.

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

Подробную информацию о группах и функциях Win32 API смотрите в руководстве по Win32 SDK, которое поставляется Microsoft.


Не нашли то, что искали? Воспользуйтесь поиском:

Лучшие изречения: Сдача сессии и защита диплома — страшная бессонница, которая потом кажется страшным сном. 8774 — | 7145 — или читать все.

188.64.174.135 © studopedia.ru Не является автором материалов, которые размещены. Но предоставляет возможность бесплатного использования. Есть нарушение авторского права? Напишите нам | Обратная связь.

Отключите adBlock!
и обновите страницу (F5)

очень нужно

Windows api: описание

Windows API был изначально спроектирован для использования в программах, написанных на языке Си или C++. Работа через Windows API — это наиболее близкий к системе способ взаимодействия с ней из прикладных программ. Более низкий уровень доступа, необходимый только для драйверов устройств, в текущих версиях Windows предоставляется через Windows Driver Model.

Версии

  • Win16 — первая версия Windows API для 16-разрядных версий Windows. Изначально назывался просто Windows API, затем стал называться Win16 для отличия от Win32.
  • Win32s — подмножество Win32, устанавливаемое на семейство 16-разрядных систем Windows 3.x, и реализующее ограниченный набор функций Win32 API для этих систем.
  • Win32 — 32-разрядный API для современных версий Windows. Самая популярная ныне версия. Базовые функции этого API реализованы в динамически подключаемых библиотеках kernel32.dll и advapi32.dll ; базовые модули графического интерфейса пользователя — в user32.dll и gdi32.dll . Win32 появился вместе с Windows NT и затем был перенесён в несколько ограниченном виде в системы серии Windows 9x. В современных версиях Windows, происходящих от Windows NT, работу Win32 GUI обеспечивают два модуля: csrss.exe (процесс исполнения клиент-сервер), работающий в пользовательском режиме, и win32k.sys в режиме ядра. Работу же системных Win32 API обеспечивает ядро — ntoskrnl.exe .
  • Win64 — 64-разрядная версия Win32, содержащая дополнительные функции для использования на 64-разрядных компьютерах. Win64 API можно найти только в 64-разрядных версиях Windows XP, Windows Server 2003, Windows Vista, Windows Server 2008, Windows Server 2008 R2, Windows 7 и Windows 8.

Технологии, доступные через Windows API

Алфавитный список технологий, доступных через Windows API:

  • Система контроля и управления доступом.
  • Microsoft Active Accessibility.
  • Active Directory.
  • Active Server Pages.
  • ActiveX.
  • Автоматизация.
  • Фоновая интеллектуальная служба передачи (BITS).
  • Bluetooth.
  • CDO.
  • Certificate Enrollment Control.
  • Certificate Services.
  • Collaboration Data Objects.
  • Component Object Model
  • COM Plus.
  • Common Controls.
  • Криптография.
  • Debugging and Error Handling.
  • Device I/O.
  • Распределённая файловая система.
  • DLL, процессы и многопоточность.
  • Domain Name System.
  • Dynamic Host Configuration Protocol (DHCP).
  • Extensible Authentication Protocol (EAP).
  • Extensible Markup Language (XML) и парсер MSXML.
  • Fax Service.
  • Групповая политика.
  • HTTP.
  • ICS и ICF.
  • Image Color Management (ICM)
  • Image Mastering API (IMAPI)
  • Indexing Service
  • Infrared Data Association (IrDa)
  • Internet Authentication Service (IAS)
  • Internet Connection Sharing and Firewall (ICSF)
  • Internet Explorer
  • Internet Information Services (IIS)
  • Internet Protocol Helper (IP Helper)
  • Interprocess Communications
  • Lightweight Directory Access Protocol (LDAP)
  • LSA Authentication
  • LSA Policy
  • Memory Management
  • Message Queuing (MSMQ)
  • Messaging Application Programming Interface (MAPI)
  • Microsoft .NET Passport
  • Microsoft Agent
  • Microsoft Data Access Components (MDAC)
  • Microsoft Interface Definition Language (M >См. также
  • DirectX
  • Microsoft .NET
  • Wine — свободная кроссплатформенная реализация Windows API.
  • Window >Ссылки
  • MSDN Windows API
  • Пакеты SDK
  • windows api programming — форум клуба программистов
  • Краткий справочник функций WinAPI на русском языке

Литература

  • Гэри Неббет Справочник по базовым функциям API Windows NT/2000 = Windows NT/2000 Native API Reference. — М .: «Вильямс», 2002. — С. 528. — ISBN 1-57870-199-6
Программные интерфейсы и фреймворкиMicrosoft Windows
Графика Проводник Windows • DirectX • Direct3D • GDI • Windows Presentation Foundation • Windows Color System • Windows Image Acquisition • Windows Imaging Component
Звук DirectSound • DirectMusic • XACT • Speech API • MME
Мультимедиа DirectShow • Windows Media • Media Foundation
Веб MSHTML • MSXML • Платформа RSS для Windows • JScript • ActiveX • XMLHttpRequest • Гаджеты
Доступ к данным Компоненты Microsoft Data Access • Extensible Storage Engine • ADO.NET • Sync Framework • Jet-механизм
Сети Winsock (LSP) • Filtering Platform • NDIS • Windows Rally • Сервис фоновой интеллектуальой передачи данных • P2P API
Коммуникации TAPI
Администрирование Консоль Win32 • Windows Script Host • Инструментарий управления Windows • PowerShell • Планировщик задач • Offline Files • Теневое копирование • Windows Installer • Диспетчер ошибок Windows • Журнал событий Windows
Модель компонентов COM • COM+ • DCOM • .NET Framework
Библиотеки Microsoft Foundation Classes (MFC) • Active Template Library (ATL) • Windows Template Library (WTL) • Base Class Library (BCL)
Разработка драйверов Windows Driver Model • Windows Driver Foundation (KMDF • UMDF)
Безопасность CryptoAPI (CAPICOM) • Windows CardSpace • Data protection API • Security Support Provider Interface
.NET .NET Framework • ASP.NET • ADO.NET • .NET Remoting • Windows Presentation Foundation • Windows Workflow Foundation • Windows Communication Foundation • Windows CardSpace • XNA Framework • Silverlight • Библиотека параллельного программирования
Межпроцессное
взаимодействие
Dynamic Data Exchange (DDE) • MSRPC • Именованные каналы
Текст и
поддержка языков
Framework Текстовых сервисов • Объектная модель текстов • Редактор метода ввода • Языковые пакеты • Многоязычный интерфейс
Игры XNA Framework • DirectX
Инструменты разработки элементов графического интерфейса
Низко-
уровневые

Macintosh Toolbox/Carbon • Windows API • Intrinsics • Intuition • Xlib

Высоко-
уровневые
Amiga OS

BOOPSI • Magic User Interface • Zune • ReAction GUI

Использование функций Windows API

В программах на ассемблере.

Windows предоставляет программисту возможность использовать огромное количество возможностей и ресурсов операционной системы. Для этого предназначен Windows API (Application Programming Interface). Windows API — это большая коллекция функций, располагающихся непосредственно в операционной системе и готовых для использования в пользовательских пpогpаммах. Эти функции находятся в нескольких динамически подгpужаемых библиотеках. Мы будем использовать при написании программ следующие:

Kernel32.dll — содеpжит API функции, взаимодействующие с памятью и упpавляющие пpоцессами.

User32.dll — содеpжит API функции, контpолиpующие пользовательский интеpфейс (то есть позволяющие, например, работать с элементами управления, выводимыми в создаваемых окнах).

Gdi32.dll — содеpжит API функции, ответственные за гpафические опеpации (определение цветовой палитры создаваемых окон, элементов управления и т.д.).

Кpоме этих тpех «основных», существуют также дpугие dll, котоpые можно использовать.

Пpогpаммы по мере необходимости связываются с этими библиотеками, то есть код API функций не включается в исполняемый файл. Связь осуществляется путем использования в тексте программы ссылки на одноименные файлы с расширением *.LIB , называемые библиотеками импоpта, они входят в состав паккета MASM32. Подключение библиотек импоpта осуществляется директивой

includelib. Описание передаваемых в API функции параметров содержится в одноименых файлах с расширением *.inc и называется файлами для включения.

Создание пробной программы

.MODEL flat, stdcall

summand_1 db 12h

summand_2 db 2fh

mov al, summand_2

add al, summand_1

А теперь садимся за компьютеры и пишем эту программу, проверим ее пошагово (отладка позволит проконтролировать содержимое регистров процессора).

Для компиляции (ассемблирования, то есть получения объектного модуля) – используется кнопка или меню:

Для компоновки – тоже кнопка или меню.

В результате получим EXE-файл (исполняемый модуль) – PROBA.EXE.

Для отладки программы вызываем пункт меню:

Затем выполняем программу по шагам, нажимая на кнопку “Step”:

После каждого шага контролируем содержимое регистров.

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

Теперь перейдем к детальному рассмотрению синтаксиса языка ассемблера.

Синтаксис Ассемблера

Все конструкции языка ассемблера можно разделить на 4 вида:

1) Команды (инструкции) – представляют собой символические аналоги машинных команд. Например, mov, add

2) Макрокоманды – это оформляемые определенным образом предложения текста программы, замещаемые во время компиляции другими предложениями. Это аналог подпрограммы или процедуры с тем отличием, что при вызове подпрограммы или процедуры надо указывать значения параметров, а здесь – это просто набор команд, которые выполняются при вызове.

3) Директивы — указания компилятору на выполнение некоторых действий или служат для задания режима его работы. У директив нет аналогов среди машинных команд.

4) Комментарии – содержат любые символы. Позволяют хранить примечания программиста к тексту исходной программы. Комментарии начинаются с символа точка с запятой “;”.

Формат команд и макрокоманд может быть описан следующим образом:

[имя метки] : [операция] [операнд(ы)] ; [комментарий]

Имя метки – символьный идентификатор строки программы (адрес первого байта предложения программы, которому поставлена в соответствие метка)

Операция – символическое обозначение машинной команды или макрокоманды.

Операнд(ы) – части команды, макрокоманды или директивы, обозначающие объекты, над которыми производятся действия (к этим объектам относятся константы, переменные, регистры ЦП).

metka_1: adc al, var2 ; складываем с учетом флага CF

содержимое регистра и переменную

Формат директивы, которая указывает компилятору на выполнение некоторых действий имеет следующий вид:

[имя] [директива] [операнд(ы)] ; [комментарий]

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

summand_1 db12h — имя summand_1 отличает директиву db от других директив, этому имени присваиваются такие характеристики, как адрес конкретной ячейки в памяти и длина размещенных данных. Эти характеристики присваивает имени программа-компилятор во время анализа исходной программы. Когда в исходной программе происходит обращение к переменной с этим именем, то компилятор проверяет, соответствуют ли ее характеристики правилам использования определенной команды, например, mov ax, summand_1. Например, нельзя поместить переменную с длиной 1 байт в регистр AX (он равен 2 байта), т.к. их длины не соответствуют.

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

Запишем основные директивы размещения данных.

Директива Описание Количество байт
DB (BYTE) Объявить байт
DW (WORD) Объявить слово
DD (DWORD) Объявить двойное слово
DF (FWORD) Объявить тройное слово
DQ (QWORD) Объявить учетверенное слово
DT (TBYTE) Объявить десять байтов (упятеренное слово)

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

summa db 10h (выделяется байт, в него записывается число 10h)

char1 DB ‘A’ (выделяется байт, в него записывается 8-разрядный код символа А (ASCII-код символа A))

list db 10h, 20h, 30h ,40h ОТЛИЧИЕ list dd 10203040h

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

List DB 20 DUP(0) ; выделяет 20 байтов, заполненных нулями

Windows API

Windows API (Шаблон:Lang-en) — общее наименование целого набора базовых функций интерфейсов программирования приложений операционных систем семейств Microsoft Windows корпорации «Майкрософт». Является самым прямым способом взаимодействия приложений с Windows. Для создания программ, использующих Windows API, «Майкрософт» выпускает комплект разработчика программного обеспечения, который называется Platform SDK, и содержит документацию, набор библиотек, утилит и других инструментальных средств для разработки.

Общие сведения Править

Windows API спроектирован для использования в языке Си для написания прикладных программ, предназначенных для работы под управлением операционной системы MS Windows. Работа через Windows API — это наиболее близкий к операционной системе способ взаимодействия с ней из прикладных программ. Более низкий уровень доступа, необходимый только для драйверов устройств, в текущих версиях Windows предоставляется через Windows Driver Model.

Windows API представляет собой множество функций, структур данных и числовых констант, следующих соглашениям языка Си. Все языки программирования, способные вызывать такие функции и оперировать такими типами данных в программах, исполняемых в среде Windows, могут пользоваться этим API. В частности, это языки C++, Pascal, Visual Basic и многие другие.

Для облегчения программирования под Windows, в компании Microsoft и сторонними разработчиками было предпринято множество попыток создать библиотеки и среды программирования, частично или полностью скрывающие от программиста особенности Windows API, и предоставляющие ту или иную часть его возможностей в более удобном виде. В частности, сама Microsoft в разное время предлагала библиотеки Active Template Library (ATL)/Windows Template Library (WTL), Microsoft Foundation Classes (MFC), .Net/WinForms/WPF, TXLib. Компания Borland (ныне Embarcadero, её преемник в части средств разработки) предлагала OWL и VCL. Есть кросс-платформенные библиотеки, такие как Qt, Tk и многие другие. Весомая часть этих библиотек сконцентрирована на облегчении программирования графического интерфейса пользователя.

Для облегчения переноса на другие платформы программ, написанных с опорой на Windows API, сделана библиотека Wine.

Люди Помогите найти описание API функций Windows

Windows API — наиболее важная и мощная дополнительная библиотека функций, доступная каждому VB-программисту. Многие из них, в том числе и опытные разработчики работают с ними, используя простые готовые решения, почерпнутые в различных книгах и журналах (возможно, также и в нашей постоянной рубрике «Советы для тех, кто программирует на VB»), не очень задумываясь о сути этой технологии. Такой подход является достаточным при решении простых задач, но для серьезной работы предпочтительнее более детально разобраться с основными принципами использования функций Windows API. Чем мы сейчас и займемся.
Windows API — набор функций операционной системы

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

В ходе разработки практически любого достаточно сложного приложения (MyAppication) для конечного пользователя формируется набор специфических внутренних функций, используемых для реализации данной конкретной программы, который называется MyApplication API. Часто оказывается, что эти функции могут эффективно использоваться также для создания других приложений, в том числе другими программистами. В этом случае авторы исходя из стратегии продвижения своего продукта должны решить вопрос — открывают ли они доступ к этому набору для внешних пользователей или нет? При положительном ответе на него в описании программного пакета, как его достоинство, появляется фраза о том, что «комплект включает открытый набор API-функций» (но иногда за дополнительные деньги) .

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

Соответственно, Windows API — это набор функций, являющийся частью самой операционной системы и в то же время — доступной для любого другого приложения, в том числе написанного с помощью VB. И в этом плане вполне оправдана аналогия с набором системных прерываний BIOS/DOS, который фактически представляет собой DOS API.

Отличие заключается в том, что состав функций Windows API, с одной стороны значительно шире, по сравнению с DOS, с другой — не включает многие средства прямого управления ресурсами компьютера, которые были доступны программистам в предыдущей ОС. Кроме того, обращение к Windows API выполняется с помощью обыкновенных процедурных обращений, а вызов функций DOS — через специальную машинную команду процессора, которая называется Interrupt («прерывание») .
Win16 API и Win32 API

Как известно смена Windows 3.x на Windows 95 ознаменовала собой переход от 16-разрядной архитектуры операционной системы к 32-разрядной. Одновременно произошла замена 16-разрядного Windows API (Win16 API) на новый 32-разрядный вариант (Win32 API) — о некоторых вопросах этого перехода будет говориться в этой статье. В данном случае нужно просто иметь в виду, что за небольшим исключением набор Win32 API является единым для семейств Windows 9x и Windows NT.

Далее под термином API будет подразумеваться Win API и более того, по умолчанию — Win32 API.
Зачем нужен Win API для VB-программистов

В чем суть WinApi?

Windows API — это самый низкоуровневый интерфейс Windows, доступный прикладному программисту — в том плане, что он на долгосрочной поддержке и не изменится с Windows 11.

Поверх Windows API работают все BOOST и STL.

Пример: читать файл в 130 мегабайт по одному байту. Добавив асинхронного чтения через OVERLAPPED, я сумел это сделать менее чем за 2 секунды (это был поток общего назначения с виртуальными read(), write() и seek(); специализированный прикладной буфер даст ещё выигрыша, но и это хорошо). То же самое через FILE* — не дождался.

Пример второй, всё те же файлы. Дело в том, что Excel захватывает свои файлы на всё время, пока он открыт. Закрывать? — плохой выбор. Добавив один флажок в CreateFile, документы всё-таки стало возможным открывать при работающем Excel.

Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL