Дополнительные заметки о дизайне диалогов

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

Навигация с помощью клавиатуры

Указывайте мнемоники для меток со статическим текстом и для других элементов управления с метками. Для этого необходимо поставить перед необходимым символом амперсанд (&). На некоторых платформах (особенно Windows и GTK+) мнемоники помогают пользователю быстро передвигаться между элементами управления.

Всегда предоставляйте пользователю возможность закрыть диалог без записи, предпочтительно при помощи нажатия клавиши клавиатуры Escape. Если диалог имеет кнопку с идентификатором wxID_CANCEL, то ее обработчик будет автоматически вызван, если пользователь нажмет клавишу Esc. Поэтому, если у вас на диалоге есть кнопка Close (Закрыть), то разумно дать ей идентификатор wxID_CANCEL.

Указывайте кнопку по умолчанию (обычно “OK”), используя метод wxButton::SetDefault. Команда для этой кнопки вызовется, если пользователь нажмет клавишу Enter.

Отделение интерфейса от данных

В целях упрощения примера все используемые PersonalRecordDialog данные мы храним внутри диалога. Однако более правильным будет создание отдельного класса данных, который будет отделен от класса диалога. С помощью конструктора копирования и оператора присваивания вы можете передать копию данных в диалог и получить модифицированную копию данных из диалога только если пользователь подтвердил изменения. Это же правило применимо и для некоторых стандартных диалогов. В качестве упражнения вы можете переписать PersonalRecordDialog, чтобы он использовал класс PersonalRecordData. При такой реализации конструктор диалога должен получать ссылку на PersonalRecordData. В диалоге также желательно создать функцию GetData, которую может вызывать приложение, чтобы получить данные из диалога.

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

Если в вашем диалоге нет кнопки “Apply” (Применить), которая сохраняет ваши изменения, то нажатие на “Cancel” должно оставлять данные данные приложения в том же состоянии, как они были до открытия диалога. Использование отдельного класса данных очень легко решает эту задачу, так как диалог редактирует не “настоящие” данные, а только их копию.

Макет

Если диалог выглядит излишне компактным или сжатым, то можно добавить в него немного пространства. Попробуйте увеличить пространство около границы диалога, используя дополнительные сайзеры (как это сделано в PersonalRecordDialog) и добавив пространство между группами элементов. Рекомендуется использовать wxStaticBoxSizer и wxStaticLine, чтобы логически сгруппировать или разделить элементы управления. Сайзеры wxGridSizer и wxFlexGridSizer позволяют выравнять элементы и их метки так, чтобы у них не появлялся случайный отступ. Для выравнивания групп элементов очень часто используют расширяющиеся спейсеры. Например, кнопки “OK”, “Cancel” и “Help” обычно помещают в отдельную группу, которую выравнивают по правой границе диалога. Этого можно достичь поместив спейсер и кнопки в горизонтальный wxBoxSizer и установив у спейсера расширение по горизонтали (задав положительный коэффициент расширения).

Если это возможно и допустимо – делайте ваши диалоги с изменяемым размером. Традиционно диалоги в Windows очень редко позволяют изменять свой размер пользователю, однако не существует причины почему это надо запрещать, так как маленькие элементы управления на большом экране могут быть очень неудобными. wxWidgets упрощает создание таких диалогов с помощью сайзеров, поэтому необходимо использовать их везде, что позволит диалогу учитывать текущий шрифт и размер элементов, а также упростит поддержку различных языке. Внимательно выбирайте какие из элементов управления могут расти; например, многострочный элемент редактирования является хорошим кандидатом и при увеличении размера даст пользователю дополнительное место для редактирования. Расширяющиеся спейсеры можно использовать, чтобы реализовать выравнивание в изменяющемся диалоге. Заметим, что не нужно самостоятельно изменять размер элементов управления увеличивая или уменьшая текст в нем, просто давайте больше или меньше пространства элементу управления. Обратитесь к Главе 7 за дополнительной информацией.

Если ваш диалог получается слишком большим – разбейте его на панели и используйте wxNotebook, wxListbook или wxChoicebook, чтобы можно было работать только с одной из этих панелей. Использование множества независимых диалогов раздражает пользователя и перегружает меню, поэтому использование нескольких панелей более предпочтительно. Вы должны избегать прокручивающихся панелей, пока не появится реальная причина в их использовании. Возможность прокручивания элементов управления поддерживается не на всех платформах, поэтому может оказаться, что диалог выглядит не так как планировалось. Если у вас есть множество свойств для редактирования, то возможно стоит использовать редактор свойств на основе wxGrid или сторонних классов (например, класс wxPropertyGrid, который указан в Приложении E “Сторонние инструменты для wxWidgets”).

Эстетика

Используйте очень умеренное число меток, записанные заглавными буквами. Не увлекайтесь использованием нестандартных шрифтов и цветов в ваших диалогах, иначе диалог будет выглядеть чужеродным вне текущей темы оформления и сильно отличаться от других диалогов приложения. Для лучшей переносимости между платформами не изменяйте шрифты и цвета диалогов – пусть оформлением занимается wxWidgets. Если вам необходимо настроить отображение некоторой части диалога, то это лучше сделать через использование wxStaticBitmap.

Альтернатива диалогам

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

Использование ресурсных файлов wxWidgets

Вы можете загружать определения диалогов, фреймов, меню, панелей инструментов и так далее из специальных XML-файлов с расширением xrc, вместо того, чтобы создавать все эти элементы непосредственно с помощью C++. Это позволяет гораздо элегантнее разделить код и пользовательский интерфейс, а также дает возможность поменять дизайн диалогов приложения во время выполнения программы. Файлы XRC могут быть экспортированы во множество инструментов по редактированию пользовательского интерфейса, включая такие как wxDesigner, DialogBlocks, XRCed и wxGlade.

Загрузка ресурсов

Чтобы использовать XRC-файлы в вашем приложении вам необходимо включить файл wx/xrc/xmlres.h в код вашего приложения.

Если вы преобразуете свои XRC-файлы в бинарные XRS-файлы (как это сделать будет показано далее), то вам также необходимо включить поддержку файловой системы zip, поместив соответствующий вызов AddHandler в вашу функцию OnInit:

#include "wx/filesys.h"
#include "wx/fs_zip.h"

wxFileSystem::AddHandler(new wxZipFSHandler);

Далее инициализируем поддержку XRC, добавив следующую строку в OnInit:

wxXmlResource::Get()->InitAllHandlers();

XRC-файлы загружаются с помощью следующего кода:

wxXmlResource::Get()->Load(wxT("resources.xrc"));

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

MyDialog dlg;
wxXmlResource::Get()->LoadDialog(&dlg, parent, wxT("dialog1"));
dlg.ShowModal();

Следующий код показывает как загрузить панель меню, пункты
меню, панель инструментов, изображения, иконки и панели из ресурсов:

MyFrame::MyFrame(const wxString& title): wxFrame(NULL, -1, title)
{
    SetMenuBar(wxXmlResource::Get()->LoadMenuBar(wxT("mainmenu")));
    SetToolBar(wxXmlResource::Get()->LoadToolBar(this,
                                                  wxT("toolbar")));

    wxMenu* menu = wxXmlResource::Get()->LoadMenu(wxT("popupmenu"));

    wxIcon icon = wxXmlResource::Get()->LoadIcon(wxT("appicon"));
    SetIcon(icon);

    wxBitmap bitmap = wxXmlResource::Get()->LoadBitmap(wxT("bmp1"));

    // Заканчиваем создание panelA и создаем ее экземпляр
    MyPanel* panelA = new MyPanel;
    panelA = wxXmlResource::Get()->LoadPanel(panelA, this,
                                                       wxT("panelA"));

    // Второй метод: срузу из XRC создаем и загружаем panelB
    wxPanel* panelB = wxXmlResource::Get()->LoadPanel(this,
                                                       wxT("panelB"));
}

wxWidgets содержит один глобальный объект wxXmlResource, который вы можете использовать, но также можете самостоятельно создать объект wxXmlResource, загрузить ресурсы, а после уничтожить его. Вы также можете вызвать wxXmlResource::Set, чтобы установить новый глобальный объект, уничтожив старый.

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

BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(XRCID("menu_quit"),  MyFrame::OnQuit)
    EVT_MENU(XRCID("menu_about"), MyFrame::OnAbout)
END_EVENT_TABLE()

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

Очень часто удобнее скомбинировать несколько ресурсных файлов в один бинарный файл (с расширением xrs). Чтобы скомпилировать XRC-файлы в один zip-файл из которого можно загружать ресурсы используйте утилиту wxrc, расположенную в каталоге utils/wxrc вашего дистрибутива wxWidgets:

wxrc resource1.xrc resource2.xrc -o resource.xrs

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

Совет: вместо создания отдельного zip-файла с вашими ресурсными файлами, вы можете включить их в один zip-файл, который включает другие файлы, необходимые вашему приложению, такие как HTML-файлы, изображения и так далее. wxXmlResource::Load принимает спецификатор виртуальной файловой системы, как будет описано в Главе 14 “Файлы и потоки”, поэтому вы можете написать:

wxXmlResource::Get()->Load(wxT("resources.bin#zip:dialogs.xrc"));

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

wxrc resource1.xrc resource2.xrc c -o resource.cpp

Далее скомпилируйте этот файл как обычный C++ файл и прилинкуйте к вашему приложению. Файл включает функцию InitXmlResource, которую вам необходимо вызвать. Например,

extern void InitXmlResource(); // определена в сгенерированом файле
wxXmlResource::Get()->InitAllHandlers();
InitXmlResource();

Таблица содержит аргументы и опции командной строки для программы wxrc.

• -h (–help) – Показывает помощь.
• -v (–verbose) – Включает подробную информацию о работе.
• -c (–cpp-code) – Генерирует исходники C++, вместо XRS-файла.
• -p (–python-code) – Генерирует исходники Python, вместо XRS-файла.
• -e (–extra-cpp-code) – Если используется совместно с командой -c, генерирует заголовочный файл C++, содержащий определение для окон, содержащихся в XRC-файле.
• -u (–uncompressed) – Не сжимать XML файлы (только для C++).
• -g (–gettext) – Выводит все строки с подчеркиваниями, чтобы poEdit или gettext смогли их просканировать. Вывод производится в stdout или файл, если задан ключ -o.
• -n (–function <имя>) – Определяет функцию инициализации для C++ (используется совместно с -c)
• -o <имя_файла> (–output <имя_файла>) – Определяет файл вывода, такой как resource.xrs или resource.cpp.
• -l <имя_файла> (–list-of-handlers <имя_файла>) – Выводит список обработчиков ресурсов, необходимых для заданных файлов.

Перевод ресурсов

Если объект wxXmlResource создан с флагом wxXRC_USE_LOCALE (это поведение по умолчанию), то все отображаемые строки являются объектами перевода, как это описано в Главе 16 “Написание многоязыковых приложений”. Однако poEdit не может просканировать XRC-файлы, чтобы выбрать строки для перевода, как это можно сделать с программой на C++ , поэтому вам необходимо создать файл, содержащий такие строки, используя опцию -g. Например:

