Функция ShellExecute

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

Используемый модуль ShellAPI. Его нужно не забыть указать в разделе Uses.

Описание: ShellExecute (hWnd: HWND; Operation: PChar; FileName: PChar; Parametrs: PChar; Directory: PChar; CmdShow: Integer): HINST;

где: hWnd – Handle родительского окна, в который будут передаваться сообщения запускаемого приложения. Можно указывать Handle-ссылку окна вашего приложения.

Operation – производимая операция. Open – открыть, print – напечатать, explore – открыть папку. По умолчанию open, если указать nil.

FileName – имя файла или документа, интернет ссылка, e-mail адрес.

Parametrs – параметры, передаваемые приложению в командной строке.

Directory – каталог по умолчанию.

CmdShow – стиль окна. Показывает, в каком состоянии будет отображаться окно при запуске. Подробно рассказано выше.

Вместо параметров Operation, Parametrs и Directory можно ставить nil. Они являются не обязательными параметрами для запуска.

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

Пример использования команды ShellExecute в программе:

ShellExecute (Form1.Handle, nil, 'http://programming.dax.ru', nil, nil, SW_RESTORE); //запуск нашей странички

ShellExecute (Form1.Handle, nil, PChar (Application.ExeName), nil, nil, SW_RESTORE); //запуск второй копии этой программы

ShellExecute (Form1.Handle, nil, 'iexplore', 'http://programming.dax.ru', nil, SW_RESTORE); //запуск в отдельном окне

ShellExecute (Form1.Handle, nil, 'mailto:semen@krovatka.net?subject=delphi', nil, nil, SW_RESTORE); //написать мне письмо

ShellExecute (Form1.Handle, nil, 'c:1.doc', nil, nil, SW_RESTORE); //открыть документ

С уважением, ведущий уроков Semen semen@krovatka.net

 

Урок5. Многооконная структура программы. Перетаскивание файлов в приложение

Часть урока для новичков

Приложения MDI и приложения SDI.

Прежде чем устанавливать вид и свойства вашего приложения надо подумать о том, какой вид приложения вы желаете создать. Это во многом зависит от его функционального назначения. Можно выбирать между так называемыми MDI- или SDI-приложениями.

MDI – сокращенно от Multiple Document Interface (интерфейс для одновременной работы со многими документами), а SDI – от Single Document Interface (интерфейс для работы с одним документом). В MDI приложениях два или более окон могут быть активны одновременно. В SDI-приложениях это невозможно. Здесь в каждый момент времени может быть активным только одно окно.

MDI-приложения являются удобным средством для одновременного выведения на экран текста или данных, которые хранятся в различных файлах. Такую структуру построения окон можно использовать для редактирования текстов, открывая и выводя на экран одновременно несколько различных документов. С помощь этих приложений можно также производить табличные вычисления, обрабатывая несколько таблиц одновременно, перенося или сравнивая данные из одной в другую. Пример такой работы над файлами – программа MS Word. Здесь файлы текстового и графического формата открываются в отдельных окнах, находящихся внутри главного окна программы.

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

Родительское окно может быть в MDI-приложениях только одно, а дочерних окон может быть теоретически бесконечно.

Большинство MDI-приложений имеют меню "Window" ("Окно") со следующими пунктами: Cascade, Arrange Icons, Tile Horizontal, Tile Vertical. С их помощью пользователь может управлять дочерними окнами приложения. Обычно нижняя часть меню отделена и представляет список всех открытых окон. Это свойство весьма удобно для быстрого перехода к тому или иному редактируемому файлу.

Модальные окна.

Все SDI-окна можно разделить по свойствам доступа друг к другу как модальные и немодальные. Они определяют, может пользователь или нет переключаться на другие окна. Когда модальное окно открыто, все другие открытые окна становятся недоступными. Пример можно увидеть практически из любой программы, вызвав пункт меню "About" ("О программе"). Отображаемое окно в приложении, как правило, не дает переключится на другое, пока не будет закрыто. Такое свойство иногда бывает очень полезным. Например, когда нужно чтобы пользователь ввел пароль, а затем получил доступ к определенному окну с данными, или окно фильтра данных, указав условия отбора, получает доступ к результату.

Итак, модальными или немодальными могут быть только SDI-окна.

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

Пример MDI-приложения.

1. Запускаем Delphi. В меню "File" выбираем пункт "New Application".

2. Переименовываем свойство имени формы Name из Form1 в MainForm.

3. Устанавливаем свойство в инспекторе объектов FormStyle в fsMDIForm. Его можно выбрать из ниспадающего списка доступных свойств. Свойство означает, что данное окно будет родительским в MDI-приложении.

