Учебное пособие по языкам C~.
Вам проще будет найти нужное, если Вы обратитесь к Оглавлению
4.2.1.Типы компонент
Каждая из компонент представляет собой законченную конструкцию,
содержащую свойства, методы и события.
Стандартные компоненты VCL инкапсулируют поведение типовых
элементов управления операционной системы Windows, как TButton, TListbox и
TEdit. В основном они расположены на вкладках Standard и Win95 Палитры
компонент.
В отличие от стандартных компонент, оригинальные компоненты
представляют собой элементы управления, у которых нет ни метода для
собственного отображения, ни заранее определенного поведения (Tpanel,
TstringGrid Рё РґСЂ.).
Графические компоненты представляют собой видимые элементы
управления, которые не могут принять фокус ввода, т.к. не являются оконными
(TImage, Tshape Рё РґСЂ.).
Невидимые компоненты не появляются на форме в виде каких-либо
элементов управления. Поведение невидимых компонент определяется на этапе
проектирования, путем инкапсуляции нужных свойств объекта (TOpenDialog,
Ttimer Рё РґСЂ.).
4.2.2. Рерархия классов VCL
Расположенная ниже схема показывает ключевые классы в иерархической
структуре, от которых произведены все компоненты VCL.
TObject -> … -> TComponent -> TGraphicControl -> …
|
| -> TWinControl -> …
TObject является базовым классом для всех порождаемых классов, а
TComponent является базовым классом для всех порождаемых компонент.
Невидимые компоненты произведены от класса TComponent. Основные
графические компоненты - от класса TGraphlcControl.
Компоненты стандартного управления произведены непосредственно от
класса TWinControl, а оригинальные компоненты - косвенно от класса
TCustornControl, восходящего к TWinControl. Ниже приведена схема,
продолжающая иерархическую структурную схему компонентных классов VCL.
TGraphicControl TWinControl
*Tbevel *TButtonControl
*TCustomLabel o Tbutton
ВЂў TDBText +TBitBtn
ВЂў Tlabel o TCustomCheckBox
*Timage +TCheckBox
*TPaintBox +TDBCheckBox
*TShape o TRadioButton
*TSpeedButton *TCustomComboBox
ВЂў TComboButton o TComboBox
ВЂў TNavButton o TDBComboBox
ВЂў TDriveComboBox
ВЂў TFilterComboBox
*TCustomControl
ВЂў TCustomGrid
+ TCunstomDBGrid
+ TDBGrid
+ TDBLookupList
+ TpopupGrid
+ TCustomOutline
+TOutline
+ TDrawGrid
+ TStringGrid
ВЂў TCunstomGroupBox
+ TCunstomRadioGroup
+TDBRadioGroup
+TRadioGroup
+TGroupBox
ВЂў TCunstomPanel
+TDBNavigator
+TPanel
ВЂў TDBImage
ВЂў TDBLookupControl
+TDBLookupComboBox
+ TDBLookupListBox
+ TPopupDataList
ВЂў THeader
ВЂў THintWindow
ВЂў TMediaPlayer
ВЂў TNotebook
ВЂў TOleContainer
ВЂў TPage
ВЂў Tscroller
ВЂў TTabSet
* TCustomEdit
ВЂў TCustomMaskEdit
+ TDBEdit
+ TInplaceEdit
+ TMaskEdit
ВЂў TCustomMemo
+ TCustomRichEdit
+ TRichEdit
+ TDBMemo
+ TMemo
ВЂў TDBLookupCombo
ВЂў TEdit
* TCustomHotKey
ВЂў THotKey
* TCustomListBox
ВЂў TDBListBox
ВЂў TDirectoryListBox
ВЂў TFileListBox
ВЂў TListBox
* TCustomListView
O TListView
*TCustomTabControl
ВЂў TPageControl
ВЂў TTabbedNotebook
ВЂў TTabControl
*TCustomTreeView
ВЂў TTreeView
* TCustomUpDown
ВЂў TUpDown
* TDBCtrlGrid
* TDBCtrlPanel
* THeaderControl
* TOleControl
* TProgressBar
* TScrollBar
* TScrollingWinControl
ВЂў TForm
+ TDesignWindow
+ TInputRedDialog
+ TLoginDialog
+ TPasswordDialog
ВЂў TScrollBox
* TStatusBar
* TTabPage
* TTabSheet
* TTrackBar
4.3. Структуры файлов в C++ Builder.
Для каждого приложения C++ Builder создается один файл проекта, один
Make-файл один файл модуля и один файл ресурсов.
Первоначально файлу проекта присваивается по умолчанию имя Project1.cpp
Если в процессе разработки приложения добавляются формы и модули C++
Builder обновляет файл проекта.
Make-файл(по умолчанию Project1.mak) - это текстовый файл, содержащий
макросы, директивы и инструкции по компиляции и сборке проекта.
Модули являются основой создания библиотек и приложений в C++ Builder.
Модуль содержит исходный текст на языке C++ и первоначально представляет
собой файл с расширением Unit1.cpp.
Файл с расширением h генерируется при создании нового модуля. В нем
содержится информация о данных и функциях, которые можно использовать в
модуле, т.е.- в h-файле содержится интерфейс, а в самом модуле - реализация.
Форма является одним из важнейших элементов приложения C++ Builder.
Процесс редактирования формы происходит при добавлении к форме
компонентов, изменении их свойств, создании обработчиков событий (по
умолчанию файл формы или файл ресурсов имеет имя Unit1.dfm).
Когда к проекту добавляется новая форма, создаются 3 отдельных файла:
ВЂў файл модуля (.СЃСЂСЂ) - содержит исходный РєРѕРґ, связанный СЃ формой;
ВЂў h-файл(.h) - содержит описание класса формы, С‚. Рµ. описание содержащихся РЅР°
форме компонентов и обработчиков событий;
ВЂў файл формы (.dfm) - двоичный файл, содержащий сведения Рѕ доступных РІ
инспекторе объектов свойствах компонентов, содержащихся в форме.
В процессе трансляции создаются дополнительные файлы с расширениями
Ilc, ild, ilf, ils, obj, которые можно удалить.
4.4.Визуальные компоненты (VCL).
VCL в C++Builder находятся на нескольких страницах.
Страница Standard состоит из следующих визуальных компонент.
1.Компонент MainMenu позволяет создавать линейку меню проектируемой формы
и выпадающее меню (компонент невизуальный).
2.Компонент PopupMenu позволяет создавать всплывающее меню при нажатии
правой кнопки мыши (компонент невизуальный).
3.Компонент Label используется для создания надписей.
4.Компонент Edit используется для ввода или отображения однострочных текстов.
5.Компонент Memo используется для ввода или отображения многострочных
текстов.
6.Компонент Button используется для создания кнопок, котрыми можно выбирать
те или иные команды.
7.Компонент Checkbox позволяет выбирать или выключать те или иные опции.
8.Компонент RadioButton предлагает набор альтернатив из которых выбирается
РѕРґРЅР°.
9.Компонент ListBox представляет стандартное окно списка, позволяющее
выбирать те или иные пункты из списка.
10.Компонент ComboBox объединяет функции ListBox и Edit.Он позволяет ввести
текст или выбрать из списка.
11.Компонент ScrollBar -это стандартная линейка прокрутки.
12.Компонент GroupBox объединяет группу связанных органов управления
(контрольные индикаторы, радиокнопки).
13.Компонент RadioGroup -комбинация GroupBox с набором RadioButton. Он
позволяет создавать группы радикнопок.
14.Компонент Panel испорльзуется для группировки органов управления.
Страница Win95 включает следующие компоненты:
- TabControl - используется для создания закладок, которые можно выбирать;
- PageControl - создает страницы, управляемые закладками;
- TreeView - позволяет просматривать иерархические структуры данных;
- ListView - отображает списки в колонках;
- ImageList - позволяет работать со списками изображений (невизуальный
компонент);
- Header - создает составные перемещаемые заголовки;
- Richedit - создает окно редактирования (позволяет выбирать цвет, шрифт и т.д.);
- StatusBar - отображает информацию о состоянии программы;
- TrackBar - создает ползунок;
- ProgressBar - используется для отображения хода процесса;
- UpDown - создает кнопку-счетчик;
- HotKey - создает поддержку "горячих клавиш";
- AnimatedSymbol – создает простейшую аннимацию.
Страница Additional состоит из следующих компонент:
- BitBtn -используется для создания кнопок, на которых расположен рисунок;
- SpeedButton - применяется для создания линеек инструментов вместе с
компонентом Panel;
- MaskEdit - используется для ввода символов в соответствии с шаблоном;
- StringGrid - применяется для отображения текстовой информации в строках и
столбцах;
- DrawGrid - применяется для отображения нетекстовой информации в строках и
столбцах;
- Image - используется для отображения графики;
- Shape - используется для рисования геометрических фигур;
- Bevel - используется для рисования объемного прямоугольника;
- ScrollBar - применяется для создания зон отображения с прокруткой;
- Scroller - применяется для создания зон отображения с горизонтальной
прокруткой;
Компоненты страницы Data Acces используются для связи и передачи
информации между приложениями и базами данных. В работе не
рассматриваются.
Компоненты страницы Data Controls используются для организации доступа
к данным. В работе не рассматриваются.
Страница Win3.1 содержит компоненты, ориентированные на Windows 3.1.
В работе не рассматриваются.
Страница Internet содержит компоненты, ориентированные на работу с Internet.
- TFTP – компонент, осуществляющий перенос данных между локальным и
удаленным компьютером с рлмощью протокола FTP;
- THTML – предназначен для отображения документов формата HTML;
- THTTP – позволяет получать документы с помощью протокола HTTP;
- TNNTP – позволяет осуществлять соединение в режиме on-line с серверами
новостей по протоколу NNTP;
- TPOP – позволяет приложению обмениваться данными с почтовыми
серверами с использованием протокола POP3;
- TSMTP – поддерживает обмен сообщениями с почтовыми серверами на основе
протокола SMTP;
- TTCP – осуществляет сетевое соединение и обмен данными по протоколу TCP;
- TUDP – осуществляет соединение и обмен данными по протоколу UDP.
Компоненты страницы Dialogs используются для создания различных окон
диалога(невизуальные компоненты);
- OpenDialog - для создания окон диалога "открыть файл";
- SaveDialog - для создания окон диалога "сохранить файл";
- FontDialog - для создания окон диалога "шрифты";
- ColorDialog - для создания окон диалога " цвет";
- PrintDialog - для создания окон диалога "печать";
- PrinterSetupDialog - для создания окон диалога "установки принтера";
- FindDialog - для создания окон диалога "найти";
- ReplaceDialog - для создания окон диалога "заменить".
Страница System содержит компоненты, позволяющие включить в
программу системные средства:
- Timer - используется для запуска процедур, функций и т.д. в заданное время
(невизуальный компонент);
- PaintBox - создает область, в которой можно рисовать;
- FileListBox - создает окно, в котором отображается список файлов из выбранного
каталога;
- DirectoryListBox - отображает каталоги выбранного диска;
- DriveComboBox - позволяет отображать и выбирать диски;
- FilterComboBox - позволяет создавать окно для отображения фильтров файлов;
- MediaPlayer - позволяет проигрывать звуковые и видеофайлы;
- OLEContainer -создает область для объекта OLE;
- DDEClientConv - используется для диалога с DDE сервером (невизуальный
компонент);
- DDEClientItem - используется для спецификации данных, передаваемых DDE
серверу (невизуальный компонент);
- DDEServerConv - используется для DDE сервером для диалога с DDE с клиентом
(компонент невизуальный);
- DDEServerItem - используется для спецификации данных сервера (компонент
невизуальный).
QReport -ВК используются для генерации отчетов. В работе не
рассматривается.
Activeve X- OCX-компоненты, неявляющиеся частью C++Builder.
- ChartFX - используется для построения диаграмм;
- VCFirstImpression -реализует трехмерную графику;
- VCFormulaOne - используется для работы с электронными таблицами;
- VCSpeller - средство проверки орфографии;
- GraphicsServer - средство для работы с графикой;
На этой странице могут быть расположены свободно распространяемые
компоненты для разработки тех или иных приложений (например, просмотрщик
файлов виртуальной реальности VRML и др.).
Страница Samples содержит компоненты, разработанные пользователями -
примеры VCL.
- Gauge - создает индикатор хода процесса;
- SpinButton - позволяет создавать кнопки- счетчики;
- SpinEdit - создает окно редактирования с кнопкой-счетчиком;
- MCxSpriteBgr - панель, на которой можно создавать спрайты;
- MCxStrite - позволяет создавать спрайты.
Компоненты VCL можно разрабатывать самостоятельно, поэтому
существует большое количество страниц и компонентов. Вот некоторые из
страниц.
JG - дополнительные компоненты
- Banner - позволет создавать в окне движущийся текст или изображение;
- SizeTask - позволяет устанавливать максимальный размер формы
MyStuff - дополнительные компоненты
- Animated - проигрывает bmp-файлы;
- AutoLed - кнопка меняет цвет;
- MMLabel - метка меняет цвет;
4.5. Программы, управление событиями, исключения.
Рассмотрим простейшую программу - вывод строки по нажатию кнопки.
Создадим новый проект или воспользуемся пустым проектом, который
предоставляется С++ Builder в момент его запуска.
На пустую форму положим два компонента: строку редактирования Edit и
РєРЅРѕРїРєСѓ Button.
Для этого щелкнем мышью на пиктограмме требуемого элемента в палитре,
а затем поставим его в нужное место формы.
Далее щелкнем на свойстве Text компоненты Edit и удалим текст, присвоенный
строке системой.
Рзменим свойство Caption РєРЅРѕРїРєРё Button, введя текст "Нажми". Форма
готова. Осталось написать исходный текст для обработки нажатия кнопки. Для
этого надо выделить кнопку Button, переключить окно инспектора объекта в
режим создания обработчиков событий и дважды щелкнуть на событии OnClick.
Откроется окно редактирования кода, в котором появился пустой
обработчик события. Добавим в него строку исходного текста:
Edit1-> Text = "Привет от Borland C++!";
После этого командой Run-Run начать компиляцию и выполнение
программы.
Нажмем кнопку "Нажми", и программа поприветствует нас. В отличии от
DOS, в которой программа получает управление при запуске, и выполняется от
начала до конца, в Windows 95 программа управляется событиями. При
управлении событиями программа не делает ничего до тех пор, пока не
происходит событие - нажатие клавиши мыши, нажатие клавиши клавиатуры и
С‚.Рґ.
Существуют различные виды событий и их обработка. На примерах
рассмотрим некоторые из них.
1.Обработчик, откликающийся на событие.
Рассмотрим пример - обработка нажатия клавиши мыши и вывод координат
курсора мыши.
1.Запускаем C++ Builder.
2.В инспекторе объектов выбираем страницу Events.
3.Справа от метки события OnMouseDown (нажатие клавиши мыши) дважды
щелкаем мышью.
4.Появляется программный код процедуры - обработчика событий.
5.Р’РІРѕРґРёРј РєРѕРґ.
Form1->Canvas->TextOut(X,Y,"Координата "+IntToStr(X)+
","+ IntToStr(Y));
6. Запускаем программу на выполнение.
При нажатии клавиши мыши активизируется обработчик событий
OnMouseDown,которому передаются параметры - координаты X и Y.
Таким образом в данном случаее мы рассмотрели вариант, когда
обработчику событий передана некоторая информация - параметры X и Y.
2.Обрабочик событий, передающий информацию, вызываемой про-
цедуре.
Возможен вариант, когда обработчик событий передает информацию
функции, которая его вызвала. Рассмотрим пример, когда в окне редактирования
все буквы преобразуются в заглавные.
1.Запускаем C++ Builder.
2.Выводим на форму из палитры компонент элемент Edit.
3.В разделе инспектора объектов Events вправо от OnKeyPress два раза щелкаем
мышью, получаем фрагмент кода.
4.Набираем код.
Key= AnsiUpperCase(Key)[1];
5.Запускаем на выполнение. Любая введеная буква печатается как заглавная.
В данном примере переменная Key, содержащая значение нажатой клавиши
указана как указатель на адрес символа - в этом случае любые изменения,
сделанные в переменной передаются обратно в вызывающую функцию. Функция
AnsiUpperCase(Key) преобразует символ в заглавный.
Кроме этого существуют обработчики событий, ориентированный на
обработку вспомогательных операций в сложной программе.
Рсключения. Для обработки исключений(ошибок) РІ C++ Builder имеются
специальные средства. В частности, при возникновении ошибки возможна
передача управления блоку, который ориентирован на обработку этой ошибки.
Для этой цели используется блок try ... except() следующего формата:
Try {
исполняемый код
}
Except (проверяемая пеpеменная)
{
код, исполняемый при ошибке
}
4.6.Стратегия отладки Windows-программ.
Ошибки в программе могут быть самыми разнообразными. Но для Windows-
приложений характерны следующие :
- вызов неверной функции, когда вместо одной функции по ошибке вызывается
другая;
- вызовам Windows API передаются неправильные аргументы;
- задание неверных параметров цикла;
- ошибка в условии операторов if, switch, while и т.д., приводящая к
неправильному ветвлению;
- возникновение не предусмотренного программистом варианта реакции системы.
Для отладки программ обычно используется несколько стандартных операций:
* установка точек прерывания (breakpoints);
* просмотр содержимого переменных и участков памяти;
* подстановка ложных данных для моделирования ситуации "что - если";
* ложные вызовы.
DOS-программу можно выполнять пошагово, перебираясь от одной строки
исходного текста к другой В Windows же это нереально. Нужно поставить точку
прерывания на интересующем вас участке программы и запустить ее на
выполнение командой Run - Run. Достигнув точки прерывания, программа
приостановит свое выполнение, давая возможность программисту приступить к
отладочным действиям.
В программах на C++ Builder, точки прерывания удобнее всего ставить
внутри обработчиков событий.
Простейший способ установить точку прерывания - нажать на клавишу
. При этом выбранная для остановки строка выделяется красной полосой, на
левом краю строчки появляется маленький значок "Stop".
Повторное нажатие на отменяет уже имеющуюся точку прерывания.
Другой способ установить точку прерывания - щелкнуть мышью на левом
краю окна редактирования.
Когда ошибочный обработчик найден, нужно приступать к уточнению места
ошибки. Для этого Можно выполнять программу шаг за шагом командой Trace
Into ( клавиша ) или Step Over (клавиша ), проверяя, как изменяются
данные программы.
После того как программа отлажена, необходимо перетранслировать ее, установив
в главном меню в разделе Options->C++ опцию Release.
4.7.Рспользование компонент VCL РІ разработке программ.
Рспользование меню.
Страница Standard содержит наиболее часто используемые компоненты – к ним
относятся компоненты MainMenu и PopupMenu.
Каждому пользователю Windows, раскрывающееся меню представляет
собой подробный список таких команд, как Open или Exit. В большинстве
приложений в главном меню перечислены имена одного или нескольких
раскрывающихся подменю.
Главное меню (компонент MainMenu). Рспользуется для создания главного
меню приложения, которое всегда отображается под заголовком окна.
Всплывающее меню (компонент PopupMenu). Рспользуется для создания
всплывающих меню, которые появляются при при щелчке правой кнопкой мыши,
когда указатель, мыши находится внутри клиентной области окна.
Для того чтобы построить главное меню программы, необходимо выполнить
следующее:
1. На форму главного окна поместите объект MainMenu.
По умолчанию в C++ Builder. ему присваивается имя MainMenu1.
2. Установите свойство формы Menu равным имени объекта MainMenu.
3. Дважды щелкните на объекте MainMenu1 и используйте Menu Designer для
ввода команд меню.
Для того чтобы создать всплывающее меню, которое появляется при щелчке
правой кнопкой мыши, выполните следующее:
1. Поместите на форму объект РорupМеnu. По умолчанию в C++ Builder ему
присваивается имя PopupMenu1.
2. Присвойте PopupMenu1 свойству формы PopupMenu.
3. Дважды щелкните на объекте PopupMenu1 и используйте Menu Designer для
ввода команд меню.
Рассмотрим пример – разработаем простейший редактор текста.
Создайте файл с именем 1.txt в каталоге, в котором будет храниться пример
и запишите в него какой-либо текст. Запустите C++ Builder.
1.Поместите на форму компонент Memo. Согласно рисунка измените размеры.
В инспекторе объектов установите ScrollBars в позицию ssVertical (вертикальная
полоса прокрутки). На поле Memo вы видите текст Memo1. Для того чтобы он
исчезал при запуске программы щелкните мышью по форме и напишите между
{и}; команду очистки окна Memo1:
Memo1->Clear();
2. Поместите на форму кнопку Button. Свойство Caption в инспекторе объектов
измените на Close. Щелкните на кнопке. и напишите код:
Close(); - по этой команде программа прекращает работу.
3. Поместите на форму компоненты MainMenu и PopupMenu.
Щелкните по форме и напишите в свойствах MainMenu- MainMenu1 и
PopupMenu - PopupMenu1 соответственно.
4.Щелкните два раза на компоненте MainMenu. Появляется конструктор меню. В
инспекторе объектов свойство Сaption измените на &File(&- быстрая клавиша
ALT+F). Нажмите клавишу Enter. Далее в конструкторе меню щелкните мышью
под командой File и опять свойство Caption измените на &Open, ниже опять
появляется синий квадратик напишите свойство Caption &Save, а затем на
следующем пункте меню измените Caption на E&xit.
5.Щелкните мыщью рядом с &File (правее) и запишите в Caption &Help.
Таким образом все пункты меню мы записали и они должны появитсяна форме.
6.Начнем ставить в соответствие событиям (пунктам меню) программный код.
Щелкните мышью на команде File, поставте курсор на Open и щелкните мышью.
между командами { и } запишите код:
Memo1->Lines->LoadFromFile("1.txt");
По этой команде текст из файла 1.txt загрузится в окно Memo. Свойство
Lines объекта Memo это объект типа строка символов, которая отображается в
окне. Метод LoadFromFile позволяет загрузить файл в Memo.
Перед нами редактор текста - текст можно модифицировать, а затем
записать.
7.Щелкните мышью на команде File, поставте курсор на Save и щелкните мыщью.
между командами begin и end; запишите код:
Memo1->Lines->SaveToFile("1.txt");
По этой команде текст запишится в файл 1.txt.
8. Наиболее интерсные действия с командой Exit.
Стандартно можно было-бы щелкнуть мышью на команде Exit и записать
код Close();, но этот код у нас есть по нажатию клавиши Button программа
прекращает работу, поэтому мы делаем так:
8.1.В инспекторе объектов в выпадающем меню (в шапке) выбираем опцию Exit1.
8.2 Переходим в инспекторе объектов на страницу Events и щелкаем мышью в
поле события OnClick.
8.3.Выбираем Button1Click. То есть мы совмещаем события:
- нажатие клавиши(закрытие программы);
- выбор опции меню Exit.
9. В дизайнере меню заходи в раздел Help -щелкаем мышью и пишем код:
Canvas->TextOut(10,10,"Помощи пока нет!");
10. Добавляем всплывающее меню. Щелкаем дважды на компоненте
PopupMenu.
11.Появляется дизайнер меню. Первую опцию меню указываем в Caption - &Open,
следующую &Save и последнюю E&xit(также как в MainMenu).
12.Щелкаем на опции Open.В выпадающем меню инспектора объектов
выбираем опцию Open2. Переходим в инспекторе объектов на страницу на
страницу Event и щелкаем мышью в поле события OnClick. Находим Open1Click и
щелкаем мышью (теперь мы совместили событие открытие файла 1.txt в меню
MainMenu Рё PopupMenu);
Соответственно выбираем опцию &Save и совмещаем с событием Save1Click.
Далее совмещаем опцию Exit с событием Button1Click. Далее программу
запоминаем и транслируем. Программа будет выглядеть так:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::FormCreate(TObject *Sender)
{
Memo1->Clear();
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Open1Click(TObject *Sender)
{
Memo1->Lines->LoadFromFile("1.txt");
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Save1Click(TObject *Sender)
{
Memo1->Lines->SaveToFile("1.txt");
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Help1Click(TObject *Sender)
{
Canvas->TextOut(10,10,"Помощи пока нет!");
}
//---------------------------------------------------------------------------
Кнопки переключатели и выключатели.
Кнопки, переключатели и выключатели - это основа графического
пользовательского интерфейса, поэтому C++ Builder предоставляет целый "набор"
всевозможных кнопок, переключателей и выключателей. Кроме того, имеется
возможность объединять группы кнопок и использовать организующие
компоненты - фаски и панели.
Кнопка (компонент Button). Стандартный управляющий элемент
Windows.
Кнопка с растровым изображением (компонент BitBtn). Компонент BitBtn
работает также, как и компоненты Button, но отличаются от последних наличием
цветной пиктограммы, визуально представляющей действие кнопки.
Кнопка панели инструментов (компонент SpeedButton). Обычно эти компоненты
используются для создания панелей инструментов.
На кнопках BitBtn или SpeedButton отображается пиктограмма (glyph),
которая представляет собой растровое изображение Windows. Несмотря на то,
что размеры пиктограмм не ограничены, обычно применяется стандартный
размер - 16х16 пикселей при 16 цветах.
Свойство glyph компонента является объектом, имеющим тип TBitmap.
Пиктограммы содержат от одного до четырех отдельных блоков,
хранящихся в одном файле. эти блоки представляют различные состояния кнопки.
1. Состояние кнопки = ненажатое (обычное состояние).
2. Состояние кнопки = недоступное (отображение серым цветом; Enabled = false).
3. Состояние кнопки = нажатое (отображение смещенное и, возможно,
затемненное).
4. Состояние кнопки = фиксированное нажатое (только для кнопок панели
инструментов).
Пиктограммы можно назначать как при создании формы, так и во время
работы программы(например, для получения динамического визуального эффекта
либо для изменения вида кнопки в зависимости от внешних условий). Для того
чтобы пиктограмма загружалась во время работы, разместите объект BitBtn на
форме, щелкните на нем дважды и в обработчик события OnClick вставьте
следующие операторы:
BitBtn1->Glyph->LoadFromFile (“alarm.bmp");
Выключатель (компонент CheckBox). Рто также стандартный управляющий
элемент Windows, состоящий из метки и небольшого квадратика. Щелкнув на
нем, пользователь может включить или выключить параметр или режим,
описанный меткой.
Группа (компонент GroupBox). Данный компонент предназначен для логического
объединения множества переключателей и других объектов.
Фокус ввода пользователи могут перемещать между группами с помощью
клавиши . Затем, используя клавиши управления курсором, можно выбрать
один из управляющих элементов, объединенных в группу.
Переключатель (компонент RadioButton). На группу или панель можно поместить
несколько переключателей, но в большинстве случаев для создания наборов
переключателей гораздо удобнее использовать компонент RadioGroup. Кроме
того, наборы переключателей можно распологать непосредственно на форме.
Группа переключателей (компонент RadioGroup). Ртот компонент имеет РјРЅРѕРіРѕ
общего с группой, но он намного удобнее в использовании при создании наборов
переключателей. Для организации переключателей необходимо только указать
текст переключаемых параметров в свойстве Items группы переключателей.
Строка ввода с настройкой (компонент SpinEdit) - компонент, представляющий
собой кнопку настройки, объединенную со строкой ввода. Щелчки на кнопке
приводят к увеличению или уменьшению числа, находящегося в строке ввода.
Кроме того, пользователи могут вводить число непосредственно в самой строке
ввода, которая к ттому же распознает команды работы с буфером обмена
Windows.
Панель (компонент Panel). Данный компонент позволяет упорядочить
загроможденные информацией окна, а также является основой создания панелей
инструментов и строк состояния.
Фаска (компонент Bevel). Ртот чисто визуальный компонент выглядит РІ РѕРєРЅРµ как
прямоугольный выступ или углубление. Фаска также используется для создания
горизонтальных и вертикальных линий.
Рассмотри пример использования рассмотренных выше компонент.
Начнем разработку нового проекта.
Согласно рисунка поместим на верхнюю часть формы компонент Panel.
Свойству Caption присвоим “Демонстрация”. Далее на форму добавим
компонент Label Рё установим свойство Caption “Рмя”. РџРѕРґ метку добавим
компонент Edit. Рспользуя инспектор объектов удалим символы РёР· свойства Text
объекта Edit. Далее добавим компонент Memo.
В инспекторе объектов установим ScrollBars в позицию ssVertical
(вертикальная полоса прокрутки). Далее в инспекторе объектов двойным щелчком
откроем свойство Lines, удалим текст Memo1 и четыре раза нажмем клавишу
Enter(будем работать с четыремя строками).
Установим на форме компоненты RadioGroup, Scrollbar и ComboBox.
Дважды щелкнем на правее свойства Items и введем четыре строчки: серый,
голубой, желтый, красный. Дважды щелкнем по компоненте RadioGrouo и введем
РєРѕРґ:
If(RadioGroup1->ItemIndex==0){Form1->Color=clSilver;}
If(RadioGroup1->ItemIndex==1){Form1->Color=clBlue;}
If(RadioGroup1->ItemIndex==2){Form1->Color=clYellow;}
If(RadioGroup1->ItemIndex==3){Form1->Color=clRed;}
Ртот фрагмент РєРѕРґР° позволяет изменять цвет формы РІ зависимости РѕС‚
отмеченной кнопки.
Далее дважды щелкнем по компоненте Scrollbar и добавим код:
RadioGroup1->ItemIndex=ScrollBar1->Position;
Ртот фрагмент РєРѕРґР° позволяет изменять цвет формы РІ зависимости РѕС‚ положения
ползунка.
Поместим на форму копонент GroupBox и добавим две кнопки Button, две кнопки
BitBtn , две RadioButton и две Checkbox. Щелкнем по кнопке Button1 и введем код:
//Очистить содержимое Memo
Memo1->Clear();
//Скопировать в Memo текст, введенный в Edit
Memo1->Lines->Add(Edit1->Text);
//Скопировать в Memo текст из Combobox
Memo1->Lines->Add(ComboBox1->Text);
// Если нажата первая радиокнопка, то цвет Memo белый
If (RadioButton1->Checked) Memo1->Color=clWhite;
// Если нажата первая радиокнопка, то цвет Memo светло-голубой
If (RadioButton2->Checked) Memo1->Color=clAqua;
Щелкнем по кнопке Button2 и введем код:
Close(); //закончить работу
Щелкнем по кнопке BitBtn1 и введем код:
//если помечена кнопка Checkbox1, то размер шрифта на форме 12
// иначе размер шрифта 8
If (CheckBox1->State==cbChecked)
Font->Size=12;
Else
Font->Size=8;
//если помечена кнопка Checkbox2, то цвет шрифта на форме фиолетовый
// иначе цвет шрифта черный
If (CheckBox2->State==cbChecked)
Form1->Font->Color=clPurple;
Else
Form1->Font->Color=clBlack;
Щелкнем по кнопке BitBtn2 и введем код:
Form1->Hide();// свернуть форму с именем Form1
AddTab->Show();// показать форму с именем AddTab
Как работать с двумя формами рассмотрим дальше.
Вся программа будет выглядеть следующим образом:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::RadioGroup1Click(TObject *Sender)
{
If(RadioGroup1->ItemIndex==0){Form1->Color=clSilver;}
If(RadioGroup1->ItemIndex==1){Form1->Color=clBlue;}
If(RadioGroup1->ItemIndex==2){Form1->Color=clYellow;}
If(RadioGroup1->ItemIndex==3){Form1->Color=clRed;}
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::ScrollBar1Change(TObject *Sender)
{
RadioGroup1->ItemIndex=ScrollBar1->Position;
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
Memo1->Clear();
Memo1->Lines->Add(Edit1->Text);
Memo1->Lines->Add(ComboBox1->Text);
If (RadioButton1->Checked) Memo1->Color=clWhite;
If (RadioButton2->Checked) Memo1->Color=clAqua;
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button2Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::BitBtn1Click(TObject *Sender)
{
If (CheckBox1->State==cbChecked)
Font->Size=12;
Else
Font->Size=8;
If (CheckBox2->State==cbChecked)
Form1->Font->Color=clPurple;
Else
Form1->Font->Color=clBlack;
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::BitBtn2Click(TObject *Sender)
{
Form1->Hide();
AddTab->Show();
}
//---------------------------------------------------------------------------
Построим вторую страницу приложения. Добавим в разрабатываемый
проект вторую форму и дадим ей имя AddTab и сохраним под именем
AdditionalTab.pas.
Разместим визуальные компоненты на форме согласно рисунка.
Поместим на форму в левый нижний угол компонент Bevel. Поместим три кнопки
типа BitBtn в нижний левый угол формы на компонент Bevel.
Свойство Kind для BitBtn1 и BitBtn2 установим равным bkCustom, а для
BitBtn3 – равным bkClose.
Установим на кнопках для свойств Caption текст, соответствующий рисунку.
Для каждой из кнопок установим гравировку (glyph), используя готовые
гравировки, поставляемые в комплекте с языком или создавая свои с помощью
редактора Image Editor в меню инструментов Tools.
Добавляем код действия для кнопок:
BitBtn1:
Form1->Show();\\ показать форму Form1
AddTab->Hide();\\свернуть форму AddTab
BitBtn2:
ShowMessage("Пока НЕТ");\\следующей страницы пока нет
BitBtn3:
Form1->Close();//закрыть форму Form1
Для правильного закрытия приложения и освобождения ресурсов необходимо
добавить для события Close формы Form1 код:
Application->Terminate();\\освободить ресурсы
В левом верхнем углу формы разместим компонент Shape (укажем в свойстве
Shape значение stEllipse), компонент Panel и на нем две кнопки SpeedButton и
компонент Image, в который можно загрузить какое-либо изображение.
Кнопки SpeedButton могут находиться в состоянии: Up- верхнее, Disabled –
отключено, Down – нижнее, Stay Down – прижатое. Для каждого состояния
отображается соответствующий элемент гравировки. Для использования этих
состояний с помощью встроеннного графического редактора создается матрица
16С…64 точки. Рзображение будет иметь четыре квадратные Р·РѕРЅС‹.
Установим свойство NumGlups для Speedbutton1 равным 4, а свойство
GroupIndex равным 1.
Дважды по кнопки SpeedButton1 и пишем код:
If (SpeedButton1->Down==true)
{Image1->Visible=false;
Shape1->Brush->Color=clRed;
Код означает, что если нажата кнопка, то изображение Image1 исчезает, а
изображение фигуры Shape1 красного цвета.
Дважды щелкаем по кнопке SpeedButton2 и записываем код:
If (SpeedButton1->Down=true)
{Image1->VisibleColor=clLime;
Для SpeedButton1 используем свойство Hint (подсказка). В этом свойстве
хранится строка подсказки, которая появляется, когда курсор мыши находится над
кнопкой. ShowHint необходимо установить в true.
Добавим на форму компонент Label свойство Caption зададим Phone.
Под меткой установим компонент MaskEdit. Дважды щелкнем на свойстве
EditMask и запусти редактор маски ввода. Далее щелкнем на Phone и нажмем
клавишу OK. Компонент MasEdit будет настроен на прием телефонных номеров.
Поместим на форму компонент StringGrid и установим свойства: RowCount и
ColCount. Свойства FixedCols и FixedRows установим в 0.
Подберем размер сетки чтоб были видны девять ячеек. Добавим на форму
кнопку со свойством Caption Fill Grid. Дважды щелкнем на ней и наберем код:
Int x,y;
For (x=0; (xColCount-1);x++)
For ( y=0;(yRowCount-1);y++)
StringGrid1->Cells[x][y]=("Coord. "+
IntToStr(x)+"-"+IntToStr(y));
Далее поставим на форму панель с прокруткой ScrollBox и разместим на ней
компоненты:BitBtn со свойством Kind равным bkHelp. Добавим на ScrollBox Panel.
Дважды щелкаем на кнопке BitBtn4 и добавляем код:
ShowMessage(" Test ");
Компонент ScrollBox c размещенными на нем компонентами позволяет
продемострировать способности показвать фрагменты, которые не помещаются в
зоне использования.
Общий вид программного модуля AddTab:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit2.h"
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma link "Grids"
#pragma resource "*.dfm"
TAddTab *AddTab;
//---------------------------------------------------------------------------
__fastcall TAddTab::TAddTab(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::BitBtn1Click(TObject *Sender)
{
Form1->Show();
AddTab->Hide();
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::BitBtn3Click(TObject *Sender)
{
Form1->Close();
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::FormClose(TObject *Sender, TCloseAction &Action)
{
Application->Terminate();
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::SpeedButton1Click(TObject *Sender)
{
If (SpeedButton1->Down==true)
{Image1->Visible=false;
Shape1->Brush->Color=clRed;
}
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::SpeedButton2Click(TObject *Sender)
{
If (SpeedButton1->Down=true)
{Image1->VisibleColor=clLime;
}
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::Button1Click(TObject *Sender)
{
Int x,y;
For (x=0; (xColCount-1);x++)
For ( y=0;(yRowCount-1);y++)
StringGrid1->Cells[x][y]=("Coord. "+
IntToStr(x)+"-"+IntToStr(y));
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::BitBtn4Click(TObject *Sender)
{
ShowMessage(" Test ");
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::BitBtn2Click(TObject *Sender)
{
ShowMessage("Пока НЕТ");
}
//---------------------------------------------------------------------------
Void __fastcall TAddTab::MaskEdit1Change(TObject *Sender)
{
}
//---------------------------------------------------------------------------
Рассмотрим еще один проект. Поместим на форму согласно рисунка
компоненты:
TabControl (на него помести панель Panel с именем Tab1), ProgressBar,
TrackBar, TreeView, Timer, OpenDialog, Edit, Label (с именем TreeView), Panel,
Button (с именем Open Dialog).
Дважды щелкнем на свойстве Tabs сомпоненты TabControl. В редакторе
строк введем названия закладок – Tab1, Tab2, Tab3.
Свойство Max компонентов ProgressBar и TrackBar установим равное 10.
В событие OnChange компоненты TrackBar введем код:
ProgressBar1->Position=TrackBar1->Position;
Дважды щелкнем по компоненте Timer и добавим код к событию OnTimer,
предварительно указав свойство Interval равным 1000(1 секунда):
I++; //интервал счетчика 1 секунда
Panel2->Caption = IntToStr(i);// панель показывает в секундах время
// работы программы
Необходимо внимательно посмотреть на листинг программы и обратить
внимание на переменную i.
Для компонента TreeView дважды щелкнем на поле справа от свойства Items,
а затем добавим к дереву пункт Level1, затем к узлу второго уровня пункт Level2 и
далее Level3.
К кнопке OpenDialog добавим код:
OpenDialog1->FileName="*.*";
If (OpenDialog1->Execute()){
Edit1->Text=OpenDialog1->FileName;
В результате программа прнимет вид:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
Int i=0;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::TrackBar1Change(TObject *Sender)
{
ProgressBar1->Position=TrackBar1->Position;
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
OpenDialog1->FileName="*.*";
If (OpenDialog1->Execute()){
Edit1->Text=OpenDialog1->FileName;
}
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
I++;
Panel2->Caption = IntToStr(i);
}
//---------------------------------------------------------------------------
4.8.Графические компоненты.
Для работы с графикой в C++Builder имеются графические компоненты:
- Image - используется для импоpта на фоpму pастpовых изобpажений,
пиктогpамм и метафайлов;
- Shape - используется для создания геометpических фигуp;.
- PaintBox - используйется для создания рисунков на компонентах, котоpые не
имеют свойства Canvas (напpимеp, компонент Panel).
В C++Builder гpафические опеpации выполняются с использованием свойства
Canvas, котоpое поддеpживается многими компонентами. Напpимеp, свойство
Canvas есть у фоpмы, а так же у TBitmap, TComboBox, TListBox, TPaintBox и
дpугих компонентов.
Canvas пpедставляет собой объект, наделенный собственными полномочиями, для
чего класс TCanvas поддеpживает множество свойств, методов и событий. Чаще
всего используется свойство Canvas.
В пpоцессе pакзpаботки это свойство недоступно в окне Object Inspector. Для
того, чтобы использовать Canvas, необходимо написать опеpатоpы, котоpые
пpисваивают свойствам Canvas значения и вызывают методы Canvas.
В таблице приведены методы, свойства и события, реализуемые TСanvas.
Установить
это...
Чтобы сделать это...
Arc
Нарисовать на холсте дугу.
Assign
Присвоить один устойчивый объект
РґСЂСѓРіРѕРјСѓ.
Brush
Определить свойства кисти
Chord
Начертить линию поперек эллипса
ClassName
Получить имя класса объекта
ClassParent
Получить родительский класс объекта
ClassType
Получить действительный тип объекта
CopyMode
Определить способ копирования на холст
CopyRect
Скопировать прямоугольную область с
другого холста
Create
Создать объект холста
Destroy
Разрушить объект
Draw
Нарисовать на холсте графику
DrawFocus-
Rect
Нарисовать на холсте прямоугольник
фокуса
Ellipse
Нарисовать на холсте эллипс
FillRect
Нарисовать на холсте заполненный
прямоугольник
FloodFill
Заполнить область холста
Font
Определить шрифт, используемый для
визуализации текста на холсте
FrameRect
Нарисовать на холсте незаполненный
прямоугольник
Free
Безопасно разрушить объект
Handle
Определить НDС для объекта холста
InheritsFrom
Определить, происходит ли объект от
определенного класса
InstanceSize
Определить объем памяти,
распределенной под объект.
LineTo
Нарисовать на холсте линию
MoveTo
Переместить текущее положение пера
OnChange
Данное событие происходит при
изменении поверхности холста
OnChanging
Данное событие происходит перед тем,
как холст будет модифицирован
Pen
Определить вид пера для рисования на
холсте
PenPos
Определить текущую позицию пера
Pie
Нарисовать объект в форме пирога
Pixels
Доступ к отдельным пикселям холста
Polygon
Нарисовать многоугольник
PolyLine
Нарисовать серию соединенных линий
Rectangle
Нарисовать заполненный прямоугольник
Refresh
Обновить холст
RoundRect
Нарисовать заполненный прямоугольник
с закругленными углами
StretchDraw
Вытянуть образ так, чтобы он
размещался внутри заданного
прямоугольника
TextHeight
Определить высоту в пикселях текста,
рисуемого на холсте
TextOut
Вывести текст на холст
TextRect
Определить кадрирующий
прямоугольник для текста на холсте
TextWidth
Определить ширину в пикселях текста,
рисуемого на холсте
Рассмотрим примеры:
Все визуальные компоненты имеют свойства Top (координата X) и Left
(координата Y). Значения X и Y измеряются в пикселах (пиксел - наименьшая
частица поверхности рисунка, которой можно манипулировать).
В зависимости от количества бит, на пиксел различаются различные виды
графики от 8- битовой до 24-битовой. В связи с этим возможно отображение до 16
миллионов цветов в стандарте RGB. Рассмотрим пример рисования синусоиды
при нажатии кнопки на форме:
//---------------------------------------------------------------------------
#include
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
Float X,Y;
Int PX,PY;
Int H;
//определяем половину стороны внизу формы
H=Form1->Height / 2;
For (PX= 0; PX Width; PX++) {
//масштаб X приводится Рє 2 РџР, чтоб сделать
//полную волну
X=PX*(2*3.1415/Form1->Width);
Y=sin(X);
PY=(0.6*Y*H)+H;
Canvas->Pixels[PX][PY]= 0;//устанавливаем черный цвет пикселя
}
}
//---------------------------------------------------------------------------
Каждое свойство Canvas имеет воображаемое перо для рисова-
ния линий и контуров и команды:
- Form1->Canvas->MoveTo(X,Y); -передвигает перо в точку с
координатами(X,Y) без рисования;
- Form1->Canvas->Point(X,Y);- рисует точку;
- Form1->Canvas->LineTo(X,Y); -чертит линию от текущей по-
зиции до точки с координатами X,Y;
Form1->Canvas->Pen->Color:=цвет; - устанавливает цвет пе-
ра(clBlue - голубой или RGB(0,0,255));
- Form1->Canvas->Pen->Width:=толщина; - устанавливает толщи-
ну пера в пикселях;
- Form1->Canvas->Pen->Style:=стиль; - устанавливает стиль пе-
ра(например,пунктирная линия - psDot);
- Form1->Canvas->Pen->Mode:=режим; - устанавливает режим ри-
сования(pmNot- цвет пера инверсный цвету фона, pmCopy -
перо текущего цвета);
- Form1->Canvas->Brush->Color:=цвет; - устанавливает цвет
закрашенного графического объекта;
- Form1->Canvas->Brush->Style:=стиль; - стиль закраски(напри-
мер,bsSolid - закраска одним цветом, bsCross -решеткой).
Анимация в C++ Builder.
Анимация - это движущаяся графика.
Рассмотрим программу, которая создает анимационную последовательность
изображений 10 эллипсов, которые движутся от середины компонента PaintBox к
его границам в случайных направлениях при нажатии кнопки Button.
Процедура рисует эллипс, а затем стирает его изображение.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include // Canvas->Brush->Color = clWhite;
PaintBox1->Canvas->Rectangle(0,0,200,200);
}
}
}
//---------------------------------------------------------------------------
Если запустить программу на выполнение, то изображение эллипсов будет
мерцать, хотя они будут двигаться очень быстро.
Для преодоления этого недостатка в аннимации используют метод двойной
буферизации. В этом случае используют две плоскости - одна отображается на
экране, а вторая используется для рисования.Далее плоскости меняются местами.
Одним из способов организации двойной буферизации - создание в памяти
битовой матрицы РІ качестве промежуточного буфера. Рзображение рисуется РІ
битовой матрице, а по завершению кадра копируется в отображаемый буфер.
Рассмотрим предыдущий пример с использованием битовой матрицы.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include // Width = 200;
For(Count2= 1; Count2
Angle = random(368); // занести случайное число
RadReal = (Angle * M_PI)/180;
For(Count= 1; Count
X = (double)(Count*sin(RadReal))+100;
Y = (double)(Count*cos(RadReal))+100;
// очистка экрана
TheBitmap->Canvas->Brush->Color = clWhite;
TheBitmap->Canvas->Rectangle(0,0,200,200);
// рисование эллипса
TheBitmap->Canvas->Brush->Color = clBlue;
TheBitmap->Canvas->Ellipse(X-6,Y-6,X+6,Y+6);
// копирование битовой матрици на экран
PaintBox1->Canvas->CopyRect(Rect(0,0,200,200),
TheBitmap->Canvas, Rect(0,0,200,200));
}
}
// освобождаем память выделенную под битовую матрицу
Delete TheBitmap;
}
//---------------------------------------------------------------------------
При запуске примера видно, что эллипсы движутся плавно, но процедура
выполняется медленнеее
4.9.Мультимедиа.
Мультимедиа - это использования звука и видео в программах. Для работы со
звуком (файлами с расширением wav и mid) нужна звуковая карта - Soundblaster.
В файлах с расширением wav записано цифровое представление информации
о волновой форме электрического сигнала, соответствующего звуку.
Файлы с расширением mid используются для хранения музыкальных
фрагментов. Звук в этих файлах хранится в виде данных о том на каком
инструменте исполняются те или иные ноты и как они звучат (цифрой эквивалент
дирижерской партитуры).
Файл с расширением avi представляет оцифрованное изображение в виде
кадров, которые сменяются с частотой 24 (могут быть отличия в различных
системах) кадра в секунду. Обычно видеофайлы сжаты, т.к. занимают достаточно
много места в памяти. Для сжатия применяется в основном следующий метод:
определяется неподвижная часть изображения, по сравнению к начальному кадру
и эта информация сжимается, т.е. сохраняются только отличия одного кадра от
РґСЂСѓРіРѕРіРѕ.
Для проигрывания wav файлов в C++ Builder используется процедура
PlaySound. Рассмотрим пример – по нажатию клавиши Button – проигрывается
звуковой файл bomb.wav.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
#include "mmsystem.hpp"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
PlaySound("bomb.wav",0,SND_SYNC);
}
//---------------------------------------------------------------------------
Как видно из программы дополнительно введен модуль mmsystem (в котором
хранятся константы для функции PlaySound) и вызвана API функция PlaySound,
которая имеет три параметра:
Первый параметр - "bomb.wav" типа AnsiString - содержит имя
проигрываемого файла.
Второй параметр (в нашем случае 0) применяется, если файл содержится в
файле ресурсов.
Третий параметр специфицирует опции, задающие способ воспроизведения
Р·РІСѓРєР°.
Для проигрывания всех типов мультимедийных файлов можно использовать
компонент MediaPlaer.
Рассмотрим пример, проигрывания avi, wav и mid файлов.
На форме расположим компоненты: MainMenu, OpenDialog, MediaPlayer,
добавим к меню команду File|Open и в событие меню Open введем код:
Void __fastcall TForm1::Open1Click(TObject *Sender)
{
If(OpenDialog1->Execute())
{
MediaPlayer1->FileName=OpenDialog1->FileName;
MediaPlayer1->Open();
}
}
Общий вид программы следующий:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::N2Click(TObject *Sender)
{
If(OpenDialog1->Execute())
{
MediaPlayer1->FileName=OpenDialog1->FileName;
MediaPlayer1->Open();
}
}
//---------------------------------------------------------------------------
Загружая через меню тот или иной мультимедийный файл мы сможем его
проигрывать.
В случае, если панель проигрывателя показывать не надо, а проигрывать файл
необходимо, то свойство Visible компоненты MediaPlayer нужно установить
равным false.
Рассмотрим пример - информационной системы - в зависимости от
выбранной радиокнопки проигрывается тот или РёРЅРѕР№ avi файл. Рспользуются
компоненты: MediaPlayr, RadioGroup, RadioButton, Panel, Button.
Основная логика программы реализуется в обработке события OnClick
кнопки Button. Когда пользователь нажимает кнопку, программа проверяет, какая
из радиокнопок выбрана. В зависимости от этого проигрывается один из трех avi-
файлов.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::FormCreate(TObject *Sender)
{
MediaPlayer1->Display=Panel1;
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
If(RadioButton1->Checked)
MediaPlayer1->FileName="1.AVI";
If(RadioButton2->Checked)
MediaPlayer1->FileName="2.AVI";
If(RadioButton3->Checked)
MediaPlayer1->FileName="3.AVI";
MediaPlayer1->Open();
MediaPlayer1->DisplayRect=Rect(0,0,
Panel1->Width,Panel1->Height);
MediaPlayer1->Play();
}
//---------------------------------------------------------------------------
4.10.Спрайтовая графика.
Спрайты - движущиеся картинки небльшого размера, являются одной из
главных частей любого игрового или обучающего пакета программ. Рассмотрим
несколько примеров использование спрайтов MChSprite из линейки Samples
Компонента MchSpriteBgr.
Данная компонента представляет собой фон на котором происходит движение
спрайтов. Одним из основных свойств MchSpriteBgr является свойство Picture –
загрузка bmp или gif изображения.
Компонента MchSprite.
Компонента представляет собой собственно спрайт- небольшое bmp -
изображение. Для загрузки изображения используется свойство SprSpriteBitmap.
Основные свойства MchSprite:
SprHideAfter – виден или нет спрайт после окончания движения (MChSprite1-
>SprHideAfter=True - не виден);
SprSetScaleX – масштаб спрайта по оси Х;
SprSetScaleY – масштаб спрайта по оси Y;
Пример – изменение масштаба спрайта при приближении:
Form1->MChSprite2->SprSetScaleX(1+1.0*sin(alpha)); (где alpha - переменная типа
Double);
SprPosFunc – функция пользователя – закон движения спрайта (возвращает
координаты движения спрайта) – пример:
//функция пользователя для движения спрайта N 2
TPoint __fastcall Sprite2PosFunc(TDateTime AtTime)
//AtTime – время от начала движения спрайта в секундах
{
Doublex,y,alpha;
Alpha=2*3.14*(AtTime-Form1->MChSprite2->SprTimeStarted)*
24.0*60.0100.0/(180.0*3.14);
X= Form1->MChSpriteBgr1->ClientWidth /2.0 +
(Form1->MChSpriteBgr1->ClientWidth /3.0)*cos(alpha);
Y= Form1->MChSpriteBgr1->ClientHeight /2.0 +
(Form1->MChSpriteBgr1->ClientWidth /3.0)*sin(alpha);
Form1->MChSprite2->SprSetScale(1+1.0*sin(alpha));
Return(Point(int(x),int(y)));
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Void __fastcall TForm1::FormCreate(TObject *Sender)
{
MChSprite2->SprPosFunc=Sprite2PosFunc;//вызов функции движения
MChSprite2->SprCruise(-1);
}
//---------------------------------------------------------------------------
SprSpriteBitmap – изображение спрайта;
SprTrColor – цвет спрайта;
SprDragable – если истина, то спрайт можно премещать мышью;
SprColliding – если истина, то вызывается функция пользовыателя для обработки
столкновения спрайтов;
SprRefX, SprRefY –соответственно контрольная точка на растре спрайта по оси X
Рё Y;
SprRadiusX ,SprRadiusY радиус столкновения спрайта по оси X и оси Y
соответственно;
Основные методы MchSprite.
Метод SprRun (Point (X1, Y1), Point (X2,Y2), t) –делает спрайт видимым при
движении из одной позиции (X1, Y1) в другую (X2, Y2) в течении того или иного
времени (t).
Пример: (MChSprite1->SprRun(
Point (MChSpriteBgr1->ClientWidth, 0),
Point (0, MChSpriteBgr1->ClientHeight), 3);
Метод SprShowOn (); делает спрайт видимым в текущей позиции.
Метод SprCruise (-1); делает спрайт видимым и его движение задается функцией
пользователя SprPosFunc;
Метод SprMoveTo (Point (X, Y); делает спрайт видимым в позиции X, Y.
Пример:
MChSprite6->SprMoveTo (Point (int ((Form1->MChSpriteBgr1->ClientWidth)/2),
Int((Form1->MChSpriteBgr1->ClientHeight)/2)));
Метод SprShowAt(Point(X,Y); - делает спрайт видимым в точке X,Y.
Метод SprHide – делает спрайт невидимым;
Метод SprStop – останавливает спрайт;
Метод SprGoTo (Point(X,Y),t); - делает спрайт видимым и перемещает в течении t
секунд из текущей позиции в позицию X, Y.
Метод SprGo (Point (X1, Y1), Point (X2, Y2), t); - делает спрайт видимым при
движении из одной позиции (X1, Y1) в другую (X2, Y2) в течении того или иного
времени (t).
Рассмотрим пример использования спрайтов. На форме расположены 6 спрайтов и
4 РєРЅРѕРїРєРё.
В зависимости от нажатия той или иной кнопки происходят события – летит
ракета, сверхновая звезда сталкивается с Солнцем и происходит взрыв и т.д.
Листинг программы:
//---------------------------------------------------------------------------
#include
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma link "MChSpBg"
#pragma link "MChSprt"
#pragma resource "*.dfm"
TForm1 *Form1;
Bool CollideFlip,Exploding;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//----------------------------------------------------------------------
Void __fastcall NoCollide(TDateTime AtTime)
{
If (CollideFlip) MessageBeep(MB_OK);
CollideFlip=False;
}
//----------------------------------------------------------------------
Void __fastcall OnCollide(TMChSprite *SprCollided ,TDateTime AtTime)
{
If (SprCollided==Form1->MChSprite2)
{
// MessageBeep(MB_ICONASTERISK);
If (! CollideFlip)
{
MessageBeep(MB_ICONASTERISK);
CollideFlip=True;
}
If (Form1->MChSprite4->SprNextPos.xMChSpriteBgr1-
>ClientWidth)/2))
{
If (Form1->MChSprite4->SprIndexMChSprite3->SprIndex)
Form1->MChSpriteBgr1->BgrSprIndexExchangeZ(Form1->MChSprite4-
>SprIndex,
Form1->MChSprite3->SprIndex);
}
Else
{
If (Form1->MChSprite4->SprIndex>Form1->MChSprite3->SprIndex)
Form1->MChSpriteBgr1->BgrSprIndexExchangeZ(Form1->MChSprite4-
>SprIndex,
Form1->MChSprite3->SprIndex);
}
}
}
//--------------------------------------------------------------------
Void __fastcall OnExplosion(TMChSprite *SprCollided ,TDateTime AtTime)
{
If (Exploding)
{
// SprCollided->SprStop;
// SprCollided->SprHide;
}
If ((! Exploding) && (SprCollided==Form1->MChSprite1))
{
Exploding=True;
Form1->MChSprite2->SprColliding=true;
Form1->MChSprite5->SprColliding=true;
Form1->MChSprite6->SprCruise(20);
}
}
//---------------------------------------------------------------------
TPoint __fastcall Sprite6PosFunc(TDateTime AtTime)
{
Form1->MChSprite6->SprSetScale(1.25*(AtTime-Form1->MChSprite6-
>SprTimeStarted)
*24.0*60.0*60.0*5.0);
// if ((AtTime-Form1->MChSprite6->SprTimeStarted)*24.0*60.0*60.0>17.0)
// Form1->MChSprite6->SprHide;
Return(Point(int((Form1->MChSpriteBgr1->ClientWidth)/2),
Int((Form1->MChSpriteBgr1->ClientHeight)/2)));
}
//-----------------------------------------------------------------------
TPoint __fastcall Sprite4PosFunc(TDateTime AtTime)
{
Double x,y,alpha;
Alpha =2*3.14*(AtTime-Form1->MChSprite3-
>SprTimeStarted)*24.0*60.0+(90.0+0.0)/180.0*3.14;
X= Form1->MChSpriteBgr1->ClientWidth /2.0 +
(Form1->MChSpriteBgr1->ClientWidth /3.0)*cos(alpha);
Y= Form1->MChSpriteBgr1->ClientHeight /2.0 +
- (Form1->MChSpriteBgr1->ClientWidth /3.0)*sin(alpha);
Form1->MChSprite4->SprSetScale(1-0.9*sin(alpha));
Return(Point(int(x),int(y)));
}
//-----------------------------------------------------------------------
TPoint __fastcall Sprite3PosFunc(TDateTime AtTime)
{
Double x,y,alpha;
Alpha=-2*3.14*(AtTime-Form1->MChSprite3->SprTimeStarted)*24.0*60.0+(90.0-
180.0)/180*3.14;
X= Form1->MChSpriteBgr1->ClientWidth /2.0 +
(Form1->MChSpriteBgr1->ClientWidth /3.0)*cos(alpha);
Y= Form1->MChSpriteBgr1->ClientHeight *0.5 +
-(Form1->MChSpriteBgr1->ClientWidth *0.55)*sin(alpha);
If (x>=(Form1->MChSpriteBgr1->ClientWidth)/2)
Form1->MChSprite3->SprSetScaleX( (1-1.0*sin(alpha)));
Else Form1->MChSprite3->SprSetScaleX(-(1-1.0*sin(alpha)));
If (yMChSpriteBgr1->ClientHeight)/2)
Form1->MChSprite3->SprSetScaleY( (1-1.0*sin(alpha)));
Else Form1->MChSprite2->SprSetScaleY(-(1-1.0*sin(alpha)));
Return(Point(int(x),int(y)));
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::FormCreate(TObject *Sender)
{
Exploding=false;
MChSprite2->SprShowAt(Point(int((Form1->MChSpriteBgr1->ClientWidth)/2),
Int((Form1->MChSpriteBgr1->ClientHeight)/2)));
MChSprite3->SprPosFunc=Sprite3PosFunc;
MChSprite4->SprPosFunc=Sprite4PosFunc;
MChSprite6->SprPosFunc=Sprite6PosFunc;
MChSprite6->SprHideAfter=true;
MChSprite6->SprOnCollide=OnExplosion;
MChSprite4->SprOnCollide=OnCollide;
MChSprite4->SprNoCollide=NoCollide;
MChSprite3->SprCruise(-1);
MChSprite4->SprCruise(-1);
MChSprite6->SprMoveTo(Point(int((Form1->MChSpriteBgr1->ClientWidth)/2),
Int((Form1->MChSpriteBgr1->ClientHeight)/2)));
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
Exploding=false;
MChSprite6->SprSetScale(0.2);
MChSprite6->SprMoveTo(Point(int((Form1->MChSpriteBgr1->ClientWidth)/2),
Int((Form1->MChSpriteBgr1->ClientHeight)/2)));
Form1->MChSprite1->SprColliding=true;
Form1->MChSprite6->SprColliding=true;
Form1->MChSprite1->SprGo( Point(Form1->MChSpriteBgr1->ClientWidth,0),
Point(int(Form1->MChSpriteBgr1->ClientWidth/2),
Int(Form1->MChSpriteBgr1->ClientHeight/2)), 5 );
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button2Click(TObject *Sender)
{
MChSprite5->SprColliding=False;
MChSprite5->SprHideAfter=True;
MChSprite5->SprGo(Point(Form1->MChSpriteBgr1->ClientWidth,
Form1->MChSpriteBgr1->ClientHeight),
Point(0,0), 20);
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button3Click(TObject *Sender)
{
Exploding=false;
MChSprite1->SprColliding=false;
MChSprite2->SprColliding=false;
MChSprite5->SprColliding=false;
MChSprite6->SprColliding=false;
MChSprite6->SprHide();
MChSprite5->SprHideAfter=true;
MChSprite2->SprShowAt(Point(int((Form1->MChSpriteBgr1->ClientWidth)/2),
Int((Form1->MChSpriteBgr1->ClientHeight)/2)));
MChSprite3->SprCruise(-1);
MChSprite4->SprCruise(-1);
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button4Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
Рспользуя рассмотренный пример, можно изучить практически РІСЃРµ свойства
спрайтов.
4.11. Объектная технология OLE2.
Фирма Microsoft включила в систему Windows 95 подсистему внедрения и
связывания объектов. В общем виде OLE2 позволяет пользователю получить
доступ к объектам разработанных систем в приложении, с которым он работает.
Например, работая в Word, можно вызвать таблицу Excel, обработать
определенным образом данные, а результат запомнить в Word. Кроме этого
автоматизация OLE2 позволяет программисту включать в свои программы
разработанные компоненты, например Word.
Основа OLE2 - Com -компонентная модель объекта (Component Object
Model), которая предусматримает модульность и совместитмость во
взаимодействии между компонентами, написанными на разных языках. Соm
определяет двоичный интерфейс, независимый от языка программирования,
который может вступать в коммуникацию с другими компонентами, ничего не
зная о них. Объекты, ориентированные на внешнее использование и доступные
только из программы называются автоматными объектами OLE. Рассмотрим
пример программы, которая вызывает Word, создает новый файл и записывает в
Word содержимое компонента Edit.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include //подключение средств автоматизации OLE
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
Variant V;
Try {
V = CreateOleObject("Word.Basic");
}
Catch(...){
ShowMessage("Не могу запусть Word");
Throw;
Close();
}
V.OleProcedure("AppShow");
V.OleProcedure("FileNew");
V.OleProcedure("Insert", Edit1->Text);
}
//---------------------------------------------------------------------------
Рассмотрим как работает програмы.
Прежде всего необходимо указать в программе команду подключения
средств, отвечающей за автоматизацию OLE #include .
Далее по команде V = CreateOleObject ("Word.Basic"); вызываем Word,
делаем приложение видимым по команде V.OleProcedure ("File New"); создаем
новый документ по команде V.OleProcedure ("File New"). Команда V.OleProcedure
("Insert", Edit1->Text); текст из редактора Edit и записывает в Word).
Как видно, в программе используются средства обработки исключений
Try {
V = CreateOleObject("Word.Basic");
}
Catch(...){
ShowMessage("Не могу запусть Word");
Throw;
Close();
которые в случае ошибки закрывают программу.
Кроме рассмотренного примера для автоматизации OLE существуют
стандартные объекты OCX, которые похожи на визуальные компоненты
C++Builder, но на самом деле являются самостоятельными объектами.
Объекты OCX могут быть включены в программу не только на C++Builder,
но и Delphi. Но в отличии от компонент C++Builder - они не включаются в код
программы, поэтому при распространении программного обеспечения,
использующего компоненты OCX необходимо распространять и сами
компоненты OCX.
4.12.Библиотеки DLL.
DLL (Dinamic Link Library) - динамически присоединяемая библиотека,
используется для хранения функций и ресурсов отдельно от исполняемого файла.
Обычно в программах статистической сборки функции, ресурсы, процедуры и т.д.
компонуются в исполняемом файле, использование же DLL позволяет наиболее
часто используемые процедуры, функции или ресурсы хранить в DLL и загружать
их из DLL по мере необходимости - это динамическое присоединение.
Обычно DLL не загружается в память пока это не необходимо, но будучи
загружена, она делает доступными функции, процедуры или ресурсы для любой
программы и для любых языков программирования, которые могут работать с
DLL.
Рассмотрим пример создания DLL, коорая кодирует строку. Кодировка
происходит путем сдвигов кода символа на еденицу вправо.
Для создания библиотеки SUM.DLL необходимо выполнить шаги:
1.Запустить C++ Builder. и выполнить File|New и выбрать пиктограмму DLL.
2.Набрать код:
//Генерирует C++Builder
#include
#pragma hdrstop
//---------------------------------------------------------------------------
// Important note about DLL memory management:
//
// If your DLL exports any functions that pass String objects (or structs/
// classes containing nested Strings) as parameter or function results,
// you will need to add the library BCBMM.LIB to both the DLL project and any
// EXE projects that use the DLL. This will change the DLL and its calling
// EXE's to use the BCBMM.DLL as their memory manager. In these cases,
// the file BCBMM.DLL should be deployed along with your DLL.
//
// To avoid using BCBMM.DLL, pass string information using "char *" or
// ShortString parameters.
//---------------------------------------------------------------------------
USERES("sum.res");
//---------------------------------------------------------------------------
Void ViewForm();
Int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*)
{
Return 1;
}
//Набираемый код
#include "sum.h"
//---------------------------------------------------------------------------
Char FileName[256];
Void SayHello()
{
GetModuleFileName( NULL,FileName, sizeof (FileName) );
MessageBox ( NULL, FileName, "Hello from:", MB_OK );
}
Int Sum(int a,int b)
{
Return a + b;
}
Char* Codec(char *eptr)
{
Int x,l;
Char ch;
L = strlen(eptr);
If(eptr[l-1] != '`') {
For(x=0; xTop = 10;
FpForm->Width = 200;
FpForm->Height = 200;
FpForm->Visible = true;
TPanel *FpPanel = new TPanel(FpForm);
FpPanel->Parent = FpForm;
FpPanel->Left = 2;
FpPanel->Top = 2;
FpPanel->Width = 198;
FpPanel->Height = 198;
FpPanel->Visible = true;
MessageBox ( NULL,"If YES clicked ", "You finished ?", MB_OK );
If(FpPanel) {
Delete FpPanel;
If(FpForm)
Delete FpForm;
}
}
3.Сохранить проект в каталоге под именем sum.mak
4.Выбрать Options|Project...|Directories/Conditionals
5.В поле Conditionals набрать: __BUILDING_THE_DLL
6.В каталоге где находится проект создать файл sum.h со следующим кодом:
#ifdef __BUILDING_THE_DLL
#define __EXPORT_TYPE __export
#else
#define __EXPORT_TYPE __import
#endif
Void __EXPORT_TYPE SayHello();
Int __EXPORT_TYPE Sum(int a,int b);
Char* __EXPORT_TYPE Codec(char *eptr); //Text.c_str()));
Edit1->Text = Codec(szMyStr); //Terminate();
}
//---------------------------------------------------------------------------
К исполняемому файлу (код которого приведен выше) подключить sum.lib
выполнив команду:
Project\Add to Project\.....sum.lib
Запустить проект на компиляцию и выполнение.
Возможен вызов DLL из DLL, или вызов DLL из другого языка
программирования.
4.13.Разработка визуальных компонент.
C++ Builder позволяет расширять библиотеку VCL собственными
компонентами.
Рассмотрим на примере разработку визуальной компоненты, которая
позволяет перемножать два числа, если их значение не превышает 100.
Прежде всего отметим, что разрабатываемая компонента TMul потомок
Tcomponent. Расположим ее на странице Samples библиотеки VCL.
Разрабатывемый компонент содержит свойства методы и события.
Свойства используются для задания определенных атрибутов (полей данных)
и инициализации некоторых действий.
Методы - это процедуры и функции, которые делают класс общедоступным.
События используются для расширения компонентов в случае, когда
возникают события (например, щелчок мыши).
Разрабатываемый компонент имеет два свойства типа int (Val1 - первый
сомножитель, Val2- второй сомножитель) один метод DoMult (перемножает
сомножители) и событие TooBig (вызывет обработчик событий, когда один из
сомножителей больше 100).
При вызове метода, два значения в свойствах перемножаются и результат
становится значением третьего свойства (Res).
Событие TooBig реализуется, если хотя бы одно из чисел больше 100.
Рассмотрим этапы построения TMul.
1.Создадим модуль, используя раздел Component/ New Главного меню.
В закладке Component Wizard указываем Calss Name: – TMul, Ancestor type: -
Tcomponent, Pallette Page: – Samples. В результате будет сгенерирован код,
который включает стандартную оболочку объявления класса TMul, и поцедуру
регистрации класса. Далее модуль сохраняется под именем Mul.cpp. В результате
будет созданы файлы: Mul.cpp и Mul.h.
2.Добавление свойств к компоненту. Открываем файл Mul.h и записываем
РєРѕРґ.
В разделе private определим свойства FVal1, FVal2 - доступные в процессе
проектирования и в процессе выполнения и свойство Res -доступное в процессе
выполнения. Также описываем событие TooBig, для определения которого
используется тип TnitifyEvent – обобщенный указатель на функцию, которая
передает один параметр типа Tcomponent – this.
Class TMul : public TComponent
{
Private:
Int FVal1;
Int FVal2;
Int FRes ;
TNotifyEvent FTooBig;
Далее определим свойства (__property): Res в разделе public, т.к. оно доступно
во время выполнения и свойства Val1 и Val2 в разделе __published, т.к. они
доступны во время проектирования. Определяем прямой доступ для чтения и
записи (read,write) значений переменных в разделе __published
Для переменной FRes прямой доступ не нужен,т.к. свойство Res
предназначено только для чтения.
Class TMul : public TComponent
{
Private:
Int FVal1;
Int FVal2;
Int FRes ;
TNotifyEvent FTooBig;
Protected:
Public:
__fastcall TMul(TComponent* Owner);
Void __fastcall DoMult(void);
//свойство для получения результата
__property int Res = { read=FRes, write=FRes };
__published:
//первый операнд
__property int Val1 = { read=FVal1, write=FVal1, default = 1 };
//второй операнд
__property int Val2 = { read=FVal2, write=FVal2, default = 1 };
//событие
__property TNotifyEvent TooBig = { read=FTooBig, write=FTooBig};
};
Далее загружаем файл Mul.cpp и добавляем код.
3.Добавление конструктора.
Для создания представителя класса вызывается конструктор. Конструктор
также:
- устанавливает значения по умолчанию для переменных класса;
- отвечает за динамическое распределение памяти и получение ресурсов,
необходимых классу;
- вызывается при добавлении компонента к форме во время проектирования или
во время выполнения.
__fastcall TMul::TMul(TComponent* Owner)
: TComponent(Owner)
{
FVal1 = 1;
FVal2 = 1;
}
4.Добавление метода.
Для добавления метода необходимо написать код:
Void __fastcall TMul::DoMult(void)
{
If((Val1
Res = FVal1 * FVal2;
Else
If (FTooBig) TooBig(this);
}
5.Добавление событие.
Событие предоставляет программисту задать специальный код, исполняемый
когда что-то происходит. В нашем случае добавляется событие
TooBig, которое запускается когда значение Val1 или Val2 больше 100.
Обработка события осуществляется в строке:
If (FTooBig) TooBig(this);
Если нашем случае FtooBig=TRUE то происходит обработка события.
Листинг файла Mul.h
//---------------------------------------------------------------------------
#ifndef mulH
#define mulH
//---------------------------------------------------------------------------
#include
#include
#include
#include
//---------------------------------------------------------------------------
Class TMul : public TComponent
{
Private:
Int FVal1;
Int FVal2;
Int FRes ;
TNotifyEvent FTooBig;
Protected:
Public:
__fastcall TMul(TComponent* Owner);
Void __fastcall DoMult(void);
__property int Res = { read=FRes, write=FRes };
__published:
__property int Val1 = { read=FVal1, write=FVal1, default = 1 };
__property int Val2 = { read=FVal2, write=FVal2, default = 1 };
__property TNotifyEvent TooBig = { read=FTooBig, write=FTooBig};
};
//---------------------------------------------------------------------------
#endif
Листинг файла Mul.cpp:
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "mul.h"
//---------------------------------------------------------------------------
Static inline TMul *ValidCtrCheck()
{
Return new TMul(NULL);
}
//---------------------------------------------------------------------------
__fastcall TMul::TMul(TComponent* Owner)
: TComponent(Owner)
{
FVal1 = 1;
FVal2 = 1;
}
//---------------------------------------------------------------------------
Namespace Mul
{
Void __fastcall Register()
{
TComponentClass classes[1] = {__classid(TMul)};
RegisterComponents("Samples", classes, 0);
}
}
//---------------------------------------------------------------------------
Void __fastcall TMul::DoMult(void)
{
If((Val1
Res = FVal1 * FVal2;
Else
If (FTooBig) TooBig(this);
}
//---------------------------------------------------------------------------
Далее компонент необходимо оттранслировать и включить в библиотеку
компонент.
Для включения компонента в библиотеку необходимо:
- в главном меню выбрать Component/Install;
- в появившемся окне Install Components выбрать опцию Add;
- зайти в папку где находится компонента, выбрать файл Mul.cpp и щелкнуть
мышью по кнопке OK.
Компонента установится на странице Samples.
Для тестирования компонента используем программу.
На форму поместим три компоненты Edit, три Label, Button и Mul.
Щелкнем по кнопке Button Рзапишем код.
Mul1->Val1 = StrToInt(EdVal1->Text);
Mul1->Val2 = StrToInt(EdVal2->Text);
Mul1->DoMult();
EdRes->Text = IntToStr(Mul1->Res);
Далее щелкаем мышью справа от события TooBig сомпонеты Mul и
записываем код:
Form1->Caption="Переполнение";
Общий вид программы:
//---------------------------------------------------------------------------
#pragma link "mul"
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
Mul1->Val1 = StrToInt(EdVal1->Text);
Mul1->Val2 = StrToInt(EdVal2->Text);
Mul1->DoMult();
EdRes->Text = IntToStr(Mul1->Res);
}
//---------------------------------------------------------------------------
Void __fastcall TForm1::Mul1TooBig(TObject *Sender)
{
Form1->Caption="Переполнение";
}
//---------------------------------------------------------------------------
Далее программу можно выполнить.
Кроме рассмотренного примера возможна модификация существующих
визуальных компонент и получение новых компонент на базе существующих.
4.14. Введение в программирование CGI.
Важнейшей особенностью web-сервера является возможность получения
информации от пользователя и обработка ее с помощью CGI(общий шлюзовый
интерфейс). CGI – компонент программного обеспечения, который:
- позволяет писать сценарии и создавать на их основе управляемые
пользователем интерактивные приложения;
- обеспечивает возможность взаимодействовать с другими программами сервера;
- имеет средства динамического создания Web-страниц на основе информации
пользователя;
- может вызвать внешнюю программу и передать в нее пользовательские
данные.
В конечном итоге пользователь, не будучи ограничен в рамках заранее
написанных документов, используя CGI сценарий может создать круг
приложений, которые ему необходимы для получения информации.
Программе CGI необходимо извлечь информацию, обработать ее и
сообщить ответ. Рассмотрим простой пример – создание виртуального документа:
Запускаем C++Builder. В главном меню выбираем File/New и в открывшейся
таблице New Items выбираем Console App.
Удаляем все что находится в открывшемся окне и записываем код:
//Пример CGI
#include
#pragma hdrstop
Char S[] = "РџР РВЕТ
\n";
Void main(void)
{
Setvbuf(stdout, NULL, _IONBF, 0);
Printf("\nContent-type: text/html\n\n");
Printf("\n");
Printf("\n");
Printf(S);
Printf("\n");
Printf("\n");
}
Запоминаем программу и запускаем на трансляцию. После этого помещаем
выполняемый файл (например Prim.exe) на Web-сервер в раздел CGI.
Запускаем броузер и вызывем программу из раздела CGI.
Во время выполнения программа посылает свою информацию на
стандартный вывод, как поток данных, состоящий из двух частей:
- заголовок в котором описан формат возвращаемых данных
Printf("\nContent-type: text/html\n\n"); - текст формата HTML;
- тело выходных данных – данные в формате HTML.
Сервер возвращает результаты выполнения CGI-программы броузеру.
Для Web-сервера неважен язык, на котором написана программа.
4.15. Программирование баз данных.
Особенностью разработки доступа к базам данных при помощи C++Builder
является полностью объектный визуальный подход. Вторая особенность
заключается в том, что доступ к разным базам данных (dBase, Paradox, Oracle и
РґСЂСѓРіРёРј) РїСЂРѕРёСЃС…РѕРґРёС‚ совершенно унифицированно. Рта дает определенные
преимущества по сравнению с таким мощным средством разработки баз данных
как Visual FoxPro.
Рнтерфейсом между приложением Рё базами данных служит BDE - Borland
Database Engine, т.е Механизм База данных Borland. Он позволяет не только
осуществлять доступ к локальным базам данных, но и осуществлять доступ к
данным по типу клиент-сервер. Одной из особенностей C++Builder является то,что
доступ к базам данных осуществляется одинаково как на стадии разработки, так и
на стадии исполнения.
Для разработки используется трех ступенчатая модель. Каждой ступени
соответствует своя компонента (класс).
TDBGrid - отображает в окне область редактирования (по типу команды
Browse (Grid) РІ FoxPro)
TdataSource - служит интерфейсом между TDBEdit и нижней компонентой.
TTable - содержит все записи таблици.
На более низком уровне работают драйвера BDE, осуществляющие
непосредственный обмен с хранимыми данными.
Расмотрим более подробно описанные выше компоненты.
Рсточник данных (TDataSource).
Основные свойства.
AutoEdit - разрешает или запрещает редактирование записей (False или True).
DataSet - определяет имя конкретного набора данных, таблицы или запроса.
Например Table1. Можно переключаться с одного набора данных на другой
непосредственно во время выполнения программы.
Name - определяет название данной компоненты. Например DataSource.
С данной компонентой связаны три события OnDataChange, OnStateChange,
OnUpdateData.
Таблица (TTable).
Основные свойства.
Active - разрешает или запрещает просмотр данных.
DatabaseName - псевдоним базы данных и путь к каталогу, где база данных
содержится.
Name - псевдоним таблицы.
TableName - конкретное имя таблицы (в указанном каталоге).
Exclusive - разрешает или запрещает другому приложению обращаться к
таблице.
IndexFiles - выбор индексного файла для таблицы.
IndexName - правило сортировки данных в индексе.
Filter - установка фильтра.
MasterFields и MasterSource - для образования связей между двумя таблицами.
Для данной компоненты определены стандартные методы используемые
другими системами управления баз данных: Locate, Lookup, Append, Insert, Next,
MoveBye Рё РґСЂСѓРіРёРµ.
Отображение данных (TDBGrid).
Некоторые свойства.
DataSource - совпадает со свойством Name компоненты TDataSource. В
результате имеем следующую связку:
TDBGrid TDataSource TTable
-----------------------------------------------------------------------------------------
DataSource Name-DataSet Name -DatabaseName-TableName
Такая связка обеспечит в окне редактирования появления записей таблицы
имеющей имя TableName (см.ниже).
Другие свойства данной компоненты тривиальны - они определяют
положение окна редактирования, цветовую гамму, размера окна, шрифты и т.п.
Еще одна компонента часто используется в связи с работой с базами данных.
Запросы (Tquery).
Данная компонента понадобится вам, если у вас возникнет необходимость
пользоваться командами SQL-языка.
Основные свойства.
Active - разрешает или запрещает просмотр данных.
DatabaseName - содержит псевдоним базы данных или полный путь к
каталогу, где эта база данных находится.
SQL - используется для ввода команды SQL. Синтаксис этих команд является
стандартом и с ним можно познакомиться в любом руководстве по СУБД
(например FoxPro).
RequestLive - разрешает или запрещает BDE возращать набор данных в
любом случае.
Приступаем теперь к разбору конкретного примера. Пример очень прост. При
запуске программы появляется форма. На форме имеется окно редактирования
таблицы, кнопка "Выход", кнопка "Добавить", кнопка "Удалить". Таблица
содержит данные Рѕ людях: Р¤РРћ, выданная СЃСѓРјРјР°, дата выдачи. РЈ вас будет
имется возможность редактировать таблицу, добавлять и удалять записи. При
запуске программа проверяет наличие таблицы в указанном каталоге и при
необходимости создает и индексирует эту таблицу.
Поместим на форму три кнопки, TDBGrid (для просмотра таблицы), TTable,
TDataSource.. Пусть наша таблица будет находится в каталоге c:\baza\ и будет
иметь имя 'proba' Заполним свойства трех компонент основных компонент:
TTable :
DatabaseName=c:\baza\
Name=Table1
TableType=ttDBase
TableName=proba
IndexName=proba
TDataSource:
DataSet=Table1
Name=DataSource1
TDBGrid:
DataSource=DataSource1
Все остальные свойства можно оставить по умолчанию и менять по ходу
работы над программой.
Приведем текст модуля Unit1.cpp содержащего основные исполняемые
функции.
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma link "Grids"
#pragma resource "*.dfm"
TForm1 *Form1;
Char * baza="proba.dbf";
Char * baza1="proba";
//---------------------------------------------------------------------------
//Конструктор
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
HANDLE handle;
//пытаемся открыть таблицу как обычный файл
Handle=CreateFile(baza,
GENERIC_READ,
FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_ARCHIVE,
NULL);
If(handle!=INVALID_HANDLE_VALUE)
{
//файл есть и закроем
CloseHandle(handle);
} else
{
//файла нет
//создаем таблицу
Table1->FieldDefs->Clear();
Table1->FieldDefs->Add("Name", ftString, 20, true);
Table1->FieldDefs->Add("Zarpl", ftFloat, 0, true);
Table1->FieldDefs->Add("Data", ftDate, 0, true);
//теперь создаем индексный файл
Table1->IndexDefs->Clear();
TIndexOptions MyIndexOptions;
MyIndexOptions Add(baza1, "Data", MyIndexOptions);
Table1->CreateTable();
}
//здесь открыть таблицу
Table1->Active = true;
//активизировать индекс
Table1->OpenIndexFile("proba.MDX");
}
//----------------------------------------------
//Деструктор
__fastcall TForm1::~TForm1()
{
//закрыть таблицу
Table1->Active = false;
}
//---------------------------------------------------------------------------
//выход
Void __fastcall TForm1::Button1Click(TObject *Sender)
{
//метод Close закрывает форму и вызывает деструктор
Close();
}
//---------------------------------------------------------------------------
//кнопка "добавить запись"
Void __fastcall TForm1::Button3Click(TObject *Sender)
{
Table1->Append();
}
//---------------------------------------------------------------------------
//кнопка "удалить запись"
Void __fastcall TForm1::Button2Click(TObject *Sender)
{
Table1->Delete();
}
Прокоментируем вышеприведенный текст.
Отметим одну интересную возможность C++Builder. Он может одновременно
работать как с библиотекой объектов с которой мы до сих пор работали так и
непосредственно с функциями API. В нашей программе мы демонстрируем эту
возможность: в конструкторе пытаемся открыть файл (функция CreateFile). Если
открытие не удается, выполняется часть кода создающий таблицу и индексный
файл. Ниже представлено окно работы нашей программы.
4.16. ПАКЕТЫ.
Существенную роль в разработке приложений на языке C++Builder 3 и выше
играют пакеты(packages), которые представляют собой библиотеки динамической
компоновки, содержащие компоненты C++Builder из библиотеки визуальных
компонент(VCL).
Применение пакетов позволяет умсеньшить размеры исполняемых (.EXE-
файлов, однако в таком случае вместе с программой необходимо распространять
эти библиотеки.
Существует несколько видов пакетов- выделим из них пакеты времени
выполнения(ПВВ). Пакеты данного вида используются: когда приложение
выполняется.
ПВВ могут связываться статически и динамически. При статическом
связывании образуется выполняемый файл, для которого не нужны библиотеки с
расширением (.BPL). Связывание в пакет динамически ведет к тому, что
библиотеки .BPL должны распространяться с приложением.
В C++Builder 3 и выше в меню Project/Options/Packages есть опция Build with
Runtime packages. Если флажок возле этой опции установлен, то приложение
необходимо распространять вместе с библиотеками .BPL, если флажок не
установлен, то получается полностью скомпилированный выполняемы файл.
Динамическое связывание применяется при конструировании приложений,
состоящих из большого количества выполняемых файлов.
Заключение.
В представленном учебном пособии были рассмотрены некоторые вопросы
программирования на языке С++ и C++Builder.
Для углубленного изучения языка программирования Си необходимо
изучить литературу, приведенную ниже.
Литература:
1. Уэйт М., Прата С., Мартин Д. Язык Си. Руководство для начинающих. - М.:
РњРёСЂ, 1988.- 512 СЃ.
2. Страуструп Р‘. Язык программирования РЎР++. - Рњ.: Радио Рё СЃРІСЏР·СЊ,1991.-
352СЃ.
3. Бруно Бабэ Просто Рё СЏСЃРЅРѕ Рѕ BORLAND РЎ++.-Рњ.:Р‘РРќРћРњ,1995.-400СЃ.
4.Бочков С.О., Субботин Д.М. Язык программирования Си для персонального
компьютера. -М.: Радио и связь,1990.-384с.
5. Ричард Вайнер, Льюс Пинсон С++ изнутри. - Киев: ДиаСофт,1993.-304с.
6. Лукас П. С++ под рукой. - Киев:ДиаСофт, 1993.-176с.
7. Стефан Дьюхарст, Кэти Старк Программирование на С++.- Киев: ДиаСофт,
1993.-272СЃ.
8. Белецкий Я. Турбо Си++: Новая разработка. - М.: Машиностроение, 1994. -
400СЃ.
9. Том Сван. Программирование для WINDOWS в BORLAND C++.-
Рњ.:Р‘РРќРћРњ, 1995.-400СЃ
10. Шилд Г. Программирование на С и С++ для WINDOWS 95.-К.:Торгово-
издательское бюро BHV, 1996.-400с.
11. Круглински Дэвид. Основы Visual C++.-М.:Русская Редакция ТОО
Channel Trading Ltd, 1997.-696СЃ.
12. Шилдт Герберт. MFC: РѕСЃРЅРѕРІС‹ программирования. - Рљ.: Рздательская
РіСЂСѓРїРїР° BHV, 1997.-560СЃ.
13. Р”. РљРЅСѓС‚. Рскусство программирования для РР’Рњ. Рў. 3. Сортировка Рё
РїРѕРёСЃРє. - Рњ.: РњРёСЂ, 1978.
14. Б. Керниган, Д. Ритчи. Язык программирования Си. - М.: Финансы и
статистика, 1992.
15. Р.Андерсон. Доказательство правильности программ. М.: Мир, 1984.
16. Шилд Герберт. Самоучитель С++.-BHV.-С.-Петербург.,1997.-512с.
17. Шамис В.А. Borland C++ Builder. Программирование на С+ без
проблем М.: Нолидж, 1997.-266с.
18. Елманова Н.З., Кошель С.П. Введение в Borland C++ Builder.-М.: Диалог. -
РњРР¤Р, 1997.-272СЃ.
19. Рейсдорф Рљ. РћСЃРІРѕР№ самостоятельно Borland C++Builder. Рњ.: Р‘РРќРћРњ,
1998.-702СЃ.
20. Рамодин Д. Создание приложений в среде Borland C++Builder, Мир ПК
В„–10,11,12-1997Рі.
21. Калверт Чарльз C++Builder. Рнциклопедия пользователя.
22.Оузьер Д., Гробман С., Батсон С. Delphi2. Освой самостоятельно.-
М.:Восточная Книжная Компания,1997.-624с.
23. Пирогов В.Ю. Программирование на языке ассемблера для операционных
систем MS DOS и Windows, 1999, -550c.
24. Калверт Чарльз и др. Borland C++Builder 3.Самоучитель.-К:ДиаСофт,
1999.-272СЃ.
25. Московские олимпиады по программированию,М.-1988.-208с.
РџР РЛОЖЕНРР• N1
Задача N1.
Определить, какая из точек плоскости A(x1,y1), B(x2,y2), C(x3,y3)
расположена ближе к началу координат.
#include
#include
#include
Int main(void)
{
Char *n[30];
Int x1,y1,x2,y2,x3,y3,p1,p2,p3,k;
Clrscr();
Printf("Введите координаты первой точки\n");
Printf("x1=",&x1);
Scanf("%d",&x1);
Printf("y1=",&y1);
Scanf("%d",&y1);
Printf("Введите координаты второй точки\n");
Printf("x2=",x2);
Scanf("%d",&x2);
Printf("y2=",y2);
Scanf("%d",&y2);
Printf("Введите координаты третьей точки\n");
Printf("x3=",x3);
Scanf("%d",&x3);
Printf("y3=",y3);
Scanf("%d",&y3);
P1=sqrt(x1*x1+y1*y1);
P2=sqrt(x2*x2+y2*y2);
P3=sqrt(x3*x3+y3*y3);
K=p1; *n="первая";
If(k>p2) { k=p2;*n="вторая"; }
If(k>p3) { k=p3;*n="третья"; }
Printf("%s точка ближе всех к началу координат \n",*n);
Getch();
Return(0);
}
Задача N2.
Можно ли раменять 25 рублей 9 купюрами достоинством в 1, 3 и 5
рублей?
#include
Int main(void)
{
Int x,y,s,z;
S=0;
For(x=1;x