wxrc -g resources.xrc -o resource_strings.cpp

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

Формат XRC-файлов

Так как формат книги не позволяет подробно рассмотреть формат XRC-файлов, то дальше просто приводится пример маленького диалога с сайзерами:

<?xml version="1.0"?>
<resource version="2.3.0.1">
<object class="wxDialog" name="simpledlg">
    <title>A simple dialog</title>
    <object class="wxBoxSizer">
      <orient>wxVERTICAL</orient>
      <object class="sizeritem">
        <object class="wxTextCtrl">
          <size>200,200d</size>
          <style>wxTE_MULTILINE|wxSUNKEN_BORDER</style>
          <value>Hello, this is an ordinary multilinen textctrl....</value>
        </object>
        <option>1</option>
        <flag>wxEXPAND|wxALL</flag>
        <border>10</border>
      </object>
      <object class="sizeritem">
        <object class="wxBoxSizer">
          <object class="sizeritem">
            <object class="wxButton" name="wxID_OK">
              <label>Ok</label>
              <default>1</default>
            </object>
          </object>
          <object class="sizeritem">
            <object class="wxButton" name="wxID_CANCEL">
              <label>Cancel</label>
            </object>
            <border>10</border>
            <flag>wxLEFT</flag>
          </object>
        </object>
        <flag>wxLEFT|wxRIGHT|wxBOTTOM|wxALIGN_RIGHT</flag>
        <border>10</border>
      </object>
    </object>
  </object>
</resource>

Детальную спецификация формата XRC можно найти в технических замечаниях в файле docs/tech/tn0014.txt вашего дистрибутива wxWidgets. Если вы используете какой-нибудь редактор для пользовательского интерфейса, то вам не нужно знать о формате XRC.

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

<object class="wxBitmapButton" name="wxID_OK">
  <bitmap>resources.bin#zip:okimage.png</bitmap>
</object>

Обратитесь к Главе 10 “Работа с изображениями” и Главе 14 “Файлы и потоки” за детальной информацией об использовании виртуальных файловых систем для загрузки ресурсов, таких как изображения.

Определение обработчика ресурсов

Система XRC использует обработчики ресурсов, чтобы опознать определения XML для каждого типа ресурсов. Если вы напишите ваш собственный элемент управления, то вы возможно захотите написать такой обработчик, чтобы иметь возможность загружать ваш элемент управления из XRC.

Для иллюстрации посмотрим как реализован обработчик ресурсов для стандартного класса wxButton:

#include "wx/xrc/xmlres.h"

class wxButtonXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxButtonXmlHandler)
public:
    wxButtonXmlHandler();
    virtual wxObject *DoCreateResource();
    virtual bool CanHandle(wxXmlNode *node);
};

Реализация обработчика достаточно простая. В конструкторе обработчика вы, используя макрос XRC_ADD_STYLE, добавляете стили, которые должна поддерживать кнопка, а в конце вызываете AddWindowStyles, чтобы добавить стандартные стили для окон. В методе DoCreateResource объект-кнопка создается в два шага, используя XRC_MAKE_INSTANCE и Create, извлекая параметры, такие как метка, положение и размер. И, наконец, CanHandle проверяет может ли обработчик обработать узел, который ему передали. Последняя возможность позволяет в одном обработчике реализовать обработку нескольких типов ресурсов.

IMPLEMENT_DYNAMIC_CLASS(wxButtonXmlHandler, wxXmlResourceHandler)

wxButtonXmlHandler::wxButtonXmlHandler()
: wxXmlResourceHandler()
{
    XRC_ADD_STYLE(wxBU_LEFT);
    XRC_ADD_STYLE(wxBU_RIGHT);
    XRC_ADD_STYLE(wxBU_TOP);
    XRC_ADD_STYLE(wxBU_BOTTOM);
    XRC_ADD_STYLE(wxBU_EXACTFIT);
    AddWindowStyles();
}

wxObject *wxButtonXmlHandler::DoCreateResource()
{
   XRC_MAKE_INSTANCE(button, wxButton)

   button->Create(m_parentAsWindow,
                    GetID(),
                    GetText(wxT("label")),
                    GetPosition(), GetSize(),
                    GetStyle(),
                    wxDefaultValidator,
                    GetName());

    if (GetBool(wxT("default"), 0))
        button->SetDefault();
    SetupWindow(button);

    return button;
}

bool wxButtonXmlHandler::CanHandle(wxXmlNode *node)
{
    return IsOfClass(node, wxT("wxButton"));
}

Чтобы использовать обработчик приложение должно включить заголовочный файл и зарегистрировать обработчик, как показано ниже:

#include "wx/xrc/xh_bttn.h"
wxXmlResource::AddHandler(new wxBitmapXmlHandler);

Сторонние элементы управления

XRC-файл может определить сторонние, или “неизвестные” элементы управления, указав class="unknown" в определении объекта. Вы можете использовать такую возможность для элементов управления, которые создаются с помощью кода C++, после того как их родительское окно будет загружено из XRC. После того, как XRC загрузит сторонний объект создается окно, которое помещается на место данного объекта. Далее приложение вызывает AttachUnknownControl для помещения реального окна в окно, созданное на прошлом шаге с правильными размерами и расположением. Например,

wxDialog dlg;

// Загружаем диалог
wxXmlResource::Get()->LoadDialog(&dlg, this, wxT("mydialog"));

// Создаем экземпляр нашего элемента управления
MyCtrl* myCtrl = new MyCtrl(&dlg, wxID_ANY);

// Добавляем его к диалогу
wxXmlResource::Get()->AttachUnknownControl(wxT("custctrl"), myCtrl);

// Показываем диалог
dlg.ShowModal();

Определение стороннего элемента управления может выглядеть следующим образом:

<object class="unknown" name="custctrl">
  <size>100,100</size>
</object>

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

Итоги

В этой главе мы изучили основные принципы проектирования и реализации диалогов, включая краткое описание сайзеров, валидаторов и преимущества использования событий об обновлении интерфейса. Примеры создания диалогов смотрите в каталоге samples/dialogs вашего дистрибутива wxWidgets. Также в каталоге samples/validate есть пример использования валидаторов. В следующей главе будет рассказано о работе с изображениями.

Добавление помощи

Существует по крайней мере три пути как можно реализовать помощь для вашего диалога:

• Всплывающие подсказки
• Контекстная помощь
• Справочная система

Кроме того у нас уже есть некоторый текст на самой панели диалога. Возможно вы захотите также использовать другие технологии, явно не поддерживаемые в wxWidgets. Например, для более сложных диалогов вы можете создать wxHtmlWindow вместо wxStaticText и загрузить в него HTML-файл, содержащий необходимое описание. В качестве альтернативы вы можете поместить маленькую кнопку помощи справа от каждого элемента управления, при нажатии на которую выводился бы некоторый текст с описанием.

Три основных типа помощи, поддерживаемые в wxWidgets, описаны далее.

Всплывающие подсказки

Всплывающие подсказки – это маленькие окна, содержащие короткое описание данного элемента управления, которые всплывают, когда указатель находится над элементом управления некоторое время. С помощью SetToolTip можно установить подсказку для элемента управления. Так как эти окна могут раздражать продвинутых пользователей, то в приложении должна быть возможность отключить их (для этого не нужно вызывать SetToolTip при создании или показе диалога).

Контекстная помощь

Контекстная помощь выглядит как небольшое выскакивающее описание, похожее на всплывающие подсказки. Пользователю необходимо сначала нажать на специальную кнопку, а после на элемент управления о котором он хочет узнать или нажать F1, чтобы узнать информацию об элементе на котором в данный момент находится фокус (последнее работает только в системе Windows). В Windows вы можете также определить специальный стиль окна wxDIALOG_EX_CONTEXTHELP, чтобы создать маленькую иконку со знаком вопроса в заголовке окна. На других платформах вы можете создать wxContextHelpButton в диалоге (обычно ее располагают рядом с кнопками “OK” и “Cancel”). В вашем приложении вы должны написать:

#include "wx/cshelp.h"
...
    wxHelpProvider::Set(new wxSimpleHelpProvider);
...

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

// Устанавливаем текст помощи для элементов диалога
void PersonalRecordDialog::SetDialogHelp()
{
    wxString nameHelp = wxT("Enter your full name.");
    wxString ageHelp = wxT("Specify your age.");
    wxString sexHelp = wxT("Specify your gender, male or female.");
    wxString voteHelp = wxT("Check this if you wish to vote.");

    FindWindow(ID_NAME)->SetHelpText(nameHelp);
    FindWindow(ID_NAME)->SetToolTip(nameHelp);

    FindWindow(ID_AGE)->SetHelpText(ageHelp);
    FindWindow(ID_AGE)->SetToolTip(ageHelp);

    FindWindow(ID_SEX)->SetHelpText(sexHelp);
    FindWindow(ID_SEX)->SetToolTip(sexHelp);

    FindWindow(ID_VOTE)->SetHelpText(voteHelp);
    FindWindow(ID_VOTE)->SetToolTip(voteHelp);
}

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

wxContextHelp contextHelp(window);

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

Однако вы не обязаны ограничивать себя только возможностями, заложенными в wxWidgets для хранения и показа текста помощи. Вы можете создать свой собственный класс-наследник от wxHelpProvider и реализовать методы GetHelp, SetHelp, AddHelp, RemoveHelp и ShowHelp.

Справочная система

Большая часть приложений поставляется с файлом помощи, в котором находятся детальные инструкции по использованию программы. В wxWidgets для этого есть элементы управления нескольких типов, которые являются наследниками от wxHelpControllerBase. Обратитесь к Главе 20 “Усовершенствование ваших приложений”, за более детальной информацией о том, как реализовать такого вида помощь.

В нашем примере мы просто используем wxMessageBox, чтобы вывести некоторое сообщение, когда пользователь нажмет на кнопку “Help” (Помощь).

BEGIN_EVENT_TABLE( PersonalRecordDialog, wxDialog )
    ...
    EVT_BUTTON( wxID_HELP, PersonalRecordDialog::OnHelpClick )
    ...
END_EVENT_TABLE()

void PersonalRecordDialog::OnHelpClick( wxCommandEvent& event )
{
    // В нормальном приложении мы должны вывести соответствующий раздел помощи
    /*
    wxGetApp().GetHelpController().DisplaySection(wxT("Personal record dialog"));
    */

    // В нашем примере мы просто выводим окно с сообщением
    wxString helpText =
      wxT("Please enter your full name, age and gender.\n")
      wxT("Also indicate your willingness to vote in general elections.\n\n")
      wxT("No non-alphabetical characters are allowed in the name field.\n")
      wxT("Try to be honest about your age.");

    wxMessageBox(helpText,
        wxT("Personal Record Dialog Help"),
        wxOK|wxICON_INFORMATION, this);
}

Полная реализация класса

Полная реализация класса приводится в приложении J “Исходники”, а также в каталоге examples/chap09 на нашем CD-ROM.

Вызов диалога

Теперь, когда диалог поностью закончен, мы можем его вызвать:

PersonalRecordDialog dialog(NULL, ID_PERSONAL_RECORD,
    wxT("Personal Record"));