4. В палитре компонентов выбираем MainMenu. Это второй компонент слева на вкладке Standart. Помещаем его на проектировщик формы Form1. Дважды щелкаем по нему. Появляется конструктор меню окна. Здесь и далее для того, чтобы вызвать конструктор для размещенного в форме компонента главного меню (MainMenu), необходимо или дважды кликнуть по нему мышкой или дважды кликнуть в Object Inspector по свойству Items. Далее, пользуясь свойством Caption задайте меню такой вид, как на рисунке. Примечание: выбрать изменяемый пункт можно мышкой, для изменения названия выберите в инспекторе объектов свойство Caption, для отделения секций меню линией используйте знак тире в свойстве Caption для нужного пункта меню. Создание меню очень простое. Вы сразу видите результат изменения, добавления или удаления пунктов в редакторе формы. Вы всегда можете пополнить пункты меню, используя дополнения, выделенные пунктирной рамкой. Всегда можно вставить или удалить пункт меню в нужное место. Для этого воспользуйтесь правой клавишей мыши. Выбрать интересующее действие можно из выпадающего меню.

Итак, содержание главного меню:

Файл	Правка	Окна	Помощь
Новый	Вырезать	Упорядочить	О программе
Открыть	Копировать
Сохранить	Вставить
Сохранить как…
Закрыть
-
Выход

5. Выбираем пункт меню "Окна" и переименовываем его имя (идентификатор) Name в инспекторе объектов в WindowMenu.

6. Выбираем мышкой форму MainForm. В Object Inspector в свойстве WindowMenu устанавливаем их ниспадающего списка пункт меню WindowMenu. Теперь во время работы приложения все дочерние окна будут списком отображаться в меню "Окна".

7. Поскольку дочерних окон в этом приложении будет много и по внешнему виду они будут подобные, то нет смысла проектировать каждое окно отдельно. Спроектируем одно. Для помещения в проект новой формы выбираем из меню "File" пункт "New Form".

8. Устанавливаем размеры окна Form2 меньшими главного родительского окна.

9. Переименовываем свойство Name для этого окна из Form2 в ChildForm.

10. Устанавливаем свойство дочернего окна для MDI-приложения FormStyle в fsMDIChild.

11. Выбираем из палитры компонентов Memo и устанавливаем его в дочернюю форму ChildForm.

12. Меняем свойство Align для этого компонента на alClient. Он немедленно расширяется на все доступное пространство окна.

13. Далее будем писать событие выбора пункта меню "Новый". При нажатии на него должно появляться дочернее окно. Поступаем следующим образом. Поскольку дочерних окон будет множество, то мы программа должна их автоматически при необходимости создавать. По умолчанию Delphi устанавливает автоматическое создание окна во время запуска приложения. Это избавляет программиста от написания некоторых команд. В данном случае мы все сделаем сами. Выбираем из меню "Project" пункт "Options…". На вкладке Forms снимаем установку "Auto-create forms" для окна ChildForm. Для этого выбираем его и перегоняем одинарной стрелкой в сторону "Available forms". Нажимаем кнопку OK.

14. Сохраняем проект на диске. Для этого проводником Windows создаем отдельную папку для хранения этого примера. В меню "File" выбираем пункт "Save All". Дальше появляются диалоги сохранения модулей окон и файл проекта. Модуль Unit1 родительского окна можно назвать, сохранив его под именем MainUnit. Модуль Unit2 дочернего окна приложения. можно сохранить под именем ChildUnit. Весь проект можно сохранить под именем MyEdit.

15. Теперь напишем в редакторе кода процедуру создания дочернего окна. Выбираем окно MainForm и дважды щелкаем по компоненту MainMenu1. Выбираем пункт меню "Новый". В Object Inspector переходим на вкладку событий Events. Дважды щелкаем по полю, правее OnClick. Или нажимаем Ctrl+Enter. Появляется готовый заголовок процедуры нажатия на пункт меню "Новый". Между begin и end пишем следующую строку:

TChildForm.Create(Self);

Поскольку в этом окне создается другое, то в переименованный модуль MainUnit необходимо подключить ChildUnit. Для этого выбираем из меню "File" пункт "Use Unit…" и указываем модуль ChildUnit. Нажимаем OK.

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

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

Часть урока для продвинутых программистов

Перетаскивание файлов в приложение

Иногда очень полезно избавить пользователя от лишних операций при открытии файла. Он должен нажать на кнопку "Открыть", затем найти интересующий каталог, выбрать файл. Проще перетащить мышкой файл сразу в окно приложения. Рассмотрим пример перетаскивания Drag & Drop в окно произвольного текстового файла, который сразу же открывается в компоненте Memo1.

Простой пример текстового редактора, который рассматривается ниже, можно скачать здесь (3KB).

Для начала в разделе Uses необходимо подключить модуль ShellAPI.

В private области окна нужно вставить следующую строку:

procedure WMDropFiles(var Msg: TWMDropFiles); message WM_DROPFILES; //получение сообщений о переносе файла в окно приложения

Процедура обработки этого сообщения будет выглядеть следующим образом:

