|
Создание элементов управления ActiveX с помощью C++ Builder
Что такое ActiveX
Технология ActiveX, рассматриваемая в
данной статье, базируется на технологии Microsoft COM
(Component Object Model - модель компонентных объектов),
позволяющей создавать и использовать
программные компоненты, предоставляющие
различные сервисы другим приложениям,
компонентам и операционной системе. COM
представляет собой одну из реализаций концепции
распределенных вычислений, базирующейся в общем
случае на предоставлении возможности
приложениям использовать для расширения своей
функциональности готовые компоненты и объекты
(иногда они называются сервисами). Технология COM
позволяет использовать
объектно-ориентированный подход не в рамках
одного приложения, а в рамках операционной
системы, но, в отличие от стандартных классов,
определенных в исходном тексте и реализуемых как
объекты в адресном пространстве одного процесса,
эти компоненты могут в общем случае
располагаться в адресных пространствах разных
процессов и даже на разных компьютерах.
В настоящее время существуют три типа
спецификаций COM, определенных Microsoft и включающих
большое количество интерфейсов и функций:
OLE-документы - составные документы, содержащие
внедренные или связанные объекты. Эта
спецификация описывает правила создания
контейнеров для таких документов с
"активацией по месту". Отметим, что
компонент OLEContainer Delphi и C++Builder создан с учетом этой
спецификации (этой теме будет посвящена одна из
следующих статей данного цикла).
OLE Automation. Эта спецификация описывает, как
создать сервер и контроллер, управляющий его
поведением с помощью скриптов или макросов. Эта
спецификация также поддерживается Delphi и C++Builder
(об этом также пойдет речь в ближайших статьях
данного цикла).
Управляющие элементы ActiveX, использующие
специальный вариант протокола Automation (о них-то и
пойдет речь в данной статье).
Использование COM, и, в частности,
технологии ActiveX, позволяет обеспечить создание
приложений, собираемых из готовых компонентов -
элементов управления ActiveX, отличающееся от
привычной пользователям C++Builder или Delphi
разработки приложений с помощью VCL-компонентов
тем, что такая "сборка" не зависит от того, на
каком языке написаны как готовые компоненты, так
и использующее их приложение - лишь бы средство
разработки поддерживало возможность
использования таких компонентов в
разрабатываемом приложении (такое приложение
обычно называется контейнером).
Элементы управления ActiveX представляют
собой библиотеки, содержащие исполняемый код.
Как было сказано выше, эти библиотеки могут быть
использованы в различных приложениях как
встроенные элементы управления, поэтому они
обладают свойствами, событиями и методами,
доступными посредством автоматизации.
Современные средства разработки, как правило,
позволяют включать такие элементы в создаваемые
с их помощью приложения. Помимо этого, элементы
управления ActiveX нередко используются в качестве
расширений web-броузеров с целью придания им
дополнительной функциональности, например, для
отображения документов, отличных от
поддерживаемых данным броузером.
Как любой COM-сервер, элемент управления
ActiveX обладает уникальным идентификатором GUID и
должен быть зарегистрирован в реестре. На
основании этой записи может быть осуществлен
поиск местоположения файла с расширением *.ocx,
содержащего его реализацию.
Таким образом, создав элемент
управления ActiveX, обладающий интересующей Вас
функциональностью, Вы можете в дальнейшем
позволить его пользователям встраивать этот
элемент в свои приложения (например, написанные
на Visual Basic, PowerBuilder, Delphi, C++Builder и др.), отображать его
в web-броузере в составе выгруженной с Вашего
web-сервера HTML-страницы, включать его в состав
документов MS Office, при этом Вы не обязаны
предоставлять исходный текст этого компонента.
Когда следует создавать управляющие
элементы ActiveX? Естественно, в тех случаях, когда
функциональность, содержащаяся в таком элементе,
уникальна. Нет смысла создавать ActiveX, реализующий
функциональность кнопки или текстового
редактора - таких элементов управления, в том
числе выполненных в виде ActiveX, на рынке готовых
компонентов более чем достаточно. Нет смысла
также создавать ActiveX, если он будет
использоваться только в C++Builder - в этом случае
проще создать VCL-компонент, который будет
работать в использующем его приложении
значительно быстрее, чем аналогичный ActiveX. Но
создание элемента управления, реализующего, к
примеру, часть автоматизированного рабочего
места какой-либо категории сотрудников Вашего
предприятия может в ряде случаев оказаться
весьма полезным, особенно в следующих двух
случаях. Первый случай - использование на
предприятии различных средств разработки,
например, C++Builder и Visual Basic; в этом случае
разработчик, использующий Visual Basic, может
встраивать в свои приложения ActiveX, созданный
другим разработчиком и реализующий какую-либо
функциональность, используемую несколькими
различными автоматизированными рабочими
местами. Второй случай - широкое использование
Internet или intranet при автоматизации предприятия. В
этом случае ActiveX, реализующий подобную
функциональность, может быть встроен в
HTML-страницу и отображен в web-броузере. Такой
подход существенно облегчает решение проблемы
обновления версий автоматизированных рабочих
мест, так как вместо установки новых версий на
рабочих станциях достаточно заменить один
экземпляр ActiveX, хранящийся на web-сервере. Наиболее
ярким примером такого подхода может быть
выполненный в виде ActiveX "тонкий" клиент,
получающий данные от удаленного сервера
приложений, являющегося, в свою очередь, клиентом
серверной СУБД.
Такой набор преимуществ сделал эту
технологию за последние два года весьма
популярной, и именно поэтому многие современные
средства разработки, такие, как Delphi или С++Builder,
позволяют создавать элементы управления ActiveX.
Эти средства обычно имеют встроенные механизмы
поддержки спецификации ActiveX с помощью
автоматической генерации соответствующего кода
(хотя, конечно, не возбраняется писать подобный
код вручную).
Спецификация ActiveX представляет собой
набор правил (а именно описание стандартных
интерфейсов), с помощью которых следует
создавать такие элементы управления. Отметим,
что текущая версия этой спецификации учитывает
возможность использования в качестве контейнера
web-броузеров и необходимость загрузки элементов
ActiveX с удаленных web-серверов с их автоматической
регистрацией.
Как было сказано выше, C++Builder 3
позволяет создавать элементы управления ActiveX на
основе VCL-компонентов. Для этой цели используется
библиотека Microsoft ATL (Active Template Library), являющаяся на
сегодняшний день индустриальным стандартом и
позволяющая создавать элементы ActiveX,
представляющие собой скомпилированный код и не
требующие дополнительных run-time-библиотек для их
выполнения. Процесс создания такого элемента
управления весьма прост.
Для создания элемента управления ActiveX
следует выбрать из репозитария объектов
страницу ActiveX и далее - элемент ActiveX Control.
Далее следует заполнить появившуюся
диалоговую панель:
Рис.1. Выбор имени ActiveX, имен модулей и
базового VCL-класса
Следует выбрать VCL-компонент, на основе
которого будет создан элемент ActiveX. В качестве
примера выберем TCalendar.
Отметим, что при выборе опции Include
Design-Time Licence автоматически будет сгенерирован
файл с расширением *.lic, без которого данный ActiveX
нельзя будет использовать ни в каких средствах
разработки, но можно поставлять с готовыми
приложениями. Использование такого файла бывает
удобно в случае, когда ActiveX поставляется
бесплатно его автором в составе готового
продукта, но требует отдельного лицензирования
при встраивании его другими пользователями в
свои разработки.
В результате работы ActiveX Control Wizard будут
созданы несколько модулей, сгенерирован
уникальный идентификатор (GUID) будущего ActiveX, а
также соответствующая библиотека типов.
Рис.2. Проект библиотеки ActiveX в С++Builder
Библиотека типов содержит сведения о
свойствах, событиях и методах компонента ActiveX,
унаследованных от исходного VCL-компонента.
Рис.3. Библиотека типов созданного
элемента ActiveX
В коде, связанном с реализацией ActiveX,
можно найти описание этих свойств и методов.
Далее следует сохранить и
скомпилировать проект и зарегистрировать
элемент ActiveX в реестре. Это делается с помощью
выбора пункта меню Run/Register ActiveX Server.
После этого можно протестировать
созданный ActiveX-компонент, открыв его, например, в
Visual Basic. Отметим, что последние версии именно
этого средства разработки широко используют
элементы управления ActiveX в качестве составных
частей создаваемых с их помощью приложений;
фактически приложения Visual Basic собраны целиком из
ActiveX-компонентов. Более того, спецификация ActiveX
создана с учетом того, что в первую очередь Visual
Basic и Visual C++ (и лишь затем остальные средства
разработки) могут быть контейнерами для этих
элементов управления. Поэтому тестирование
поведения ActiveX в VisualBasic может более или менее
гарантировать, что в других средствах разработки
этот управляющий элемент будет вести себя точно
так же.
В случае отсутствия Visual Basic можно
воспользоваться и более широко распространенным
Visual Basic for Applications. С этой целью можно запустить
Microsoft Word 97, создать новый документ и выбрать на
панели инструментов кнопку "Редактор Visual
Basic". Далее следует выбрать в окне "Project"
имя вновь созданного документа, щелкнуть по нему
правой кнопкой мыши и из полученного
контекстного меню выбрать опцию
"Вставить/UserForm". На экране появится редактор
форм Visual Basic и панель элементов. Далее нужно
щелкнуть правой клавишей мыши по панели
элементов и выбрать из контекстного меню опцию
"Дополнительные элементы". Теперь следует
из появившегося списка всех зарегистрированных
элементов управления ActiveX выбрать нужный, и он
автоматически окажется на панели элементов Visual
Basic (можно поместить его на единственную
имеющуюся страницу управляющих элементов или
создать свою, выбрав опцию "Создать
страницу" из контекстного меню ярлычков
блокнота, расположенного на панели элементов).
После этого можно поместить наш ActiveX на
форму и попытаться изменить какие-либо его
свойства, используя для этой цели окно
"Свойства".
Рис.4. Тестирование ActiveX в Visual Basic
И, наконец, можно вернуться в
редактируемый документ, поместить на него
кнопку, дважды щелкнуть по ней и в окне редактора
кода создать процедуру, показывающую созданную
форму, вписав в сгенерированный код строку
UserForm1.Show :
Private Sub CommandButton1_Click()
UserForm1.Show
End Sub
Теперь можно нажать на панели
инструментов "Visual Basic" кнопку "Выход из
режима конструктора". После этого нажатие на
созданную в теле документа кнопку приведет к
появлению диалоговой панели с созданным нами
элементом управления.
Можно было бы, конечно, протестировать
поведение созданного ActiveX, установив его в
палитру компонентов Delphi или C++Builder,, но это не
самый лучший способ тестирования - ведь в основе
создания нашего ActiveX лежит та же самая библиотека
VCL, что и в основе создаваемого приложения для
тестирования ActiveX. Использование для этой цели
любого не имеющего отношения к VCL средства
разработки, способного использовать элементы
управления ActiveX в создаваемых приложениях, более
оправдано. При этом следует заметить, что Visual Basic
for Applications представляет собой наиболее часто
встречающееся средство разработки такого
класса, так как входит в состав самого
популярного в нашей стране офисного пакета.
Так как элементы управления ActiveX могут
быть использованы в средствах разработки,
нередко они обладают набором страниц свойств,
позволяющим пользователям менять те или иные
свойства этого элемента управления.
Для создания страницы свойств выберем
из репозитария объектов страницу ActiveX и элемент
Property Page. В результате получим форму, на которой
можно размещать интерфейсные элементы.
Создадим страницу для редактирования
свойств CalendarDate и GridLineWidth. Для этого разместим на
вновь созданной форме два компонента TStaticText и два
компонента TEdit.
Рис.5. Страница свойств на этапе
проектирования
В созданной форме имеются
сгенерированные прототипы обработчиков событий
UpdatePropertyPage и UpdateObject. Добавим в них
соответствующий код:
void __fastcall Tpp2f::UpdatePropertyPage(void)
{
Edit1->Text=OleObject.OlePropertyGet("CalendarDate");
Edit2->Text=OleObject.OlePropertyGet("GridLineWidth");
}
//-----------------------------------------------
void __fastcall Tpp2f::UpdateObject(void)
{
OleObject.OlePropertySet("CalendarDate",Variant(Edit1->Text));
OleObject.OlePropertySet("GridLineWidth",Variant(Edit2->Text));
}
Далее следует создать ссылку на
странице свойств в модуле, описывающем
реализацию элемента ActiveX. С этой целью следует
модифицировать h-файл .Модификация кода
заключается во вставке строки, указывающей на
необходимость регистрации страницы свойств:
BEGIN_PROPERTY_MAP(TCCX2Impl)
PROP_PAGE(CLSID_pp2f)
END_PROPERTY_MAP()
Следует также включить ссылку на h-файл
страницы свойств в h-файл реализации ActiveX.
Далее следует заново скомпилировать
библиотеку ActiveX и зарегистрировать ее.
Если теперь в среде разработки Visual Basic
поместить на пользовательскую форму наш ActiveX и
выбрать страницу свойств "Специальные",
получим созданную нами страницу:
Рис.6. Страница свойств на этапе
тестирования ActiveX
При изменении значений в компонентах
TEdit можно убедиться, что изменяются и
соответствующие свойства элемента ActiveX.
Рис.7. Результат использования
страницы свойств
Активная форма - это элемент
управления ActiveX, содержащий несколько
VCL-компонентов. Возможность создания таких
элементов управления позволяет существенно
расширить круг доступных для элементов ActiveX
функциональных возможностей. Создание такого
ActiveX происходит примерно так же, как и создание
обычного приложения.
Попробуем создать простейший пример
такого элемента управления. Для его создания
следует выбрать со страницы ActiveX репозитария
объект ActiveForm, ответить на вопросы об имени
компонента, после чего в дизайнере форм получим
пустую форму - заготовку будущего ActiveX. Добавим на
эту форму компоненты TCheckBox, TButton, TImage и TOpenPictureDialog.
Рис.8. Активная форма на этапе
проектирования
Создадим обработчики событий, связанных с TCheckBox
и TButton:
void __fastcall TActiveFormX::Button1Click(TObject *Sender)
{
if (OpenPictureDialog1->Execute())
Image1->Picture->LoadFromFile(OpenPictureDialog1->FileName);
}
//---------------------------------------------------------------------------
void __fastcall TActiveFormX::CheckBox1Click(TObject *Sender)
{
Image1->Stretch=CheckBox1->Checked;
}
Теперь можно скомпилировать
приложение, зарегистрировать созданный ActiveX и
протестировать его указанным выше способом.
Рис.9. Тестирование активной формы в
Visual Basic
Можно также протестировать созданный
ActiveX c помощью отображения его в Internet Explorer. Для
этой цели можно выбрать пункт меню Project/Web Deployment
Options и на странице Project в полях Target dir, Target URL, HTML dir
этого диалога указать имя какого-нибудь
локального каталога.
Затем можно выбрать опцию Project/Web Deploy и
по окончании работы Web Deployment Wizard открыть в Internet
Explorer автоматически сгенерированную С++Builder
html-страницу c именем, совпадающим с именем
созданного проекта:
Рис.10. Тестирование активной формы в
Internet Explorer
Отметим, что для успешного отображения
ActiveX в броузере требуется Microsoft Internet Explorer версии
3.0 и выше, при этом настройки уровня безопасности
должны позволять запуск активного содержимого,
расположенного в Intranet-зоне. Если в качестве
броузера используется Netscape Navigator, он должен быть
оснащен модулем расширения (plug-in), позволяющим
интерпретировать тег <OBJECT> языка HTML как
элемент управления ActiveX (естественно, такая
возможность существует только для версий Navigator,
выполняющихся под управлением 32-разрядных
версий Windows). Отметим также, что сгенерированную
автоматически страницу можно в дальнейшем
отредактировать с помощью любого html-редактора
(или даже любого текстового редактора).
При поставке ActiveX через Web процедура
аналогична описанной, но вместо локальных
каталогов в строке URL следует указать Internet-адрес
Web-сервера:
Рис.11. Настройка опций поставки ActiveX
через Internet
Помимо этого, следует обратить
внимание на дополнительные "пакеты" или
другие файлы, которые следует включить в
поставку, если опции проекта таковы, что требуют
использования каких-либо дополнительных
библиотек.. Разделение ActiveX на несколько файлов и
выделение отдельных пакетов может быть
использовано для того, чтобы уменьшить в целом
время загрузки ActiveX через Internet, например, в случае
предстоящей необходимости обновления версии
ActiveX или при поставке нескольких разных ActiveX - в
этом случае часть "пакетов" может быть
установлена один раз, а далее производится
поставка лишь небольшой содержательной части
элемента ActiveX. Впрочем, не возбраняется создавать
ActiveX и в виде одного файла. Отметим также, что при
выборе опции Include CAB File compression можно собрать
используемые файлы в один файл с расширением *.cab,
фактически представляющий собой архив, что также
уменьшает примерно в два раза время загрузки
файлов через Internet.
Следует отметить, что в активных
формах можно использовать практически все
компоненты C++Builder, кроме TMainMenu. Возможна также
динамическая генерация дополнительных форм на
этапе выполнения, при этом дополнительные формы
уже не будут содержаться в контейнере, а будут
представлять собой обычные формы Windows (и,
естественно, могут содержать в том числе и TMainMenu).
В заключение отметим, что, редактируя
библиотеку типов, можно к созданным ActiveX
добавлять свойства и методы и затем описывать их
реализацию в соответствующем модуле. Более
подробно о библиотеках типов, их назначении,
создании, редактировании будет рассказано в
последующих статьях данного цикла.
| 