dialog.SetName(wxEmptyString);
dialog.SetAge(30);
dialog.SetSex(0);
dialog.SetVote(true);
if (dialog.ShowModal() == wxID_OK)
{
    wxString name = dialog.GetName();
    int age = dialog.GetAge();
    bool sex = dialog.GetSex();
    bool vote = dialog.GetVote();
}

Адаптация диалогов для портативных устройств

wxWidgets можно использовать для мобильных и других встраиваемых устройств, используя для этого порты GTK+, X11 и Windows CE (или иные в будущем). Самым важной особенностью таких устройств является ограниченный размер экрана, который для некоторых смартфонов может быть не больше 176×220 пикселей.

Многие диалоги нуждаются в альтернативном (адаптированном для маленьких экранов) размещении элементов, а некоторые элементы управления могут быть объеденены или удалены, особенно в связи с тем, что мобильные версии более ограниченны по сравнению с их десктопными версиями. С помощью метода wxSystemSettings::GetScreenType можно получить полный размер экрана. Например:

#include "wx/settings.h"
bool isPda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);

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

• wxSYS_SCREEN_NONE – Неизвестный тип экрана
• wxSYS_SCREEN_TINY – Миниатюрный экран, менее 320×240
• wxSYS_SCREEN_PDA – Экран наладонника, 320×240 или больше, но менее 640×480
• wxSYS_SCREEN_SMALL – Маленький экран, 640×480 или больше, но менее 800×600
• wxSYS_SCREEN_DESKTOP – Обычный экран, 800×600 или больше

Если вам необходимо получить точный размер экрана, то существует три способа получить его:

• Использовать функцию wxSystemSettings::GetMetric[i], передав ей [i]wxSYS_SCREEN_X или wxSYS_SCREEN_Y.
• Вызвать wxGetDisplaySize, которая возвратит объект типа wxSize.
• Создать объект wxDisplay и вызвать метод GetGeometry, который возвратит wxRect, содержащий координаты прямоугольника для дисплея.

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

• Заменить весь макет диалога с помощью его загрузки из другого XRC-файла или выполнения другой процедуры создания. Если у элементов не изменится тип, то вам даже не понадобится менять обработчик событий.
• Уменьшить число элементов управления и расстоянием между ними.
• Изменить тип некоторых элементов управления, чтобы они занимали на экране меньше места (например, с wxListBox в wxComboBox). Это потребует некоторой модификации кода обработчиков событий.
• Изменить ориентацию одного или нескольких сайзеров. Некоторые портативные устройства имеют гораздо больше пространства в одном направлении, чем в другом.

Кроме того вам необходимо использовать расширения API для некоторых платформ. Смартфоны Microsoft имею две специальные кнопки, которым можно присвоить некоторые метки, такие как “OK” и “Cancel”. На таких платформах вместо создания двух объектов типа wxButton вы должны вызвать wxDialog::SetLeftMenu и wxDialog::SetRightMenu с соответствующим идентификатором, меткой и, возможно, меню. Так как эти функции имеются только в портах для смартфонов, то необходимо добавить операторы включения в ваш код. Например:

#ifdef __SMARTPHONE__
    SetLeftMenu(wxID_OK, wxT("OK"));
    SetRightMenu(wxID_OK, wxT("Cancel"));
#else
    wxBoxSizer* buttonSizer = new wxBoxSizer(wxHORIZONTAL);
    GetTopSizer()->Add(buttonSizer, 0, wxALL|wxGROW, 0);
    buttonSizer->Add(new wxButton(this, wxID_OK), 0, wxALL, 5);
    buttonSizer->Add(new wxButton(this, wxID_CANCEL), 0, wxALL, 5);
#endif

Читать третью часть главы “Написание собственных диалогов”

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

Шаги для создания собственных диалогов

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

1. Создать наследника от wxDialog.
2. Решить, где будут храниться данные диалога и как приложение получит к ним доступ.
3. Написать код создания и размещения элементов управления.
4. Добавить код, отвечающий за пересылку данных между данными диалога и элементами управления.
5. Написать обработчики событий от элементов управления.
6. Добавить обработку обновления пользовательского интерфейса, чтобы элементы управления всегда были в правильном состоянии.
7. Добавить помощь, в частности всплывающие подсказки, контекстную помощь (данная возможность не реализована в Mac OS X) и справочную систему.
8. Вызвать диалог из подходящего места вашего приложения.

Проиллюстрируем указанные шаги на конкретном примере.

Пример: PersonalRecordDialog

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

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

Мы проиллюстрируем шаги, необходимые для создания диалога с помощью диалога в котором пользователь вводит свое имя, возраст, пол и хочет ли он проголосовать. Диалог называется PersonalRecordDialog и показан на рисунке.

<рисунок пропущен>

Кнопка “Reset” (Сброс) устанавливает значение всех элементов управления в их начальные значения. Кнопка “OK” закрывает диалог и возвращает wxID_OK из ShowModal. Кнопка “Cancel” возвращает wxID_CANCEL и не обновляет содержимое переменных диалога. Кнопка “Help” (Помощь) выводит несколько строк с описанием диалога, (хотя в реальном приложении эта кнопка должна вызывать полноценную страницу помощи в справочной системе).

Хороший пользовательский интерфейс не должен позволять пользователю вводить данные, которые не имеют значения в текущей ситуации. Например, пользователь не должен иметь возможность использовать элемент управления “Vote” (Голосовать), если его возраст меньше чем допустимый для голосования возраст (18 лет для США или Великобритании). Поэтому необходимо убедиться, что при возрасте менее 18 лет чек-бокс Vote заблокирован для ввода.

Создаем новый класс-наследник

Далее приведено объявление нашего PersonalRecordDialog. Информация времени выполнения о типе вводится с помощью макроса DECLARE_CLASS, а добавление таблицы событий – с помощью DECLARE_EVENT_TABLE.

/*!
* Объявление класса PersonalRecordDialog
*/

class PersonalRecordDialog: public wxDialog
{
    DECLARE_CLASS( PersonalRecordDialog )
    DECLARE_EVENT_TABLE()

public:
    // Конструкторы
    PersonalRecordDialog( );
    PersonalRecordDialog( wxWindow* parent,
      wxWindowID id = wxID_ANY,
      const wxString& caption = wxT("Personal Record"),
      const wxPoint& pos = wxDefaultPosition,
      const wxSize& size = wxDefaultSize,
      long style = wxCAPTION|wxRESIZE_BORDER|wxSYSTEM_MENU );

    // Инициализация наших переменных
    void Init();

    // Создание
    bool Create( wxWindow* parent,
      wxWindowID id = wxID_ANY,
      const wxString& caption = wxT("Personal Record"),
      const wxPoint& pos = wxDefaultPosition,
      const wxSize& size = wxDefaultSize,
      long style = wxCAPTION|wxRESIZE_BORDER|wxSYSTEM_MENU );

    // Создание элементов управления и сайзеров
    void CreateControls();
};

Заметим, что следуя принятому в wxWidgets соглашению позволять одно- и двушаговое конструирование мы предоставляем конструктор по умолчанию и функцию Create, а также расширенный конструктор.

Проектируем хранение данных

У нас есть четыре части данных, которые нужно хранить: имя (строка), возраст (целое), пол (логическое) и предпочтения по голосованию (логическое). Чтобы упростить использование элемента управления wxChoice мы будем использовать целочисленный тип для хранения логического типа для пола, но интерфейс класса будет представлять его как логическое значение: true для женского пола и false для мужского. Давайте добавим эти данные и методы для работы с ними в класс PersonalRecordDialog:

// Данные
wxString    m_name;
int         m_age;
int         m_sex;
bool        m_vote;

// Доступ к имени
void SetName(const wxString& name) { m_name = name; }
wxString GetName() const { return m_name; }

// Доступ к возрасту
void SetAge(int age) { m_age = age; }
int GetAge() const { return m_age; }

// Доступ к полу (мужской = false, женский = true)
void SetSex(bool sex) { sex ? m_sex = 1 : m_sex = 0; }
bool GetSex() const { return m_sex == 1; }

// Будет ли пользователь голосовать?
void SetVote(bool vote) { m_vote = vote; }
bool GetVote() const { return m_vote; }

Создание элементов управления и их размещение

Теперь добавим функцию CreateControls, которая будет вызываться из Create. CreateControls добавляет несколько элементов управления типа wxStaticText, wxButton, wxSpinCtrl, wxTextCtrl, wxChoice и wxCheckBox. Обратитесь к рисунку 9-1, чтобы посмотреть результирующий диалог.

Мы используем основанный на сайзерах макет для этого диалога, из-за чего код выглядит достаточно сложно для такого небольшого числа элементов управления (мы уже коротко описывали сайзеры в Главе 7 “Размещение элементов с помощью сайзеров”, где рассказывали, что они позволяются создавать диалоги, которые нормально выглядят на множестве платформ и которые легко адаптировать для перевода и изменения размера). Вы можете использовать и другие методы, такие как загрузка диалога из ресурсов wxWidgets (XRC-файлов).

Основной принцип основанного на сайзерах размещения – поместить управляющие элементы во вложенные боксы (сайзеры), которые распределят место между элементами управления или растянуться, чтобы стать достаточными для их размещения. Сайзеры не являются окнами, они формируют отдельную иерархию и поэтому элементы управления остаются детьми своих родителей, независимо от сложности иерархии сайзеров. Вы можете освежить свою память и посмотреть на схематический вид размещения сайзеров, который показан на рисунке 7-2 в Главе 7.

В CreateControls мы используем вертикальный сайзер (boxSizer), вложенный в другой вертикальный сайзер (topSizer), чтобы получить достаточный отступ между элементам управления и границами диалога. Один горизонтальный сайзер используется для размещения wxSpinCtrl, wxChoice и wxCheckBox, а другой (okCancelSizer) – для кнопок Reset, OK, Cancel и Help.