procedure TForm1.WMDropFiles(var Msg: TWMDropFiles);
var
CFileName: array[0..MAX_PATH] of Char; // переменная, хранящая имя файла
begin
try
If DragQueryFile(Msg.Drop, 0, CFileName, MAX_PATH)>0 then// получение пути файла
begin
Form1.Caption:=CFileName; // имя файла в заголовок окна
Memo1.Lines.LoadFromFile(CFileName); // открываем файл
Msg.Result := 0;
end;
finally
DragFinish(Msg.Drop); // отпустить файл
end;
end;

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

procedure TForm1.FormCreate(Sender: TObject);
begin
DragAcceptFiles(Handle, True);
end;

С уважением, ведущий уроков Semen semen@krovatka.net

 

Урок6. Палитра компонентов, часть первая

В нескольких уроках будут рассмотрены основные страницы с компонентами, содержащиеся в палитре компонентов главного окна Delphi. Будут рассмотрены описания некоторых свойств, место их применения. На этом занятии будут рассмотрены страницы Standart, Additional и Win32.

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

Поскольку у меня установлена 4 версия Delphi, то объяснять буду именно для нее. В других версиях имеются некоторые различия, но это не меняет всей картины в целом.

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

Страница Standart

Компоненты на этой странице представляют стандартные Windows-элементы (кнопки, списки, меню и т.п.)

TMainMenuпозволяет вам поместить главное меню в окно. Такое меню присутствует в большинство программах. При помещении TMainMenu на проектируемую форму, оно выглядит в виде значка. Для того, чтобы добавить, изменить, удалить пункты меню используйте свойство этого компонента Items в Object Inspector. При этом вызывается окно построителя пунктов меню.

TPopupMenuпозволяет создавать всплывающее меню для многих других компонентов. Это меню появляется при нажатии на правую кнопку мышки на том компоненте, к которому оно привязано. Изменить пункты меню можно аналогично главному меню (свойство Items). Чтобы к конкретному компоненту привязать это всплывающее меню, его необходимо указать в свойстве PopupMenu этого компонента.

TCaption это обычный текст. Его можно редактировать как во время разработки, так и во время работы приложения. Текст можно изменить в свойстве Caption, шрифт меняется в свойстве Font.

TEdit предназначен для ввода пользователем некоторых данных. Обычно им пользуются для ввода цифровых или текстовых данных, пароля (свойство PasswordChar установите маску отображаемых символов, обычно это звездочка). Доступ к тексту - свойство Text. Ограничение количества введенных символов - свойство MaxLength (0 – число символов не ограничено).

TMemo это многострочный компонент для ввода/вывода данных. Может содержать относительно большой текст. Пример его использования вы можете увидеть в стандартном блокноте Windows. Для доступа к тексту используйте свойство Lines. Оно представляет набор строк Strings. Свойство WordWrap указывает нужно или нет производить автоматический перенос текста на новую строку, если она выходит за границы компонента. Этот компонент не работает с текстом формата RTF. Для этого применяйте компонент TRichEdit на вкладке Win32.

TButton это обычная кнопка в вашем приложении. Текст на кнопке задается свойством Caption.

TCheckBox представляет собой текстовую строку с возможностью ее установки в три положения. Свойство Checked true (истинно, установлена галочка), false (ложно, галочка снята). Возможно ее выделить серым в свойстве State в cbGrayed. Текст устанавливается в свойстве Caption. Такие компоненты чаще всего устанавлявают в окна настройки параметров программы, окна поиска.

TRadioButton применяется в списках свойств, где нужно выбрать только одну опцию из нескольких. Текст - свойство Caption, состояние - свойство Checked. Если компонентов TRadioButton на управляющей панели (TPanel, TGroupBox, TForm) несколько, то если пользователь установит флаг на одном, то на остальных он автоматически снимается. Это принцип группировки. Если у вас несколько таких групп, которые используют разные тематики в работе, то устанавливайте их в отдельные панели.

TListBox предназначен для отображения списка строк. От компонента TMemo он отличается только тем, что невозможно непосредственно редактировать текст, пользователь может только выбрать одну или несколько строк в этом списке. Доступ к строкам Lines.

TComboBox напоминает компонент TListBox, но только нужный пункт можно выбрать из ниспадающего списка. Строки хранятся в свойстве Lines. Установленный пункт из списка - свойство ItemIndex. Пример его использования - список шрифтов в текстовых редакторах.

TScrollBar это полоса прокрутки. Используется для прокручивания невидимой части в компоненте.

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

TRadioGroup по внешнему виду похож на компонент TGroupBox. Его отличие лиш в том, что в нем располагаются список компонентов TRadioButton. Список содержится в свойстве Items. Очень удобно использовать этот компонент т.к. он автоматически позиционирует список переключателей после изменения из списка. Свойство ItemIndex показывает какой переключатель сейчас установлен (-1 нет, 0 первый, 1 второй ...).

TPanel по функциональному назначению похож на компонент TGroupBox.

TActionList может содержать список как стандартных действий компонентов (вырезать, вставить, упорядочить значки для MDI-окон), так и есть возможность создать собственные действия.

Страница Additional

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

TBitBtn это таже кнопка TButton, но на ней можно разместить рисунок. Картинка загружается в кнопку с помощью свойства Glyph. Этой кнопке можно задать стандартный вид, изменив свойство Kind. Если вы используете а приложении кнопку без рисунка, то используйте компонент TButton.

TSpeedButton является частью компонента TSpeedBar. Это кнопка, на которой обычно располагается только картинка без текста. Границы этой кнопки можно спрятать, изменив свойство Flat на true. В таком случае этот компонент будет выделен только в том случае, когда указатель мыши находится над ним. Пример - кнопки на палитре компонентов и кнопки быстрого запуска команд меню.

TMaskEdit похож на компонент TEdit, но позволяет вводить данные определенного формата. Например телефон 555-55-55. Этот формат указывается в свойстве EditMask.

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

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

TImage может содержать рисунок большинства широко распространенных форматов. Рисунок устанавливается в свойстве Picture. Установленный рисунок можно центрировать (Center), вписать в рамки компонента увеличив или уменьшив (Stretch), сделать прозрачным относительно нижней левой точки рисунка (Transparent).

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

TBevel применяется только для украшения внешнего вида окон. Может принимать вид приподнятых (опущенных) панелей из свойства Style. Может стать линией, квадратом, пунктирным квадратом с помощью свойства Shape.

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

TCheckListBox по внешнему виду похож на компонент TListBox, но в его строках Items есть переключатели, аналогичные TCheckBox. Доступ к которым можно получить только во время работы приложения через свойство Checked[N], где N - индекс строки. Если установлено true, значит галочка стоит, если false - наоборот.

TSplitter позволяет изменять границы компонентов, к которым он прилегает. Может быть как вертикальным (Свойство Align в alLeft или alRight), так и горизонтальным (Align alTop или alBottom).

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

TControlBar применяется для современного оформления меню, кнопок быстрого доступа. В нем панели можно передвигать мышкой. Пример вы можете увидеть в главном окне Delphi. Там главное меню, кнопки, панель палитры компонентов расположены на компоненте TControlBar.

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

Страница Win32

Компоненты на странице Win32 обеспечивают доступ к 32-битным элементам Windows (Windows95/NT).

TTabControl это страничный компонент подобный картотеке или записной книжке. Этот компонент обеспечивает выбор нужной страницы из массива имеющихся. Список страниц находится в свойстве Tabs.

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

TImageList может содержать в себе список хранящихся вместе изображений. Доступ к ним осуществляется через индекс. Для изменения списка хранимых изображений дважды щелкайте по этому компоненту. Все изображения в нем должны иметь одинаковый размер. Используйте свойства Height и Width для задания ширины и высоты изображения. Эти изображения в последствии через индекс можно размещать на TMainMenu, TPopupMenu, TPageControl, TToolBar, TTreeView, TListView и т.д. Необходимо помнить, что все загружаемые в этот компонент изображения, как и в любом другом компоненте с изображением, линкуются в исполняемый EXE файл.

TRichEdit в отличие от компонента TMemo может содержать форматированный текст RTF. Это текст с разными шрифтами, цветом. Пример вы увидите в текстовых редакторах MSWord или WordPad.

TTrackBar представляет собой многопозиционный бегунок. Его полезно использовать для задания данных из допустимого диапазона. Минимальный и максимальный диапазон данный устанавливается в свойстве Min и Max, а текущую позицию можно узнать или установить с помощью свойства Position. Этот бегунок можно увидеть в регуляторе громкости.

TProgressBar это простой индикатор процесса работы. Его можно увидеть в момент копирования файлов, форматирования диска. Минимальные и максимальные значения хранятся в свойстве Min и Max. Текущая позиция Position. Величина шага перемещения указателя - свойство Step. Само перемещение указателя прогресса осуществляется командой StepIt. Например, необходимо скопировать семь файлов. Изначально программно или на этапе проектировки задаем свойства Min=0, Max=7, Step=1, а после копирования каждого из файлов применяем StepIt.

TUpDown размещается с целью задания величин с последующим пошаговым изменением. Сама величина не отображается. Свойства схожи с компонентом TTrackBar. В свойстве Increment задается величина шага изменения значения. Если необходимо отображать результат тут же, то воспользуйтесь компонентом TSpinEdit на странице Samples.

THotKey позволяет задавать или отображать на экран комбинацию клавиш. Комбинация содержится в свойстве HotKey.

TAnimate представляет собой замечательный компонент оживления ваших приложений. С его помощью вы можете вставить анимированный видеофрагмент в вашу форму, прокрутить стандартную Windows анимацию. Файл загружается с указанного свойства FileName, а стандартную Windows анимацию устанавливают в свойстве CommonAVI. Для начала проигрывания не забудьте установить Active в true.

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