/*!
* Control creation for PersonalRecordDialog
*/
void PersonalRecordDialog::CreateControls()
{
    // Сайзер верхнего уровня

    wxBoxSizer* topSizer = new wxBoxSizer(wxVERTICAL);
    this->SetSizer(topSizer);

    // Второй сайзер, чтобы получить больше пространства вокруг элементов

    wxBoxSizer* boxSizer = new wxBoxSizer(wxVERTICAL);
    topSizer->Add(boxSizer, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    // Некоторый текст

    wxStaticText* descr = new wxStaticText( this, wxID_STATIC,
        wxT("Please enter your name, age and sex, and specify whether\
        you wish to\nvote in a general election."),
        wxDefaultPosition, wxDefaultSize, 0 );
    boxSizer->Add(descr, 0, wxALIGN_LEFT|wxALL, 5);

    // Отступ

    boxSizer->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    // Метка для текстового элемента

    wxStaticText* nameLabel = new wxStaticText ( this, wxID_STATIC,
        wxT("&Name:"), wxDefaultPosition, wxDefaultSize, 0 );
    boxSizer->Add(nameLabel, 0, wxALIGN_LEFT|wxALL, 5);

    // Тестовый элемент для получения имени пользователя

    wxTextCtrl* nameCtrl = new wxTextCtrl ( this, ID_NAME, wxT("Emma"),
        wxDefaultPosition, wxDefaultSize, 0 );
    boxSizer->Add(nameCtrl, 0, wxGROW|wxALL, 5);

    // Горизонтальный сайзер, содержащий возраст, пол и флаг голосования

    wxBoxSizer* ageSexVoteBox = new wxBoxSizer(wxHORIZONTAL);
    boxSizer->Add(ageSexVoteBox, 0, wxGROW|wxALL, 5);

    // Метка для возраста

    wxStaticText* ageLabel = new wxStaticText ( this, wxID_STATIC,
        wxT("&Age:"), wxDefaultPosition, wxDefaultSize, 0 );
    ageSexVoteBox->Add(ageLabel, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Спиновый элемент для получения возраста

    wxSpinCtrl* ageSpin = new wxSpinCtrl ( this, ID_AGE,
        wxEmptyString, wxDefaultPosition, wxSize(60, -1),
        wxSP_ARROW_KEYS, 0, 120, 25 );
    ageSexVoteBox->Add(ageSpin, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Метка для пола

    wxStaticText* sexLabel = new wxStaticText ( this, wxID_STATIC,
        wxT("&Sex:"), wxDefaultPosition, wxDefaultSize, 0 );
    ageSexVoteBox->Add(sexLabel, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Создаем выпадающий список для выбора пола
    wxString sexStrings[] = {
        wxT("Male"),
        wxT("Female")
    };

    wxChoice* sexChoice = new wxChoice ( this, ID_SEX,
        wxDefaultPosition, wxSize(80, -1), WXSIZEOF(sexStrings),
            sexStrings, 0 );
    sexChoice->SetStringSelection(wxT("Female"));
    ageSexVoteBox->Add(sexChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Добавляем растяжимый отступ, который перемещает элемент для
    // голосования направо

    ageSexVoteBox->Add(5, 5, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxCheckBox* voteCheckBox = new wxCheckBox( this, ID_VOTE,
       wxT("&Vote"), wxDefaultPosition, wxDefaultSize, 0 );
    voteCheckBox ->SetValue(true);
    ageSexVoteBox->Add(voteCheckBox, 0,
        wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Создаем разделяющую черту перед кнопками OK и Cancel

    wxStaticLine* line = new wxStaticLine ( this, wxID_STATIC,
        wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
    boxSizer->Add(line, 0, wxGROW|wxALL, 5);

    // Горизонтальный сайзер содержит кнопки Reset, OK, Cancel и Help

    wxBoxSizer* okCancelBox = new wxBoxSizer(wxHORIZONTAL);
    boxSizer->Add(okCancelBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    // Кнопка Reset

    wxButton* reset = new wxButton( this, ID_RESET, wxT("&Reset"),
        wxDefaultPosition, wxDefaultSize, 0 );
    okCancelBox->Add(reset, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Кнопка OK

    wxButton* ok = new wxButton ( this, wxID_OK, wxT("&OK"),
        wxDefaultPosition, wxDefaultSize, 0 );
    okCancelBox->Add(ok, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Кнопка Cancel

    wxButton* cancel = new wxButton ( this, wxID_CANCEL,
        wxT("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    okCancelBox->Add(cancel, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    // Кнопка Help

    wxButton* help = new wxButton( this, wxID_HELP, wxT("&Help"),
        wxDefaultPosition, wxDefaultSize, 0 );
    okCancelBox->Add(help, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
}

Пересылка данных и их проверка

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

Когда диалог показывается в первый раз wxWidgets вызывает InitDialog, который в свою очередь генерирует событие wxEVT_INIT_DIALOG. Обработчик по умолчанию для данного события вызывает TransferDataToWindow для диалога. Чтобы переслать информацию из элементов управления обратно в переменные вы должны вызвать TransferDataFromWindow, когда пользователь подтвердит свой выбор. Тоже самое делает wxWidgets в обработчике по умолчанию для управляющего события wxID_OK, который вызывает TransferDataFromWindow перед вызовом метода EndModal (который непосредственно закрывает диалог).

Поэтому вы можете переопределить TransferDataToWindow и TransferDataFromWindow для пересылки ваших данных. Для нашего диалога код может выглядеть следующим образом:

/*!
* Посылаем данные в окно
*/

bool PersonalRecordDialog::TransferDataToWindow()
{
    wxTextCtrl* nameCtrl = (wxTextCtrl*) FindWindow(ID_NAME);
    wxSpinCtrl* ageCtrl = (wxSpinCtrl*) FindWindow(ID_SAGE);
    wxChoice* sexCtrl = (wxChoice*) FindWindow(ID_SEX);
    wxCheckBox* voteCtrl = (wxCheckBox*) FindWindow(ID_VOTE);

    nameCtrl->SetValue(m_name);
    ageCtrl->SetValue(m_age);
    sexCtrl->SetSelection(m_sex);
    voteCtrl->SetValue(m_vote);

    return true;
}

/*!
* Получаем данные из окна
*/

bool PersonalRecordDialog::TransferDataFromWindow()
{
    wxTextCtrl* nameCtrl = (wxTextCtrl*) FindWindow(ID_NAME);
    wxSpinCtrl* ageCtrl = (wxSpinCtrl*) FindWindow(ID_SAGE);
    wxChoice* sexCtrl = (wxChoice*) FindWindow(ID_SEX);
    wxCheckBox* voteCtrl = (wxCheckBox*) FindWindow(ID_VOTE);

    m_name = nameCtrl->GetValue();
    m_age = ageCtrl->GetValue();
    m_sex = sexCtrl->GetSelection();
    m_vote = voteCtrl->GetValue();

    return true;
}

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

FindWindow(ID_NAME)->SetValidator(
      wxTextValidator(wxFILTER_ALPHA, &m_name));
FindWindow(ID_AGE)->SetValidator(
      wxGenericValidator(& m_age));
FindWindow(ID_SEX)->SetValidator(
      wxGenericValidator(& m_sex);
FindWindow(ID_VOTE)->SetValidator(
      wxGenericValidator(& m_vote);

Эти несколько строк в конце CreateControls заменяют две переопределенные функции. В качестве бонуса пользователю будет запрещено использовать цифры в строке с именем.

Валидаторы могут выполнять две работы. Кроме передачи данных они также могут проверять данные и показывать сообщение об ошибке, если данные не удовлетворяют заданным критериям. В нашем примере кроме небольшой проверки имени не делается других проверок. wxGenericValidator относительно простой класс предназначенный только для передачи данных. Однако он может работать с множеством стандартных базовых элементов управления. Другие валидаторы (например wxTextValidator) имеют более сложное поведение и могут даже перехватывать нажатия на клавиши, чтобы запретить ввод недопустимых символов. Для нашего примера мы используем стандартный стиль wxFILTER_ALPHA, но можно также явно определить какие символы должны или не должны считаться допустимыми с помощью методов SetIncludes и SetExcludes.

Изучим подробнее каким образом wxWidgets обрабатывает валидаторы. Как было упомянуто ранее стандартный обработчик OnOK вызывает TransferDataToWindow, но до этого он вызывает Validate, запрещая вызов TransferDataToWindow и EndModal, если вызов закончится неудачно. Вот стандартная реализация OnOK:

void wxDialog::OnOK(wxCommandEvent& event)
{
    if ( Validate() && TransferDataFromWindow() )
    {
        if ( IsModal() )
            EndModal(wxID_OK); // Если диалог модальный
        else
        {
            SetReturnCode(wxID_OK);
            this->Show(false); // Если диалог не модальный
        }
    }
}

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

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

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

Так как двух представленных выше классов-валидаторов может быть не достаточно для ваших нужд (особенно если вы пишете свои собственные элементы управления), то у вас есть возможность унаследовать свой класс от wxValidator. Этот класс должен иметь конструктор копирования и функцию Clone, которая возвращает копию объекта-валидатора, а также реализацию для передачи данных и проверки. Валидатор обычно также хранит указатель на переменную языка C++. В файлах include/wx/valtext.h и src/common/valtext.cpp дистрибутива wxWidgets можно посмотреть как реализовать валидатор. Также обратитесь к разделу “Написание собственных элементов управления” в Главе 12 “Продвинутые классы окон”.

Обработка событий

Для нашего примера нам не потребуется писать обработчики для кнопок OK и Cancel, так как мы можем использовать стандартные обработчики. Для этого достаточно использовать стандартные идентификаторы wxID_OK и wxID_CANCEL для этих кнопок.

Однако, для нетривиальных диалогов вам возможно потребуется перехватывать и обрабатывать события от элементов управления. В нашем примере у нас есть кнопка Reset, которую можно нажать в любой момент, чтобы сбросить значения в диалоге в их начальные значения. Мы добавим обработчик OnResetClick и соответствующую запись в таблицу обработчиков событий. Реализация OnResetClick будет очень простой: вначале мы сбрасываем значение переменных, вызвав функцию Init (которую введена, чтобы сделать единую точку инициализации переменных), а далее вызываем TransferDataToWindow, чтобы отобразить эти данные.

BEGIN_EVENT_TABLE( PersonalRecordDialog, wxDialog )
    ...
    EVT_BUTTON( ID_RESET, PersonalRecordDialog::OnResetClick)
    ...
END_EVENT_TABLE()

void PersonalRecordDialog::OnResetClick( wxCommandEvent& event )
{
    Init();
    TransferDataToWindow();
}

Обработка обновлений интерфейса

Одна из задач с которой обычно сталкивается программист – это быть уверенным, что пользователь не может выбрать элемент управления или пункт меню, который в данный момент не применим. Ленивые программисты обычно делают выскакивающую надпись “Эта опция в данный момент недоступна”. Но если опция недоступна, то она должна выглядеть недоступной, и при нажатии на соответствующий элемент ничего не должно происходить. Для этого программе необходимо обновлять элементы интерфейса, чтобы они отражали правильное состояние в каждый момент времени.

В нашем примере мы должны отключить чек-бокс “Vote” когда возраст пользователя меньше 18 лет, так как в этом случае пользователь не может принимать решение об этом. Вашей первой мыслью, наверное, будет добавить обработчик событий от спина Age, который будет включать и выключать элемент Vote в соответствии со своим значением в спине. Хотя данное решение может хорошо работать для простых пользовательских интерфейсов, но представьте что будет, если состояние элемента зависит от множества факторов. Существуют более плохие ситуации, когда вы не можете перехватывать изменения некоторого параметра. Например, вам необходимо включать пункт меню “Вставить” в зависимости от доступности данных в буфере обмена. Перехват этого события очень сложен, так как данные могут поступать и из другого окна.

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

Далее приведен обработчик события об обновлении интерфейса для элемента “Vote”. Заметим, что мы не можем использовать переменную m_age, так как перенос данных из элементов управления в переменные происходит только после того, как пользователь нажмет кнопку “OK”.

BEGIN_EVENT_TABLE( PersonalRecordDialog, wxDialog )
    ...
    EVT_UPDATE_UI( ID_VOTE, PersonalRecordDialog::OnVoteUpdate )
    ...
END_EVENT_TABLE()

void PersonalRecordDialog::OnVoteUpdate( wxUpdateUIEvent& event )
{
    wxSpinCtrl* ageCtrl = (wxSpinCtrl*) FindWindow(ID_AGE);
    if (ageCtrl->GetValue() < 18)
    {
        event.Enable(false);
        event.Check(false);
    }
    else
        event.Enable(true);
}

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

Читать вторую часть главы “Написание собственных диалогов”.

Перевод сделан Грубниковым А.Г.

Все GUI-приложения должны каким-либо образом реагировать на данные, поступающие от устройства ввода. Эта глава покажет как можно взаимодействовать с мышью, клавиатурой и джойстиком.

6.1 Получение данных от мыши

Упрощенно говоря, приложение получает от мыши два вида событий: основные события мыши, посылаемые с помощью класса wxMouseEvent, и “сырые” события, передаваемые вашей функции-обработчику неинтерпретированными. При этом действия, связанные с элементами управления (такими как, например, кнопка), часто являются результатом интерпретации событий от мыши (или других устройств) как отдельных команд.
Например, когда вы добавляете макрос EVT_BUTTON в таблицу событий, то вы перехватываете событие wxCommandEvent, которое было сгенерировано классом wxButton.

Это, в свою очередь, происходит следующим образом: кнопка перехватывает событие от мыши EVT_LEFT_DOWN и порождает управляющее событие. Конечно, на большинстве платформ, класс wxButton реализован как “родной” и не использует низкоуровневую обработку событий wxWidgets, но так будет происходить для несуществующих на платформе классов.

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

Вы можете перехватить события отпускания (key up), нажатия (key down) и двойного клика левой, средней или правой кнопками мыши. Можно также перехватить движения мыши, как с нажатой кнопкой, так и без. Вы можете перехватить события, говорящие о входе курсора в область окна и о выходе из этой области. Наконец, возможно перехватить события от колесика прокрутки, если на мыши таковое присутствует.

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

Таблица 6.1 содержит макросы таблицы событий, которые вы можете использовать. Класс wxMouseEvent не передается по цепочке родителям окна, поэтому для обработки таких событий вы должны унаследовать свой класс от класса окна или от wxEvtHandler, а потом модифицировать обработчик событий для необходимых подокон с помощью функций SetEventHandler или PushEventHandler. Или же, вы можете выполнить динамическую привязку с помощью функции Connect.

• EVT_LEFT_DOWN(func) – Обрабатывает событие wxEVT_LEFT_DOWN, генерируемое при смене состояния левой кнопки на “нажата”.
• EVT_LEFT_UP(func) – Обрабатывает событие wxEVT_LEFT_UP, генерируемое при смене состояния левой кнопки на “отпущена”.
• EVT_LEFT_DCLICK(func) – Обрабатывает событие wxEVT_LEFT_DCLICK, генерируемое при двойном клике левой кнопкой.
• EVT_MIDDLE_DOWN(func) – Обрабатывает событие wxEVT_MIDDLE_DOWN, генерируемое при смене состояния средней кнопки на “нажата”.
• EVT_MIDDLE_UP(func) – Обрабатывает событие wxEVT_MIDDLE_UP, генерируемое при смене состояния средней кнопки на “отпущена”.
• EVT_MIDDLE_DCLICK(func) – Обрабатывает событие wxEVT_MIDDLE_DCLICK, генерируемое при двойном клике средней кнопкой.
• EVT_RIGHT_DOWN(func) – Обрабатывает событие wxEVT_RIGHT_DOWN, генерируемое при смене состояния правой кнопки на “нажата”.
• EVT_RIGHT_UP(func) – Обрабатывает событие wxEVT_RIGHT_UP, генерируемое при смене состояния правой кнопки на “отпущена”.
• EVT_RIGHT_DCLICK(func) – Обрабатывает событие wxEVT_RIGHT_DCLICK, генерируемое при двойном клике правой кнопкой.
• EVT_MOTION(func) – Обрабативает событие wxEVT_MOTION, генерируемое при движении указателя мыши.
• EVT_ENTER_WINDOW(func) – Обрабатывает событие wxEVT_ENTER_WINDOW, генерируемое при входе указателя в область окна.
• EVT_LEAVE_WINDOW(func) – Обрабатывает событие wxEVT_LEAVE_WINDOW, генерируемое при выходе указателя из области окна.
• EVT_MOUSEWHEEL(func) – Обрабатывает событие wxEVT_MOUSEWHEEL, генерируемое при движении колесика прокрутки у мыши.
• EVT_MOUSE_EVENTS(func) – Обрабатывает все события, производимые мышью.

6.1.1 Обработка событий о движении мыши и нажатии кнопок

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

Для проверки, нажаты ли клавиши-модификаторы во время перехвата события, используйте функции AltDown, MetaDown, ControlDown или ShiftDown. Функция CmdDown используется для проверки, нажата ли клавиша Meta (на Mac OS X) или клавиша Control (на других платформах). Дополнительную информацию можно найти далее в этой главе в разделе “Разновидности клавиш-модификаторов”.

Для определения, какая кнопка мыши нажата в данный момент, используйте функции LeftIsDown, MiddleIsDown и RightIsDown. Также можно проверить, нажата ли какая-либо кнопка, послав событие wxMOUSE_BTN_LEFT, wxMOUSE_BTN_MIDDLE, wxMOUSE_BTN_RIGHT или wxMOUSE_BTN_ANY объекту wxButton. Обратите внимание, что это проверка на нажатие какой-либо кнопки на момент совершения события, а не при смене его состояния.

В Mac OS X клавиша Command означает клавишу Meta, а клавиша Alt — Option. Так как часто на Mac-комьютерах мышь имеет только одну кнопку мыши, то пользователь должен удерживать Control во время клика, чтобы получить событие клика правой кнопкой. Это означает, что в Mac OS невозможно сделать правый клик одновременно с Control, если у вас нет обычной мыши с двумя или тремя кнопками.

Вы можете выяснить тип произошедшего события с помощью функций Dragging (движение курсора с удерживаемой кнопкой), Moving (без нее), Entering, Leaving, ButtonDown, ButtonUp, ButtonDClick, LeftClick, LeftDClick, LeftUp, RightClick, RightDClick, RightUp, ButtonUp и IsButton.

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

Вот пример обработки событий мыши в простом демонстрационном приложении:

BEGIN_EVENT_TABLE(DoodleCanvas, wxWindow)
EVT_MOUSE_EVENTS(DoodleCanvas::OnMouseEvent)
END_EVENT_TABLE()

void DoodleCanvas::OnMouseEvent(wxMouseEvent& event)
{
    static DoodleSegment *s_currentSegment = NULL;
    wxPoint pt(event.GetPosition());
    if (s_currentSegment && event.LeftUp())
    {
        // Заканчиваем сегмент, если пользователь отпустил левую кнопку
        if (s_currentSegment->GetLines().GetCount() == 0)
        {
            // Если сегмент пустой, то удаляем его
            delete s_currentSegment;
            s_currentSegment = (DoodleSegment *) NULL;
        }
        else
        {
            // Сохраняем сегмент
            DrawingDocument *doc = GetDocument();
            doc->GetCommandProcessor()->Submit(
            new DrawingCommand(wxT("Add Segment"), DOODLE_ADD, doc, s_currentSegment));
            doc->Modify(true);
            s_currentSegment = NULL;
        }
    }
    else if (m_lastX > -1 && m_lastY > -1 && event.Dragging())
    {
        // При движении мыши с нажатой кнопкой, добавляем линию в текущий сегмент
        if (!s_currentSegment)
            s_currentSegment = new DoodleSegment;
        DoodleLine *newLine = new DoodleLine(m_lastX, m_lastY, pt.x, pt.y);
        s_currentSegment->GetLines().Append(newLine);
        wxClientDC dc(this);
        DoPrepareDC(dc);
        dc.SetPen(*wxBLACK_PEN);
        dc.DrawLine( m_lastX, m_lastY, pt.x, pt.y);
    }
    m_lastX = pt.x;
    m_lastY = pt.y;
}

В этом приложении сегменты линий хранятся в документе. Пока пользователь, удерживая левую кнопку, двигает мышь, функция добавляет линии к текущему сегменту и одновременно рисует их. Как только пользователь отпускает левую кнопку мыши, текущий сегмент передается в документ, используя управляющий процессор (часть архитектуры Документ/Вид), который отвечает за реализацию операций “отменить” и “повторить”. В обработчике OnPaint этого приложения (не приводится) рисуются все сегменты линий документа. За полной реализацией действий “отменить” и “повторить”, обратитесь к Главе 19 “Работа с архитектурой Документ/Вид”. Более полное приложение захватывало бы мышь по нажатию левой кнопки и освобождала ее после отпускания кнопки, чтобы при выходе курсора за пределы окна, оно бы по-прежнему получало события.

6.1.2 Обработка событий от колесика мыши

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

В некоторых ситуациях мышь может быть настроена проматывать страницу за раз. В этом случае вам нужно вызвать IsPageScroll и если она вернет значение true, то проматывать страницу.

Ниже показана реализация обработки колесика прокрутки в классе wxScrolledWindow. В переменной m_wheelRotation суммируется вращение, и действие происходит только если количество строк ненулевое.

void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
{
    m_wheelRotation += event.GetWheelRotation();
    int lines = m_wheelRotation / event.GetWheelDelta();
    m_wheelRotation -= lines * event.GetWheelDelta();
    if (lines != 0)
    {
        wxScrollWinEvent newEvent;
        newEvent.SetPosition(0);
        newEvent.SetOrientation(wxVERTICAL);
        newEvent.m_eventObject = m_win;
        if (event.IsPageScroll())
        {
            if (lines > 0)
                newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
            else
                newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
            m_win->GetEventHandler()->ProcessEvent(newEvent);
        }
        else
        {
            lines *= event.GetLinesPerAction();
            if (lines > 0)
                newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
            else
                newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
            int times = abs(lines);
            for (; times > 0; times)
                m_win->GetEventHandler()->ProcessEvent(newEvent);
        }
    }
}

6.2 Обработка событий от клавиатуры

События от клавиатуры представлены классом wxKeyEvent. В библиотеке wxWidgets существуют три типа сообщений: нажатие клавиши (key down), отпускание клавиши и набор символа. Нажатие и отпускание – не преобразуемые события, в то время как набор символа — преобразуемое.

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

Чтобы получать события от клавиатуры ваше окно должно находиться в текстовом фокусе, который вы можете принудительно получить, вызвав метод wxWindow::SetFocus, например, по нажатию мыши.

Таблица 6.2 содержит три макроса для обработки событий от клавиатуры.

• EVT_KEY_DOWN(func) – Обрабатывает событие wxEVT_KEY_DOWN
  (не преобразуемое нажатие клавиши).
• EVT_KEY_UP(func) – Обрабатывает событие wxEVT_KEY_UP (не
  преобразуемое отпускание клавиши).
• EVT_CHAR(func) – Обрабатывает событие wxEVT_CHAR (преобразуемый набор символа).

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

Для получения кода клавиши вызывайте функцию GetKeyCode (в Unicode-сборках, можно использовать GetUnicodeKeyCode). Все действительные коды клавиш указаны в таблице 6.3.

Для проверки, была ли нажата клавиша-модификатор во время образования события, используйте функции AltDown, MetaDown, ControlDown или ShiftDown. Функция HasModifiers возвращает значение true, если Control или Alt были нажаты во время генерации сообщения нажатия/отпускания (но не Shift или Meta).

Вместо использования функций ControlDown или MetaDown лучше использовать более высокоуровевую функцию CmdDown, которая вызывает MetaDown на Mac OS X и ControlDown на прочих платформах. См. также “Разновидности клавиш-модификаторов” в следующем разделе для более подробных объяснений.
Функция GetPosition возвращает позицию указателя мыши в координатах клиентской области во время получения соответствующих событий.

Совет: если событие нажатия клавиши захвачено и его обработчик не вызвал метод event.Skip(), то данное событие не будет передаваться следующим обработ чикам. Если вы не вызываете event.Skip() для событий, которые не обрабатываете, то на некоторых платформах могут перестать работать горящие клавиши.

6.2.1 Пример обработчика события ввода символа

Ниже представлен обработчик клавиш из примера wxThumbnailCtrl, который вы можете найти в папке examples/chap12/thumbnail на прилагаемом CD-ROM’е.

BEGIN_EVENT_TABLE( wxThumbnailCtrl, wxScrolledWindow )
EVT_CHAR(wxThumbnailCtrl::OnChar)
END_EVENT_TABLE()
void wxThumbnailCtrl::OnChar(wxKeyEvent& event)
{
    int flags = 0;
    if (event.ControlDown())
        flags |= wxTHUMBNAIL_CTRL_DOWN;
    if (event.ShiftDown())
        flags |= wxTHUMBNAIL_SHIFT_DOWN;
    if (event.AltDown())
        flags |= wxTHUMBNAIL_ALT_DOWN;
    if (event.GetKeyCode() == WXK_LEFT ||
        event.GetKeyCode() == WXK_RIGHT ||
        event.GetKeyCode() == WXK_UP ||
        event.GetKeyCode() == WXK_DOWN ||
        event.GetKeyCode() == WXK_HOME ||
        event.GetKeyCode() == WXK_PAGEUP ||
        event.GetKeyCode() == WXK_PAGEDOWN ||
        event.GetKeyCode() == WXK_PRIOR ||
        event.GetKeyCode() == WXK_NEXT ||
        event.GetKeyCode() == WXK_END)
    {
        Navigate(event.GetKeyCode(), flags);
    }
    else if (event.GetKeyCode() == WXK_RETURN)
    {
        wxThumbnailEvent cmdEvent(
            wxEVT_COMMAND_THUMBNAIL_RETURN,
            GetId());
        cmdEvent.SetEventObject(this);
        cmdEvent.SetFlags(flags);
        GetEventHandler()->ProcessEvent(cmdEvent);
    }
    else
        event.Skip();
}

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

6.2.2 Преобразование кода клавиши

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

Вот несколько поясняющих примеров. Когда клавиша “А” нажата, код события нажатия равен коду “А” из таблицы ASCII (65), но код события ввода символа – ASCII “а” (97). Притом, если вы нажали “А” с Shift, код клавиши в событии нажатия по-прежнему будет “А”, в то время как код клавиши события ввода символа теперь тоже станет “А”.

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

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

Другой вид преобразования происходит когда зажат Control, например, Ctrl+А. Событие нажатия передает тот же код “А”, но событие ввода символа будет иметь код “1″. Это ASCII-значение этой комбинации клавиш.

Вы можете исследовать работу других клавиш у себя в системе, запустив пример samples/keyboard и понажимав разные клавиши.

6.2.3 Разновидности клавиш-модификаторов

В ОС Windows клавиши-модификаторы это Control и Alt, а также особая win-клавиша, работающая как Meta. В ОС UNIX, клавиша, работающая как Meta настраивается (запустите утилиту xmodmap, чтобы посмотреть, как настроена ваша система).

Иногда NumLock настроена как Meta, и из за этого функция HasModifiers не возвращают значение true при удержанной клавише Meta, так как при этом нормально обрабатываются нажатия клавиш с включенным NumLock.

В Mac OS X клавиша Command (с символом apple) выполняет функции Meta, а Option — функции Alt.
Эти различия показаны в таблице 6.4, где первая колонка — название модификаторов в wxWidgets, остальные три — клавиши, используемые для этих модификаторов на основных платформах. Клавиши Mac проиллюстрированы для наглядности.

Так как в Mac OS X клавиша Command используется для тех же целей, что и Control на других платформах, то можно использовать функцию CmdDown объекта wxKeyEvent вместо ControlDown или MetaDown для перехвата этих команд на разных платформах.

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

6.2.4 Акселераторы

Акселераторы — это “горячие” клавиши для различных команд меню, которые позволяют пользователю вызывать команды очень быстро. Такие горячие клавиши имеют преимущество в обработке перед другими обработчиками клавиатуры, такими как EVT_CHAR. Стандартный набор таких акселераторов включает в себя Ctrl+O (чтобы открыть файл) и Ctrl+V (чтобы вставить данные в приложение). Самый легкий способ реализовать акселераторы — определить их непосредственно в пунктах меню. Например:

menu->Append(wxID_COPY, wxT("Copy\tCtrl+C"));

wxWidgets интерпретирует текст после символа табуляции как акселератор и добавляют его в таблицу акселераторов меню. В этом примере при нажатии пользователем Ctrl+C посылается команда wxID_COPY, как будто был выбран соответствующий пункт меню.

Вы можете использовать Control, Alt или Shift в различных сочетаниях, дополняя символом или функциональной клавишей, следующими за “+” или “-”. Вот примеры правильных сочетаний клавиш-акселераторов: Ctrl+B, G, Shift-Alt-K, F9, Ctrl+F3,
Esc и Del. Вы можете использовать следущие зарезервированные имена клавиш: Del, Back, Ins, Insert, Enter, Return, PgUp, PgDn, Left, Right, Up, Down, Home, End, Space, Tab, Esc и Escape. Регистр в именах клавиш не важен (любые сочетания верхнего и нижнего регистра будут работать).

Напоминаем, что в Mac OS X описание горячих клавиш, использующих Ctrl, будет
в действительности использовать клавишу Command.

Другой способ включить акселераторы — заполнить таблицу wxAcceleratorTable
объектами wxAcceleratorEntry и связать ее с окном, используя метод wxWindow::SetAcceleratorTable. Каждый объект wxAcceleratorEntry инициализируется битовым списком модификаторов (один или несколько wxACCEL_ALT,
wxACCEL_CTRL, wxACCEL_SHIFT и wxACCEL_NORMAL), кодом клавиши (см. таблицу 6.3) и идентификатором. Например,

wxAcceleratorEntry entries[4];
entries[0].Set(wxACCEL_CTRL, (int) ’N’, wxID_NEW);
entries[1].Set(wxACCEL_CTRL, (int) ’X’, wxID_EXIT);
entries[2].Set(wxACCEL_SHIFT, (int) ’A’, wxID_ABOUT);
entries[3].Set(wxACCEL_NORMAL, WXK_DELETE, wxID_CUT);
wxAcceleratorTable accel(4, entries);
frame->SetAcceleratorTable(accel);

Можно использовать несколько таблиц акселераторов в оконной иерархии, а также сочетать наборы акселераторов с определенной таблицей wxAcceleratorTable.

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

6.3 Обработка событий от джойстика

Класс wxJoystick дает вашему приложению возможность получать информацию от одного или двух джойстиков в ОС Windows или Linux. Как правило, вы создаете объект wxJoystick, передавая wxJOYSTICK1 или wxJOYSTICK2 и храните объект в ОЗУ, пока он нужен. Когда вам нужно получить с него данные, пошлите функцию SetCapture, передав указатель на окно, которое будет получать события джойстика, а затем вызовите ReleaseCapture, если вам больше не нужны события. Вы можете поставить захват на все время работы приложения вызвав SetCapture при инициализации и ReleaseCapture при выходе.

Для более детального описания событий и методов рассмотрим пример samples/joystick из дистрибутива wxWidgets. Управляя джойстиком пользователь может рисовать последовательности линий на холсте, нажимая любую из кнопок джойстика. При нажатии также воспроизводится звук.

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

#include "wx/wx.h"
#include "wx/sound.h"
#include "wx/joystick.h"
bool MyApp::OnInit()
{
    wxJoystick stick(wxJOYSTICK1);
    if (!stick.IsOk())
    {
        wxMessageBox(wxT("No joystick detected!"));
        return false;
    }
    m_fire.Create(wxT("buttonpress.wav"));
    m_minX = stick.GetXMin();
    m_minY = stick.GetYMin();
    m_maxX = stick.GetXMax();
    m_maxY = stick.GetYMax();
    // Создаем главный фрейм окна
    ...
    return true;
}

MyCanvas — это окно, которое хранит объект джойстика, а также получает от
него события. Вот реализация MyCanvas:

BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
EVT_JOYSTICK_EVENTS(MyCanvas::OnJoystickEvent)
END_EVENT_TABLE()
MyCanvas::MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size):
wxScrolledWindow(parent, wxID_ANY, pos, size, wxSUNKEN_BORDER)
{
    m_stick = new wxJoystick(wxJOYSTICK1);
    m_stick->SetCapture(this, 10);
}

MyCanvas::~MyCanvas()
{
    m_stick->ReleaseCapture();
    delete m_stick;
}

void MyCanvas::OnJoystickEvent(wxJoystickEvent& event)
{
    static long xpos = -1;
    static long ypos = -1;
    wxClientDC dc(this);
    wxPoint pt(event.GetPosition());
    // Если возможны отрицательные координаты, то делаем, чтобы минимум был 0
    int xmin = wxGetApp().m_minX;
    int xmax = wxGetApp().m_maxX;
    int ymin = wxGetApp().m_minY;
    int ymax = wxGetApp().m_maxY;
    if (xmin < 0) {
        xmax += abs(xmin);
        pt.x += abs(xmin);
    }
    if (ymin < 0) {
        ymax += abs(ymin);
        pt.y += abs(ymin);
    }
    // Масштабируем по размеру холста
    int cw, ch;
    GetSize(&cw, &ch);
    pt.x = (long) (((double)pt.x/(double)xmax) * cw);
    pt.y = (long) (((double)pt.y/(double)ymax) * ch);
    if (xpos > -1 && ypos > -1 && event.IsMove() && event.ButtonIsDown())
    {
        dc.SetPen(*wxBLACK_PEN);
        dc.DrawLine(xpos, ypos, pt.x, pt.y);
    }
    xpos = pt.x;
    ypos = pt.y;
    wxString buf;
    if (event.ButtonDown())
        buf.Printf(wxT("Joystick (%d, %d) Fire!"), pt.x, pt.y);
    else
        buf.Printf(wxT("Joystick (%d, %d)"), pt.x, pt.y);
    frame->SetStatusText(buf);
    if (event.ButtonDown() && wxGetApp().m_fire.IsOk())
    {
        wxGetApp().m_fire.Play();
    }
}

6.3.1 События wxJoystick

Класс wxJoystick создает события типа wxJoystickEvent. Соответствующие им макросы представлены в таблице 6.5. Каждый макрос принимает один аргумент —
функцию обработки события.

• EVT_JOY_BUTTON_DOWN(func) Обрабатывает событие wxEVT_JOY_BUTTON_DOWN, генерируемое при нажатии кнопки.
• EVT_JOY_BUTTON_UP(func) Обрабатывает событие wxEVT_JOY_BUTTON_UP, генерируемое при отпускании кнопки.
• EVT_JOY_MOVE(func) Обрабатывает событие wxEVT_JOY_MOVE, генерируемое при движении джойстика в плоскости XY.
• EVT_JOY_ZMOVE(func) Обрабатывает событие wxEVT_JOY_ZMOVE, генерируемое при движении джойстика по оси Z.
• EVT_JOYSTICK_EVENTS(func) Обрабатывает все события джойстика.

6.3.2 Методы класса wxJoystickEvent

Ниже представлено описание функции класса wxJoystickEvent, которые вы можете вызывать для получения дополнительной информации о событии. Как обычно, вы можете вызвать функцию GetEventType, чтобы получить тип события, что полезно при использовании макроса EVT_JOYSTICK_EVENTS, который отлавливает все события от джойстика.

Вызов ButtonDown позволяет проверить, было ли событие вызвано нажатием кнопки. Вы можете дополнительно передать идентификатор кнопки wxJOY_BUTTONn
(где n = 1, 2, 3 или 4) чтобы определить, какая конкретно кнопка была нажата, или wxJOY_BUTTON_ANY, если вам это не важно. Метод ButtonUp работает также, но проверяет событие отпускание соответствующей кнопки. Метод IsButton равносилен применению конструкции ButtonDown() || ButtonUp().

Чтобы проверить, была ли кнопка нажата во время генерации события (если, например, событие представляет не само нажатие кнопки), вызывите метод ButtonIsDown с теми же аргументами, что и ButtonDown. В противном случае используйте GetButtonState (с теми же аргументами), чтобы получить битовый список идентификаторов wxJOY_BUTTONn.
Вызовете метод IsMove чтобы проверить, было ли событие движением в плоскости XY и IsZMove — по оси Z.
Функция GetPosition возвращает объект wxPoint с текущей позицией в плоскости XY, а GetZPosition возвращает целое, представляющее собой Z-координату,
если таковая поддреживается.

Наконец, вы можете определить, какой джойстик послужил причиной события (wxJOYSTICK1 или wxJOYSTICK2) вызвав GetJoystick.

6.3.3 Методы класса wxJoystick

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

Как было показано в примере, функцию SetCapture необходимо вызывать для прямого получения данных с джойстика в определенное окно, и, соответственно, ReleaseCapture для освобождения и использования его другими приложениями. В случае, если джойстик занят другим приложением или неисправен, вызывайте IsOK перед попыткой захвата. Вы также можете определить характеристики джойстика при помощи функций GetNumberButtons, GetNumberJoysticks, GetNumberAxes, HasRudder и прочих.

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

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

6.4 Заключение

В этой главе вы узнали о получении данных с мыши, клавиатуры и джойстика. Теперь вы сможете добавить взаимодействие с устройствами ввода в ваше приложение. Для углубления степени понимания рекомендуем изучить примеры samples/keyboard, samples/joytest и samples/dragimag, а также класс wxThumbnailCtrl в examples/chap12 на прилагаемом CD-ROM.

Следующая глава расскажет, как можно добиться гибкой, переносимой, легко переводимой, и, прежде всего, привлекательной компоновки элементов окна с помощью нашего гибкого друга — сайзера (sizer).

Программирование с wxImage

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

Основные функции wxImage в Таблице 10-6.

Таблица 10-6. wxImage Функции

• wxImage – Изображение может быть создано с заданной шириной и высотой, из другого изображения, XPM данных, битовых данных (char[]) и опционально данных об альфа канале, из файла, су указанием типа файла, или из потока ввода.
• ConvertAlphaToMask – Конвертирует альфа канал (если есть) в маску.
• ConvertToMono – Конвертирует в новое монохромное изображение.
• Copy – Возвращает идентичную копию, не используя подсчета ссылок.
• Create – Создает изображение заданного размера, опционально инициализирует его из данных.
• Destroy – Удаляет внутренние данные, если никакой другой объект их не использует.
• GetData, SetData – Возвращают или задают указатель на внутренние данные (unsigned char*).
• GetImageCount – Возвращает количество изображений в файле или потоке.
• GetOption, GetOptionInt, SetOption, HasOption – Возвращают, задают, или проверяют объект на наличие опции.
• GetSubImage – Возвращает область изображения, как новое изображение.
• GetWidth, GetHeight – Возвращают размеры изображения.
• Getred, GetGreen, GetBlue, SetRGB, GetAlpha, SetAlpha – Возвращают, или задают значения красного, синего, зеленого, и альфа значения для пикселя.
• HasMask, GetMaskRed, GetMaskGreen, GetMaskBlue, SetMaskColour – Функции для проверки наличия маски, установки и взятия цвета маски.
• LoadFile, SaveFile – Загрузка из файла и сохранение изображения в файл.
• Mirror – Зеркально отображает изображение в заданном направлении, возвращает новое изображение.
• Ok – Возвращает true если изображение инициализировано.
• Paste – Вставляет изображение в текущее изображение, в заданной точке.
• Rotate, Rotate90 – Вращает изображение, возвращает новое изображение.
• SetMaskFromImage – Устанавливает маску, определяет изображение или цвет, который нужно использовать для прозрачности.
• Scale, Rescale – Изменяют размеры изображения, возвращают новое изображение, или сохраняют изменения в текущем.

Загрузка и Сохранение Изображений

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

В Таблице 10-7 указаны все типы обработчиков изображений, на платформах поддерживаемых wxWidgets. По-умолчанию всегда установлен wxBMPHandler обработчик. Для того, что бы использовать другие форматы, установите нужный обработчик с помощью wxImage::AddHandler или wxInitAllImageHandlers.

Если Вы используете определенный формат, у Вас должен быть вот такой код в вашей wxApp::OnInit функции:

#include "wx/image.h"

wxImage::AddHandler( new wxPNGHandler );
wxImage::AddHandler( new wxJPEGHandler );
wxImage::AddHandler( new wxGIFHandler );
wxImage::AddHandler( new wxXPMHandler );

Или же можно просто вызвать:

wxInitAllImageHandlers();

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

// Загружаем изображение, используя конструктор, с указание типа файла
wxImage image(wxT("image.png"), wxBITMAP_TYPE_PNG);
if (image.Ok())
{
    ...
}

// Оставляем wxImage самому определить тип файла
wxImage image(wxT("image.png"));

// Загрузка в два шага
wxImage image;
if (image.LoadFile(wxT("image.png")))
{
    ...
}

// Загрузка в два шага, с использованием индекса изображения, для
// форматов, с несколькими изображениями в файле:
// загружаем изображение номер два, если оно есть
wxImage image;
int imageCount = wxImage::GetImageCount(wxT("image.tif"));
if (imageCount > 2)
    image.LoadFile(wxT("image.tif"), wxBITMAP_TYPE_TIFF, 2);

// Загрузка из потока
wxFileInputStream stream(wxT("image.tif"));
wxImage image;
image.LoadFile(stream, wxBITMAP_TYPE_TIF);

// Сохранение в файл
image.SaveFile(wxT("image.png")), wxBITMAP_TYPE_PNG);

// Сохранение в поток
wxFileOutputStream stream(wxT("image.tif"));
image.SaveFile(stream, wxBITMAP_TYPE_TIF);

Изображения сохраняются в файл в 24-битном формате, за исключением XPM и PCX форматов, чьи обработчики подсчитывают количество цветов и сохраняют с нужной глубиной. В JPEG формате есть опция качества, которую можно установить перед сохранением. Значение является целым числом между 0 и 100, где 0 это наихудшее качество с высоким уровнем сжатия, и 100 наивысшее качество с плохим сжатием.

// Сохраняем с оптимальным сжатием и компрессией
image.SetOption(wxIMAGE_OPTION_QUALITY, 80);
image.SaveFile(wxT("picture.jpg"), wxBITMAP_TYPE_JPEG);

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

// Сохраняем XPM в поток
image.SetOption(wxIMAGE_OPTION_FILENAME, wxT("myimage"));
image.SaveFile(stream, wxBITMAP_TYPE_XPM);

Учтите, обработчик добавит суффикс _xpm к имени файла, которое Вы укажете.

Прозрачность

Есть два способа использования прозрачности в wxImage: маска и альфа канал. Один цвет изображения может быть указан как цвет маски, что приведет к автоматическому созданию объекта wxMask при конвертировании в wxBitmap.
wxImage также поддерживает альфа канал. В дополнение к каждому байту в пикселе для красного, зеленого, и синего компонентов цвета, класс содержит байт, который указывает значение непрозрачности (opacity) для данного пикселя. Значение альфа 0 соответствует прозрачному пикселю (нулевая непрозрачность), и значение 255 указывает на то, что пиксель 100% непрозрачный.
Не у всех изображений есть альфа канал, и перед использованием GetAlpha, Вы должны проверить наличие альфа канал с помощью HasAlpha. В данный момент, альфа канал поддерживают только изображения, загруженные из PNG файлов, или изображения с назначенным альфа каналом функцией SetAlpha. Сохранение изображений с альфа каналом пока не поддерживается. Рисовать изображения с альфа каналом можно сконвертировав изображение в wxBitmap и вызвав wxDC::DrawBitmap или wxDC::Blit.
В нижеприведенном коде показывается, как создать wxImage с маской. Изображение будет синим, и будет содержать прозрачный прямоугольник.

// Создаем изображение с маской
// Сначала рисуем в wxBitmap
wxBitmap bitmap(400, 400);
wxMemoryDC dc;
dc.SelectObject(bitmap);
dc.SetBackground(*wxBLUE_BRUSH);
dc.Clear();
dc.SetPen(*wxRED_PEN);
dc.SetBrush(*wxRED_BRUSH);
dc.DrawRectangle(50, 50, 200, 200);
dc.SelectObject(wxNullBitmap);

// Конвертируем растровое изображение (bitmap) в картинку (image)
wxImage image = bitmap.ConvertToImage();

// Устанавливаем красный как цвет маски
image.SetMaskColour(255, 0, 0);

Другой способ сделать маску – это создать ее из другого изображения. В следующем примере, image.bmp содержит основное изображение, и mask.bmp содержит черные пиксели, которые будут указывать на прозрачные области.

// Загрузим изображение и его маску
wxImage image(wxT("image.bmp"), wxBITMAP_TYPE_BMP);
wxImage maskImage(wxT("mask.bmp"), wxBITMAP_TYPE_BMP);

// Укажем черный, как цвет маски
image.SetMaskFromImage(maskImage, 0, 0, 0);

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

// Загружаем изображение с прозрачностью
wxImage image(wxT("image.png"), wxBITMAP_TYPE_PNG);

// Получаем маску
if (image.HasMask())
{
    wxColour maskColour(image.GetMaskRed(),
    image.GetMaskGreen(),
    image.GetMaskBlue());
}

Преобразования

wxImage поддерживает масштабирование, вращение, и зеркальное отражение картинки. Вот несколько примеров:

// Масштабировать изображение как 200x200
// и назначить результат другому объекту.
// image1 не модифицируется.
wxImage image2 = image1.Scale(200, 200);

// Изменяем размер на 200x200
image1.Rescale(200, 200);

// Вращаем на указаное число радиан.
// image1 не модифицируется.
wxImage image2 = image1.Rotate(0.5);

// Вращаем на 90 градусов по часовой стрелке.
// image1 не модифицируется.
wxImage image2 = image1.Rotate90(true);

// Отражаем изображение по горизонтали.
// image1 не модифицируется.
wxImage image2 = image1.Mirror(true);

Уменьшение Цветности
Если Вам нужно уменьшить количество цветов в изображении, Вы можете использовать статические функции класса wxQuantize. Нужная нам функция Quantize, в качестве аргументов принимает исходное изображение, возвращаемое изображение, выборочно палитру wxPalette** для сокращенных из изображения цветов, и желаемое количество цветов. Так же можно указать переменную типа unsigned char**, для получения 8-битного представления возвращаемого изображения и стиль, для лучшего управления возвращаемыми данными; для более детальной информации, смотрите справочное руководство.
Данный пример показывает, как уменьшить цветность изображения до 256 цветов:

#include "wx/image.h"
#include "wx/quantize.h"

wxImage image(wxT("image.png"));

int maxColorCount = 256;
int colors = image.CountColours();
wxPalette* palette = NULL;
if (colors > maxColorCount )
{
    wxImage reducedImage;
    if (wxQuantize::Quantize(image, reducedImage,
                               & palette, maxColorCount))
    {
        colors = reducedImage.CountColours();
        image = reducedImage;
    }
}

С изображением может идти палитра, связанная с ним wxPalette, например когда изображение загружено из GIF файла. Тем не менее, изображение хранится в RGB формате, а палитра просто указывает значение индексов в RGB формате. Для wxImage также можно назначить палитру wxPalette, и в результате SaveFile может сохранить данное изображение с ограниченным количеством цветов. Например, если Windows BMP обработчик обнаруживает, что в опциях изображения указан wxBMP_8BPP_PALETTE формат, он сохраняет изображение с палитрой изображения; если указан формат wxBMP_8BPP, обработчик создает палитру из данных изображения. Некоторые обработчики сами производят уменьшение цветности, например PCX, пока не подберут достаточное количество уникальных цветов.

Больше информации по wxPalette, смотрите в разделе “wxPalette” в Главе 5.

Манипуляции Непосредственно с Данными wxImage

Вы можете получить доступ непосредственно к данным изображения функцией GetData , для более быстрой манипуляции данными, чем через GetRed, GetBlue, GetGreen, и SetRGB. Ниже показан пример преобразования цветного изображения в черно-белое:

void wxImage::ConvertToGrayScale(wxImage& image)
{
    double red2Gray   = 0.297;
    double green2Gray = 0.589;
    double blue2Gray  = 0.114;
    int w = image.GetWidth(), h = image.GetHeight();
    unsigned char *data = image.GetData();

    int x,y;
    for (y = 0; y < h; y++)
        for (x = 0; x < w; x++)
        {
            long pos = (y * w + x) * 3;

            char g = (char) (data[pos]*red2Gray +
                              data[pos+1]*green2Gray +
                              data[pos+2]*blue2Gray);
            data[pos] = data[pos+1] = data[pos+2] = g;
        }
}

Списки Изображений и Пакеты Иконок

Иногда удобно объединять несколько изображений в один объект. Списки wxImageList можно использовать непосредственно в Вашем приложении, или для иконок элементов управления wxWidgets, которые используют списки изображений (image lists). wxNotebook, wxTreeCtrl, и wxListCtrl используют wxImageList для иконок в своих элементах. Также можно просто нарисовать отдельное изображение из списка wxImageList в контекст устройства.

wxImageList создается с указанием высоты и ширины каждого изображения, булевым значением, которое указывает на то будет ли использоваться маска, и начальным размером списка (для внутренней оптимизации). Потом нужно добавить несколько wxBitmap или wxIcon изображений. Для списков нельзя использовать wxImage объект, но можно передать его в конструктор wxBitmap. wxImageList::Add возвращает целочисельный индекс, который потом можно использовать как идентификатор изображения; после того, как Вы добавите изображение в список, Вы можете его уничтожить, потому что wxImageList делает его копию.

Далее несколько примеров создания wxImageList и добавления в него изображений.

// СозданиеImageList
wxImageList *imageList = new wxImageList(16, 16, true, 1);

// Добавление растрового изображения с прозрачностью из PNG
wxBitmap bitmap1(wxT("image.png"), wxBITMAP_TYPE_PNG);
imageList->Add(bitmap1);

// Добавление изображения с прозрачностью из другого растрового изображения
wxBitmap bitmap2(wxT("image.bmp"), wxBITMAP_TYPE_BMP);
wxBitmap maskBitmap(wxT("mask.bmp"), wxBITMAP_TYPE_BMP);
imageList->Add(bitmap2, maskBitmap);

// Добавление растрового изображения с маской, указанной цветом маски
wxBitmap bitmap3(wxT("image.bmp"), wxBITMAP_TYPE_BMP);
imageList->Add(bitmap3, *wxRED);

// Добавление иконки
#include "folder.xpm"
wxIcon icon(folder_xpm);
imageList->Add(icon);

Можно нарисовать изображение непосредственно в контекст устройства, передав флаг, который указывает, как будет нарисовано изображение. wxIMAGELIST_DRAW_TRANSPARENT, например, указывает, что изображение рисуется с использованием прозрачности, есть еще три формата рисования: wxIMAGELIST_DRAW_NORMAL, wxIMAGELIST_DRAW_SELECTED, или wxIMAGELIST_DRAW_FOCUSED.

// Рисуем все изображения в списке
wxClientDC dc(window);
size_t i;
for (i = 0; i < imageList->GetImageCount(); i++)
{
    imageList->Draw(i, dc, i*16, 0, wxIMAGELIST_DRAW_NORMAL|
                                    wxIMAGELIST_DRAW_TRANSPARENT);
}

// Создадим wxImageList
wxImageList *imageList = new wxImageList(16, 16, true, 1);

// Добавим несколько иконок
wxBitmap bitmap1(wxT("folder.png"), wxBITMAP_TYPE_PNG);
wxBitmap bitmap2(wxT("file.png"), wxBITMAP_TYPE_PNG);
int folderIndex = imageList->Add(bitmap1);
int fileIndex = imageList->Add(bitmap2);

// Создадим блокнот с двумя страницами
wxNotebook* notebook = new wxNotebook(parent, wxID_ANY);
wxPanel* page1 = new wxPanel(notebook, wxID_ANY);
wxPanel* page2 = new wxPanel(notebook, wxID_ANY);

// Назначим список изображений
notebook->AssignImageList(imageList);

// Добавим страницы с иконками
notebook->AddPage(page1, wxT("Folder options"), true, folderIndex);
notebook->AddPage(page2, wxT("File options"), false, fileIndex);

#include "wx/hashmap.h"

WX_DECLARE_STRING_HASH_MAP(int, IconNameToIndexHashMap);

// Класс для обращения к индексам через имя
class IconNameToIndex
{
public:
    IconNameToIndex() {}

    // Добавление изображения с именем в список изображений
    void Add(wxImageList* list, const wxBitmap& bitmap,
        const wxString& name) {
        m_hashMap[name] = list->Add(bitmap);
    }

    // Добавление иконки с именем в список изображений
    void Add(wxImageList* list, const wxIcon& icon,
        const wxString& name) {
        m_hashMap[name] = list->Add(icon);
    }

    // Поиск индекса по имени
    int Find(const wxString& name) { return m_hashMap[name]; }

private:
    IconNameToIndexHashMap m_hashMap;
};

// Создаем пакет с одной иконкой
#include "file16x16.xpm"
wxIconBundle iconBundle(wxIcon(file16x16_xpm));

// Добавляем иконку из файла
iconBundle.Add(wxIcon(wxT("file32x32.png"), wxBITMAP_TYPE_PNG));

// Создаем пакет иконок из нескольких иконок в одном фале
wxIconBundle iconBundle2(wxT("multi-icons.tif"), wxBITMAP_TYPE_TIF);

// Получает иконку с заданным размером, или если не найдена, берет иконку
// с размерами wxSYS_ICON_X, wxSYS_ICON_Y
wxIcon icon = iconBundle.GetIcon(wxSize(16,16));

// Назначает пакет иконок приложению
wxFrame* frame = new wxFrame(parent, wxID_ANY);
frame->SetIcons(iconBundle);

wxBitmap bmp = wxArtProvider::GetBitmap(wxART_GO_BACK,wxART_TOOLBAR);

// XPM’ы с графикой
#include "bitmaps/helpbook.xpm"
#include "bitmaps/helppage.xpm"
#include "bitmaps/helpback.xpm"
#include "bitmaps/helpdown.xpm"
#include "bitmaps/helpforward.xpm"
#include "bitmaps/helpoptions.xpm"
#include "bitmaps/helpsidepanel.xpm"
#include "bitmaps/helpup.xpm"
#include "bitmaps/helpuplevel.xpm"
#include "bitmaps/helpicon.xpm"

#include "wx/artprov.h"

// Класс графики
class MyArtProvider : public wxArtProvider
{
protected:
    virtual wxBitmap CreateBitmap(const wxArtID& id,
                                  const wxArtClient& client,
                                  const wxSize& size);
};

// CreateBitmap функция
wxBitmap MyArtProvider::CreateBitmap(const wxArtID& id,
                                     const wxArtClient& client,
                                     const wxSize& size)
{
    if (id == wxART_HELP_SIDE_PANEL)
        return wxBitmap(helpsidepanel_xpm);
    if (id == wxART_HELP_SETTINGS)
        return wxBitmap(helpoptions_xpm);
    if (id == wxART_HELP_BOOK)
        return wxBitmap(helpbook_xpm);
    if (id == wxART_HELP_FOLDER)
        return wxBitmap(helpbook_xpm);
    if (id == wxART_HELP_PAGE)
        return wxBitmap(helppage_xpm);
    if (id == wxART_GO_BACK)
        return wxBitmap(helpback_xpm);
    if (id == wxART_GO_FORWARD)
        return wxBitmap(helpforward_xpm);
    if (id == wxART_GO_UP)
        return wxBitmap(helpup_xpm);
    if (id == wxART_GO_DOWN)
        return wxBitmap(helpdown_xpm);
    if (id == wxART_GO_TO_PARENT)
        return wxBitmap(helpuplevel_xpm);
    if (id == wxART_FRAME_ICON)
        return wxBitmap(helpicon_xpm);
    if (id == wxART_HELP)
        return wxBitmap(helpicon_xpm);

    // Любые иконки wxWidgets, которые здесь не реализованы,
    // будут поставлены «родным» классом графики.
    return wxNullBitmap;
}

// Инициализация
bool MyApp::OnInit()
{
    ...

    wxArtProvider::PushProvider(new MyArtProvider);

    ...
    return true;
}