TMonthCalendar это обычный календарь для выбора даты. Попробуйте его растянуть - можно даже увидеть весь год. Свойство установленной даты - Date.

TTreeView может показывать древовидную структуру данных. Например каталоги. Пользуйтесь свойством Items для изменения дерева. В дереве могут присутствовать изображения. Тогда к нему нужно привязать массив изображений TImageList и указывать для каждого элемента дерева индекс рисунка.

TListView широко известный компонент, применяемый в проводнике Windows. Может содержать большие, мелкие значки, список. Свойство Items содержит список выводимых элементов.

THeaderControl используйте его, чтобы отобразить заголовок колонок текста или чисел.

TStatusBar является нижней панелью, которая отображает информацию, как работает приложение. Практически повсюду применяется. В текстовых редакторах на такой панели можно узнать о состоянии кнопок Caps, Num, Scroll, узнать изменен или нет документ, на какой странице находится указатель и т.п.

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

TCoolBar представляет собой некий контейнер для компонентов. Там их легко позиционировать, перемещать. Такой элемент расположен в Internet Explorer.

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

С уважением, ведущий уроков Semen semen@krovatka.net

 

Урок7. Палитра компонентов, часть вторая

Продолжаем рассматривать элементы в палитре компонентов. На этом занятии будут рассмотрены страницы System, Dialogs, Samples.

Страница System

На этой странице находится набор компонентов для доступа к системным ресурсам, таким как OLE, DDE.

TTimer создает событие OnTimer, интервал которых задан с свойстве Interval. Этот интервал задается в миллисекундах и работает относительно точно. Тем не менее не рекомендуется его применение при точных вычислениях. С помощью свойства Enabled счетчик можно запустить (true) или остановить (false).

TPaintBox компонент для рисования. Доступ к графике через Canvas.

TMediaPlayer работает с изображением и звуком. Использует стандартный драйвер мультимедиа. Имеет вид готовой к работе панели управления устройством управления (кнопки Play, Stop и т.п.).

TOLEContainer это компонент, содержащий OLE-объекты. Привязанные объекты во время проектировки приложения линкуются в исполняемый EXE файл.

TDDEClientConv представляет собой связь с DDE сервером. Посылает данные или макрокоманды на сервер DDE после того, как связь была установлена. Это стандартные методы обмена данными между приложениями. Пример вы можете найти в стандартной поставке примеров Delphi.

TDDEClientItem определяет обмен данными между DDE приложениями. Он содержит в себе данные, которые передаются. Используйте этот компонент вместе с TDDEClientConv, чтобы позволить приложению действовать как клиент DDE, и иметь возможность передать данные.

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

TDDEServerItem представляет собой обмениваемые данные в DDE приложении.

Страница Dialogs

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

TOpenDialog это диалог открытия файла. Этот и все другие диалоги активируются через функцию Execute. Если возвращаемое значение равно true, значит пользователь выбрал файл (принтер, шрифт и т.п.) и нажал на кнопку Ok в этом диалоговом окне. Тогда имя открываемого файла содержится в свойстве FileName. Обычно процедура вызова подобного диалогового окна выглядит следующим образом: if OpenDialog.Execute then Memo.Lines.LoadFromFile(OpenDialog.FileName); Здесь показан пример загрузки текстового файла в компонент Memo (страница Standart), выбранного с помощью диалога открытия файла OpenDialog. Текст заголовка диалога в свойстве Title. Фильтр, который будет отфильтровывать файлы по расширению указывается в свойстве Filter. Его целесообразно установить сразу во время разработки проекта, поскольку при этом открывается удобная для занесения значений таблица. Свойство InitialDir указывает программе каталог по умолчанию, который будет открыт в диалоговом окне. Если это свойство не задано, то берется каталог, из которого запущена программа.

TSaveDialog - диалог сохранения файла. Свойства и работа подобны диалогу TOpenDialog.

TOpenPictureDialog - диалог открытия рисунка. В отличие от TOpenDialog имеет внутренний предварительный просмотр рисунка в открываемом файле. Кроме того уже имеет некоторые заданные свойства фильтра Filter, который содержит все распознаваемые в этом диалоге форматы графики.

TSavePictureDialog - диалог сохранения рисунка.

TFontDialog - вызывает стандартный диалог выбора шрифта. Свойство Font содержит как изначальный (выбранный по умолчанию) шрифт, так и измененный, после вызова диалога. FontDialog1.Font := Edit1.Font; if FontDialog.Execute then Edit.Font := FontDialog.Font; Здесь показан пример изменения шрифта в компоненте Edit. Причем во время вызова диалога FontDialog в нем изначально будет установлен шрифт, заданный в компоненте Edit. Свойство Device указывает типы отображаемых шрифтов. fdBoth - все, fdPrinter - принтерные, fdScreen - экранные. MaxFontSize MinFomtSize устанавливает границы минимального и максимального размера шрифта. Цифра 0 - размер ограничивается только возможностями данного шрифта.

TColorDialog - диалог выбора цвета. Цвет по умолчанию и измененное хранится в свойстве Color.

TPrintDialog - диалог выбора принтера, выбора количества копий, страниц, свойства печати и т.п.

TPrinterSetupDialog - диалог выбора принтера.

TFindDialog - диалог поиска фрагмента текста в документе.

TReplaceDialog - диалог замены текста в документе.

Страница Samples

TGauge это графически улучшенный ProgressBar. Содержит в себе надпись процента выполнения действия. В свойствах MinValue, MaxValue, Progress указаны соответственно минимальное, максимальное и текущее значение. Свойство BackColor содержит цвет фона, а ForeColor - цвет заполнения. Свойством Kind можно задать разный тип отображения индикатора.

TSpinEdit по своему функциональному назначению схож с компонентом TUpDown (страница Win32). Значение Value видно сразу в момент его изменения в индикаторе. Кроме того значение можно корректировать с помощью цифр.

TDirectoryOutline показывает древовидный список каталогов.

TCalendar - календарь. Свойство Year, Month, Day (год, месяц, день) разбиты на три отдельные части.

С уважением, ведущий уроков Semen semen@krovatka.net

 

Урок8. Модули. Заставка программы

Часть урока для новичков

Как уже упоминалось в первых уроках, основой Delphi есть язык программирования Object Pascal. В своей основе он содержит так знакомый всему миру и очень популярный язык Pascal. Разумеется, для того, чтобы довольно быстро и без особых проблем изучить Delphi, необходимо знать этот язык. Для начинающих рекомендуется ознакомиться с ним. Потребуется знание элементарных понятий синтаксиса, типов данных, структур модулей программ.

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

 

Итак, основой любого языка программирования есть команда присваивания и выглядит как двоеточие и знак равенства :=

Здесь сразу нужно оговориться, что знак присваивания указывает на внесение указанной переменной некоторого значения, например:

 

x := 10;

 

Где x - переменная.

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

 

Каждый оконный проект в Delphi имеет один текст программы и как минимум один модуль.

Что же такое программа. Она храниться на диске с названием заголовка программы и расширением DPR. Вот ее архитектура:

 

program Project1; uses Forms, Unit1 in 'Unit1.pas' {Form1}; {$R *.RES} begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end.

Заголовок программы   Список подключаемых модулей   Поключаемые файлы ресурсов     Текст программы

Файл программы состоит из заголовка и блока программы. Блок программы включает объявление подключаемых модулей (частей программы), подключаемые ресурсные файлы (иконки, указатели мыши, рисунки), текст программы (создание окон, запуск приложения на выполнение).

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

Заголовок или название программы всегда должен совпадать с названием проекта. Если вам необходимо изменить название проекта, то следует пересохранить проект под другим именем.

 

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

Структура модуля:

 

unit Unit1; interface uses Windows, SysUtils, Forms; type TForm1 = class(TForm) private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.DFM} end.

Заголовок модуля   Заголовки доступных свойств   подключаемые модули     описание типа   скрытый раздел свойств   открытый раздел свойств   описание переменной     Описание свойств   Подключаемые файлы ресурсов

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

Если переименовать форму Form1 в MainForm, добавить в не компонент Memo1, и задействовать событие OnChange (изменение текста внутри этого компонента) то программный код изменится следующим образом:

 

unit Unit1;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type
TMainForm = class(TForm) // изменяется описание класса этой формы
Memo1: TMemo; // добавляется компонент Memo1 из класса TMemo
procedure Memo1Change(Sender: TObject); // заголовок процедуры
private
{ Private declarations }
public
{ Public declarations }
end;

var
MainForm: TMainForm; // задание переменной формы

// из объявленного класса

implementation

{$R *.DFM}

procedure TMainForm.Memo1Change(Sender: TObject);
begin
// здесь следует текст реакции на событие изменения текста

// в компоненте Memo1
end;

end.

Примечание: после двойной дроби // следует комментарий.

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

 

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

Напомню, что в пример был начат в уроке 5 и его можно скачать здесь. Это простое MDI-приложение, где все открываемые файлы в отдельных дочерних окнах размещаются внутри родительского окна (принцип можно увидеть на примере текстового редактора MS Word).

 

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

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

Для этого сначала отображаем проектируемую форму ChildForm на экран. Для этого нажимаем комбинацию клавиш Shift+F12 или выбираем пункт "Forms..." в меню "View". В появившемся окне выбираем эту самую форму и нажимаем Ok.

Выделяем компонент Memo1 в проектируемой форме одинарным щелчком мышки. В инспекторе объектов находим свойство этого компонента Lines. Изменяем это свойство, нажав на кнопку с троеточием в поле с TStrings. Появляется окно String List Editor, в котором надо убрать все буквы, оставив его пустым. Далее нажимаем Ok.

Теперь мы видим в проектировщике формы ChildForm, что компонент Memo1 не содержит никаких строк.

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

В верхней части Object Inspector есть ниспадающий список, в котором нужно выбрать ChildForm. Далее переходим на вкладку событий Events. Находим событие OnClose (закрытие окна) и дважды щелкаем по пустому полю правее. Создается готовый каркас процедуры закрытия окна с заголовком:

 

procedure TChildForm.FormClose(Sender: TObject; var Action: TCloseAction);

 

Здесь вносимый в процедуру параметр Action определяет поведение данной формы при закрытии. Он может принимать следующие значения:

caNone - форма не предпринимает никаких действий.

caHide - форма причется от глаз пользователя, но не уничтожается из памяти. Поскольку мы с вами "вручную" (программно) создаем дочернюю форму, то нам нужно ее при закрытии уничтожить из памяти.
caFree - форма закрывается и уничтожается из памяти.
caMinimize - форма минимизируется. Это значение для MDI-дочерних окон установлено по умолчанию.

Пишем внутри созданной процедуры:

 

Action := caFree;

 

Теперь запустите приложение на выполнение (F9) и посмотрите на ее работу.

 

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

Итак, открывается файл при выборе пункта меню "Открыть", которое находится в главной форме. Отображаем проектируемую форму MainForm поверх всех окон (Shift+F12). Устанавливаем в форму компонент OpenDialog. Он находится на палитре компонентов на странице Dialogs.

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

Выделяем его и в инспекторе объектов устанавливаем следующие свойства:

Свойство Title устанавливает заголовок такого окна. Заносим в это свойство строку "Открыть текстовый файл".

Свойство Filter фильтрует список по расширению в названиях файлов. Нажимаем на троеточие в этом свойстве. На экран выводится окно Filter Editor, в котором можно легко задать все возможные маски файлов. В левой части Filter Name пишется отображаемое в фильтре название. В правой части Filter сам фильтр. Пишем так, как указано на рисунке. Нажимаем на Ok.

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

Выбираем пункт меню "Файл" в форме MainForm и выбираем пункт "Открыть". Создается пустая процедура реакции на событие выбора этого меню. В ней пишем:

 

if OpenDialog1.Execute then // если файл выбран, то выполнять следующее
begin
ChildForm := TChildForm.Create(Self); // создать дочернее окно
ChildForm.Memo1.Lines.LoadFromFile(OpenDialog1.FileName); // загрузить в Memo1 выбранный файл
ChildForm.Caption := OpenDialog1.FileName; // установить заголовок дочернего окна в название файла
end;

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

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

Функция Execute для компонента OpenDialog1 вызывает диалоговое окно открытия файла и возвращает значение исхода выбора. Если значение равно true (истинно), то файл был выбран и false (ложно) - пользователь нажал на "Отмена".

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

 

Часть урока для продвинутых программистов

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

Итак, зачем же это окно все-таки нужно? Допустим, вы пишите относительно большую программу, и соответственно ее процесс загрузки занимает весьма продолжительное время, в течениии которого пользователь на экране монитора ничего не видит. Сидит и думает, а запустил ли я эту программу или нет, и пробует снова. Это первая причина. Ну, а остальные - это возможность приукрасить внешний вид, придать солидность, марку фирмы (профессиональности) изготовителя.

Что же в себе содержит окно-заставка? Да все, что угодно. От бесполезной информации, до названия программы, версии продукта, лицензии и контактного телефона. Лучше всего все это дело организовать в прямоугольный рисунок с максимальным размером 640х480 (минимальное экранное разрешение).Такой пример вы видите выше. И этот рисунок надо разместить в отдельной форме.

Рассмотрим пример. Ваша программа имеет название PROJECT1, главное окно проекта называется FORM1, окно с заставкой FORM2.

У окна Form2 устанавливаем свойства Position в poScreenCenter (располагать это окно посередине экрана), свойство BorderStyle в bsNone (окно без заголовка). Дальше размещаем в этом окне компонент TImage. Загружаем в него изображение через свойство Picture и устанавливаем свойство для рисунка и окна AutoSize в true. Все, рисунок имеет размер всего окна, а размер окна автоматически подстраивается под размер рисунка.

Дальше открываем файл проекта DPR на редактирование из меню "Project" пунктом "View Source".

Там мы видим следующие строки:

 

Application.Initialize; // инициализация приложения
Application.CreateForm(TForm1, Form1); // создать главное окно
Application.CreateForm(TForm2, Form2); // создать окно-заставку

// дальше могут быть создано много окон в приложении
Application.Run; // запустить приложение

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

Вот пример:

 

Application.Initialize; // инициализация приложения
Form2 := TForm2.Create(Application); // создать окно-заставку
Form2.Show; // сделать окно видимым
Form2.Update; // перерисовать окно

//(поскольку приложение еще не запущено, это необходимо делать вручную)
Application.CreateForm(TForm1, Form1); // создать главное окно

// дальше создаются все остальные окна в вашей программе
Form2.Close; // закрыть окно-заставку
Application.Run; // запуск приложения

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

Для этого делаем так.

Во-первых, убираем строку Form2.Close; из файла проекта. Дальше устанавливаем свойство FormStyle окна Form2 в fsStayOnTop (окно будет всегда отображаться поверх всех, что позволит пользователю любоваться им даже после появления главного окна). Устанавливаем в окно Form2 компонент TTimer. Устанавливаем свойство Interval в минимальный промежуток видимости этого окна. Например 3000 - 3 секунды. Событие срабатывания таймера:

 

procedure TForm2.Timer1Timer(Sender: TObject);
begin
Timer1.Enabled:=false; // заблокировать дальнейшее применение таймера
if Form1.Visible then Close; // если главное окно уже видно, то закрыть окно-заставку
end;

Эта часть программы имеет пользу только, если прошло три секунды, уже на экране есть главное окно и необходимо закрыть заставку. А если прошло более трех секунд и только тогда появилось главное окно, то заставка закрывается сразу. Для этого событие OnShow для главного окна Form1 содержит только одну строчку:

 

procedure TForm1.FormShow(Sender: TObject);
begin
ifnot Form2.Timer1.Enabled then Form2.Close; // если таймер уже отключен, то закрыть

// окно-заставку. Если оно уже закрыто, то ничего не происходит
end;

Теперь пользователь может наблюдать одно и то же в момент каждого запуска.

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

 

procedure TForm2.FormCreate(Sender: TObject);
begin
if FileExists('splash.gif') then // если файл с рисунком есть в текущем каталоге
try
Image1.Picture.LoadFromFile('splash.gif'); // загрузить рисунок
except
MessageDLG('Ошибка загрузки рисунка',mtError,[mbOk],0); // если загрузка рисунка

// не удалась, то выводится сообщение об ошибке
end;
end;

Этот готовый примерчик можно скачать здесь.

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

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

 

Form2.Label1.Caption:='создание главного окна';

Form2.Label1.Update;

Application.CreateForm(TForm1, Form1);
Form2.Label1.Caption:='создание окна Form3';

Form2.Label1.Update;

Application.CreateForm(TForm3, Form3);

// и т.д. и т.п.

 

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

С уважением, ведущий уроков Semen semen@krovatka.net

 

Урок9. Процедуры и функции. Главное меню

Часть урока для новичков

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

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

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

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

Далее следует сам программный блок процедуры или функции, заключенный в операторные скобки begin и end.

Пример процедуры:

 

procedure MyProcedure (InData: Integer); // заголовок процедуры. InData - вносимый параметр

Var i1,i2,i3: Integer; // описание переменных в данной процедуре

begin

// текст программы

end;

 

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

Пример функции:

 

function MyFunction (InData: Integer): Integer; // возвращаемый тип данных - Integer

Var i1,i2,i3: Integer;

begin

// текст программы

Result:= 1; // возвращаемое значение

end;

 

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

 

function MyFunction (x: String): String;

begin

Result:= x+'рамма';

end;

 

procedure MyProcedure;

begin

ShowMessage(MyFunction('прог'));

end;

 

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

1. Вход в процедуру MyProcedure.

2. Вызывается функция MyFunction и управление передается в нее. При этом туда передается строковый параметр "прог".

3. В функции выполняется арифметическая операция со строкой. К вносимому параметру прибавляется строка "рамма" и все это передается в качестве возвращаемого параметра функции Result.

4. Возвращение в процедуру MyProcedure. Теперь MyFunction принимает значение "программа" и это значение передается в качестве параметра в процедуру ShowMessage.

5. Процедура ShowMessage является стандартной (она описана в стандартном модуле, автоматически подключаемом изначально). Эта процедура производит вывод окошка с сообщением и кнопкой Ok.

6. После вывода окошка с текстом "программа" текущая позиция выполнения программы выходит из процедуры MyProcedure в то место, откуда она была вызвана.

 

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

 

 

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

В почти каждом MDI-приложении есть меню "Окно" или "Window", в котором первыми пунктами стоят различного рода операции с позиционированием дочерних окон. Сделаем что-то подобное в нашем многооконном приложении.

Открываем проект на приложении в среде программирования Delphi. Комбинацией клавиш Shift+F12 выводим на экран главную форму MainForm.

Начиная с версии Delphi 4, на странице палитры компонентов Standart есть компонент TActionList. Его назначение, а также другие полезные компоненты можно узнать из урока№ 6. Устанавливаем этот компонент на проектировочную форму MainForm. Дважды щелкаем по нему мышкой или выбираем пункт "Action List Editor" из выпадающего меню по правой кнопке мыши. Открывается окно изменения действий. Нажимаем комбинацию клавиш Ctrl+Ins, или выбираем пункт "New Standart Action" из ниспадаюшего меню на желтой кнопки.

Появляется окно доба