Многооконный интерфейс. Создание MDI-приложения , страница 3
Вместо дополнительных байт окна приложение может использовать его свойства. Преимущество применения свойств состоит в том, что при регистрации класса окна не требуется выделять дополнительное пространство под данные. Кроме того, свойства представляются в виде строк, которые могут сами пояснять свое назначение. В подобных случаях значение свойства окна служит указателем на структуру данных, связанную с этим окном.
Наконец, для некоторых приложений имеет смысл хранить отдельные структуры данных в списке и включать дескриптор окна, связанного со структурой данных, как часть самой структуры. Затем потребуется лишь проанализировать связанный список, сопоставляя дескрипторы окна в структуре данных с дескриптором окна, предоставленным процедуре окна, чтобы определить, для какой структуры данных предназначается сообщение.
Меню в MDI-приложениях
Строка меню главного окна MDI должна включать выпадающее меню Window (Окно). Обычно оно предшествует выпадающему меню Help и содержит пункты Tile (Мозаика), Cascade (Каскад), Arrange Icons (Упорядочить значки) и Close All Child Windows (Закрыть все дочерние окна). Это реализуется при помощи сообщений окна, о которых речь пойдет ниже. Кроме того, клиентское окно MDI добавляет имена вновь созданных дочерних окон в нижнюю часть выпадающего меню, который указывается при создании клиентского окна MDI.
На рис. 27.2 показано простое MDI-приложение. Открыто четыре дочерних окна, из которых одно свернуто в значок в нижней части клиентского окна MDI. Стоит обратить внимание на меню Window. Клиентское окно MDI динамически поместило имена четырех дочерних окон в нижнюю часть раскрывающегося меню, а также установило отметку рядом с именем окна, активного в данный момент.
Windows предоставляет MDI-приложениям несколько комбинаций клавиш сокращенного доступа. Для их реализации не требуется дополнительного кода. Функции сокращенного доступа реализуются просто за счет использования MDI-версий стандартных функций обработки сообщений в главном и дочерних окнах, применения функции трансляции клавиши сокращенного доступа MDI в главном цикле сообщений, а также при помощи клиентского окна класса MDICLIENT. Описание этих комбинаций клавиш приводится в табл. 27.2.
Таблица 27.2 Комбинации клавиш сокращенного доступа для MDI-приложений
Создание MDI и SDI интерфейсов: разработка меню, панели инструментов, стандартных диалоговых окон, строки состояния, контекстного меню
Имеется два типа интерфейсов: SDI (Single Document Interface однодокументный интерфейс) и MDI (Multi Document Interface многодокументный интерфейс). SDI-приложения работают одновременно с одним документом, MDI-приложения предназначены для одновременной работы со множеством однотипных документов. При этом все документы располагаются внутри одного контейнера, которым служит, как правило, главная форма. Компания Microsoft не рекомендует использовать MDI-интерфейсы, хотя сама использует их в различных служебных программах, например, в консолях вроде Диспетчера устройств. Кроме того, разработка MDI-приложений в Lazarus пока не реализована.
Главное отличие MDI-отSDI-приложения состоит в том, что SDI-приложение содержит только одно окно документа, a MDI-приложение способно содержать несколько таких окон, что дает пользователю возможность параллельной работы с несколькими документами.
В SDI-приложениях окна могут быть двух видов модальные и немодальные. Создаются они одинаково, разница заключается только в способе вывода этих окон на экран. Модальное окно блокирует программу, не даёт с ней работать, пока вы это окно не закроете. Стандартный пример модального окна — окно «О программе», которое присутствует почти в любом приложении. Как правило, такое окно находится в меню «Справка». Пока вы не нажмете «ОК», закрыв это окно, вы не сможете работать с основной программой.
Немодальные окна позволяют переключаться между ними, и программой, и работать одновременно и там, и там. Типичный пример — окна Lazarus вы можете переключаться между Инспектором объектов, Редактором кода, Редактором форм, и другими окнами — они не мешают друг другу, так как все они немодальные.
В отличие от Delphi, в Lazarus пока не реализована возможность создания MDI-приложений, а поскольку MDI-интерфейсы считаются устаревшими, то возможно, она и не будет реализована. Но знать об этих интерфейсах нужно, поэтому вкратце коснемся этой темы, тем более, что я могу ошибаться, и в следующих версиях Lazarus разработчики эту возможность все же реализуют.
Для реализации MDI-интерфейса сами разработчики рекомендуют установить дополнительный компонент MultiDoc, который реализует псевдоMDI-интерфейс.
Среды визуального программирования
В настоящее время на рынке программного обеспечения наиболее распространенными и покупаемыми являются такие среды визуального программирования как Borland Delphi, С++ Builder, Visual Studio 2005 Standard Edition.
Borland Delphi – это проверенный продукт, предназначенный для разработки приложений в среде WINDOWS 95/98/2000/Me/NT/XP. Его популярность на рынке программного обеспечения обеспечивается следующими факторами:
-сочетание классических принципов программирования и современных технологий. Delphi объединяет визуальные средства быстрого создания приложений, высокопроизводительный (до 350000 строк кода в минуту на Pentium 90) компилятор объектно-ориентированного языка, компонентную архитектуру среды разработчика, масштабируемый механизм доступа к базам данных;
-возможность многократно использовать однажды созданный код, уменьшая тем самым время и усилия, затрачиваемые на разработку;
-быстрый компилятор делает процесс разработки интерактивным;
-настоящий машинный код работает в 10-20 раз быстрее, чем в системах на основе интерпретатора;
-достигается высочайшая скорость разработки за счет использования набора встроенных компонент, средств визуального проектирования и отладки RAD — Rapid Application Development;
-прототип превращается в целевую систему без переработки;
-приложения и компоненты создаются с помощью одного инструмента – объектно-ориентированного языка программирования Object Pascal;
-осуществлять поддержку приложений баз данных, которая состоит в организации доступа к базам данных и управление данными из приложений через процессоры баз данных, таких как Borland Database Engine или ActiveX Data Objects фирмы Microsoft, а также разрабатывать приложения клиент-сервер для баз данных на основе SQL-серверов;
-разрабатывать Интернет — приложения и Web-серверные расширения;
-создавать собственные компоненты, библиотеки динамической компоновки DLL и пакеты, разрабатывать COM-приложения;
-использовать механизмы ActiveX и OLE Automation — высокоуровневые программные технологии, основывающиеся на COM.
Вывод: Delphi является продуктивной и производительной средой для создания приложений, что обусловлено следующими аспектами: скоростью работы компилятора и высоким быстродействием откомпилированных программ, гибкостью и масштабностью используемой базовой архитектуры.
C++ Builder, также как и Borland Delphi, относится к RAD_системам.
С++ Builder имеет те же возможности, что и Delphi, однако имеет и существенные преимущества, такие как:
— визуальная среда разработки, имеет ряд дополнительных функций, по сравнению с Delphi, что облегчает и ускоряет разработку приложений; наличие библиотеки шаблонов STL (Standard Template Library);
— поддержка библиотеки MFC (Microsoft Foundation Classes); возможность импорта и дальнейшей компиляции приложений Visual C++, работающих с MFC;
— больший, по сравнению с Delphi, объем сервисных функций; гибкость и расширяемость языка C++, за счет возможности перегрузки операторов, создания библиотек шаблонов и т.д.
К числу достоинств С++ Builder можно отнести:
— универсальность, краткость и относительно низкий уровень;
— адекватность большинству задач системного программирования.
К недостаткам можно отнести синтаксис языка. В силу своей гибкости, может сделать код программы сложно читаемым и не содержит средств мультипрограммирования, параллельных процессов, синхронизации и организации сопрограмм.
Вывод: С++ Builder – это универсальный язык программирования с компактным способом записи выражений, современными механизмами управления данными и богатым набором операторов. Кроме того, он поддерживает абстракцию данных с помощью механизма классов и обеспечивает объектно-ориентированное программирование и позволяет вводить собственные типы данных, соответствующие решаемым задачам.
Visual Studio 2005 Standard Edition.Эта версия Visual Studio представляет собой профессиональный инструмент начального уровня. В нем сочетается простота версий Express и мощные средства разработки, необходимые для:
— создания бизнес-приложений с использованием языков Visual Basic, С#, C++;
— создания Windows — и веб-приложений, приложений для портативных устройств;
— создания клиент-серверных приложений с использованием веб-служб, и приложения для работы с данными, для чего есть встроенные инструменты.
Также Visual Studio позволяет:
— использовать возможности по генерированию отчетов SQL Reporting Services для оформления выводимых данных;
— расширять возможности Visual Studio с помощью инструментов третьих фирм;
— создавать корпоративные веб-приложения масштаба подразделения, используя средства отладки и прекомпиляции сайтов.
Вывод: Visual Studio.net на сегодняшний день является одной из самых продуктивных и производительных сред для создания приложений, что обусловлено следующими важнейшими аспектами:
-универсальным межъязыковым интерфейсом;
-качеством визуальной среды обработки;
-скоростью работы компилятора и высоким быстродействием откомпилированных программ;
-гибкостью и масштабностью используемой базовой архитектуры.
Интерфейсы SDI и MDI
Операционная система Windows предоставляет возможность разрабатывать
приложения в одной из двух разновидностей интерфейса:
•SDI (Single Document Interface) – однодокументный интерфейс.
•MDI (Multiple Document Interface) – многодокументный интерфейс.
Каждый из указанных стилей интерфейса обладает своими уникальными
возможностями и соответственно особенностями программирования. Характерными представителями интерфейса MDI являются большинство текстовых редакторов, электронных таблиц и программ работы с графикой, короче говоря, приложений, способных одновременно работать с несколькими документами, открытыми в отдельных дочерних окнах. Все дочерние окна приложения MDI размещаются в клиентской области главного окна приложения.
Чтобы далеко не ходить за примером,
предлагаю взглянуть на утилиту Sysedit.exe, предназначенную для редактирования системных файлов (она
входит в стандартную комплектацию
Windows). Для этого в строке ввода
Открыть надо набрать команду Sysedit
(рис. 9.5) и нажать кнопку ОК.
В результате на экране монитора отобразится редактор файлов настройки, позволяющий опытному пользователю внести некоторые поправки в процесс инициализации Windows. Хочу предупредить, что без особой необходимости не стоит вносить изменения в файлы настройки.
Как я и обещал, перед вами появилось
несколько дочерних окон, расположенных внутри главного окна (рис. 9.6). Вы не сможете переместить дочерние окна за пределы главного, и все управление дочерними окнами осуществляется из общего главного меню программы. Приложение SDI также строится на базе главного и дочерних окон, но его дочерние окна имеют гораздо больше степеней свободы: они не столь крепко
привязаны к главной форме проекта
и могут свободно разгуливать по всему пространству рабочего стола. В качестве примера классического приложения SDI может выступать Delphi. Главным окном Delphi служит форма, на
которой расположены главное меню, палитра компонентов и «быстрые» кнопки. Остальные окна (окна проекта, Инспектор объектов и др.) являются дочерними.
Дата добавления: 2020-03-15 ; просмотров: 1595 ; ЗАКАЗАТЬ НАПИСАНИЕ РАБОТЫ
Работа с многодокументными (MDI) формами
Другая разновидность форм — многодокументные, или MDI-формы. Интерфейс MDI позволяет открыть сразу несколько окон внутри родительского окна-контейнера. Скажем, в главном окне типичного текстового редактора (классический пример — Word for Windows) можно открыть несколько документов (рис. 2.7). Главное окно выполняет функции контейнера, а дочерние формы находятся внутри него. MDI-приложения появились в те времена, когда на рынке преобладали ранние версии Windows. Многодокументные приложения позволяли одновременно открывать несколько файлов, не запуская нескольких копий одной программы. Это экономило не только время, но и память.
Рис. 2.7. Несколько документов в родительском окне-контейнере
Интерфейс MDI обычно используется для документно-ориентированных приложений (например, текстовых или графических редакторов). Программа называется документно-ориентированной, если она предназначена для работы с документами. Если пользователи приложения должны одновременно работать с несколькими формами, выбирайте модель MDI. Visual Basic позволяет очень просто создавать MDI-приложения.
Создание MDI-приложения
Для создания MDI-приложения необходимо иметь как минимум две формы — родительскую (контейнер) и дочернюю (внутреннюю). Чтобы работать с дочерними формами различных типов, необходимо включить в проект дополнительные формы. Тем не менее для простейшего MDI-проекта одной формы вполне достаточно. Проект создается так:
1. Создайте новый проект командой File >• New Project. Если у вас включен Project Wizard, выберите тип проекта Standard EXE.
2. В созданном проекте изначально присутствует одна форма. Задайте ее свойству Name значение frmChild, а свойству Caption — Дочерняя форма MDI.
3. Чтобы создать родительскую форму MDI, щелкните правой кнопкой мыши на папке Forms в окне проекта и выполните команду Add > MDI Form. Когда на экране появится окно Form Wizard, выберите в нем MDI Form.
4. Задайте свойству Name значение frmMDI, а свойству Caption — значение Родительская форма MDI
5. Щелкните правой кнопкой мыши на строке Project1 в окне проекта и выберите из контекстного меню команду Project1 Properties. Выберите из списка Startup Object строку frmMDI. Если не сделать этого, в начале работы вашего приложения будет отображаться дочерняя форма.
6. Выберите в окне проекта строку frmChild. Задайте свойству MDI Child значение True — теперь дочерняя форма будет находиться внутри родительской.
7. Выберите в окне проекта строку frmMDI.
8. Запустите редактор меню командой Tools > Menu Editor. Появляется окно, изображенное на рис. 2.8.
Рис. 2.8. Редактор меню
В своем примере мы ограничимся очень простым меню. Не беспокойтесь о технических подробностях работы с редактором меню — они будут рассмотрены в уроке 5, «Создание и использование меню и панелей инструментов».
1. Введите &File в поле Caption.
2. Введите mnuFile в поле Name.
3. Нажмите кнопку Next.
4. Нажмите кнопку со стрелкой вправо — у команды меню появляется отступ.
5. Введите &New Form в поле Name.
6. Введите mnuFileNew в поле Name.
7. Закройте редактор меню кнопкой ОК.
8. В форме frmMDI должно появиться меню File. Выполните команду File > New, и на экране появится окно программы.
9. Вставьте в процедуру события mnuFileNew_Click() следующий фрагмент:
Dim frm As New frmChild
10. Сохраните и запустите проект. На рисунке показан примерный вид окна MDI-ириложения.
Добавленный нами фрагмент создает новую копию формы frmChild и отображает ее. Это происходит при каждом выполнении команды File > New. Попробуйте открыть и закрыть несколько дочерних окон; как видите, мы построили вполне рабочее MDI-приложение.
Новая версия MDI-приложения
Чтобы наша программа действительно была похожа на коммерческие MDI-приложения Windows, необходимо добавить несколько дополнительных штрихов. Например, все дочерние формы имеют одинаковые названия, так что их невоз-
можно отличить друг от друга; этот недостаток нужно исправить. Также хотелось бы иметь возможность упорядочить дочерние окна и выстроить их «мозаикой», или «каскадом». Наконец, в меню должен присутствовать список окон, при помощи которого можно легко перейти к любому дочернему окну, даже если оно спрятано под другими окнами.
1. Запустите редактор меню и добавьте в строку меню родительского окна, frmMDI, новое меню &Window. Установите флажок WindowList в редакторе меню.
2 Добавьте в новое меню команды Tile и Cascade. Назовите их mnuWindowTile и mnuWindowCascade соответственно.
3. Закройте редактор меню кнопкой ОК.
4. Добавьте в процедуру события Click объекта mnuWindowTile следующую строку:
5. Добавьте в процедуру события Click объекта mnuWindowCascade следующую строку:
vbCascade и vbTileHorizontal — встроенные константы Visual Basic. Их значение описано в справочной системе.
6. Измените код процедуры для команды mnuFileNew:
Private Sub mnuFileNew_Click()
Static Counter As Integer
Dim frm As New frmChild
Counter = Counter + 1
frm.Caption = «Дочерняя форма MDI» & Counter
7. Сохраните и запустите приложение. Обратите внимание на отличия рис. 2.9 от предыдущего рисунка.
Расшифровка программы
Возможно, фрагмент программы из предыдущего примера показался вам совершенно невразумительным — не стоит огорчаться. Смысл многих операторов прояснится в последующих главах этой книги. И все же давайте кратко рассмотрим этот фрагмент, чтобы вы хотя бы приблизительно представляли себе, что в нем происходит.
Первая строка (Static Counter As Integer) приказывает Visual Basic создать переменную с именем Counter. Ключевое слово Static говорит о том, что значение Counter будет запоминаться при каждом вызове процедуры. Это позволяет использовать Counter для подсчета создаваемых форм.
Рис. 2.9. Усовершенствованное MDI-приложение
Во второй строке (Dim frm As New frmChild) встречается оператор Dim. Обычно он определяет размерность массива, но в данном случае описывает переменную с именем frm, которая создается на основе формы frmChild. Ключевое слово New сообщает Visual Basic о том, что речь идет о новой форме, а не об одной из форм, созданных в этой процедуре.
Поскольку значение переменной Counter запоминается между вызовами процедуры, его можно увеличить следующей строкой:
Counter = Counter + 1
Например, если значение Counter было равно 3, то оператор присвоит ей текущее значение «3 плюс 1», то есть 4. Раз переменная Counter объявлена с ключевым словом Static, новое значение будет сохранено, так что при следующем вызове процедуры переменной Counter будет присвоено значение 5, затем — 6 и т. д. Следующий оператор (frmCaption = «Дочерняя форма MDI» & Counter) заменяет содержимое свойства Caption строкой, которая состоит из текста «Дочерняя форма MDI» и номера, хранящегося в переменной Counter. Например, свойство Caption во второй форме будет иметь значение «Дочерняя форма MDI 2». Последняя строка, так сказать, вдыхает жизнь в форму. Она приказывает Visual Basic отобразить форму на экране. Поскольку мы уже рассматривали процесс создания формы, вы знаете, что работа новой формы начинается с события Load. После загрузки форма активизируется и отображается на экране.
Использование Form Wizard
Когда вы освоите программирование на Visual Basic, вам нередко придется добавлять в свои проекты новые формы (как это было сделано в примере MDI-приложения). Поскольку однодокументный (SDI) интерфейс не позволяет имитировать многие возможности интерфейса MDI, для этой цели были созданы специальные MDI-формы. В начале работы над приложением может выясниться, что одиночной формы не хватает для решения задачи; в этом случае следует добавить новую форму и настроить ее для выполнения требуемой задачи. В Visual Basic 6 процесс добавления форм упрощен до предела: Form Wizard поможет выбрать форму нужного типа и добавить ее в проект. Достаточно щелкнуть правой кнопкой мыши внутри окна проекта и выбрать в контекстном меню команду Add > Form — Form Wizard открывает диалоговое окно Add Form (рис. 2.10).
Рис. 2.10. Form Wizard
Как видите, выбор достаточно широк — диалоговое окно About (About Dialog), заставка (Splash Screen), окно с полезными советами (Tip of the Day) и даже окно-броузер (Web Browser)! После того как вы выберете форму в окне Wizard, Visual Basic создаст шаблон с необходимой графикой и кодом и включит его в проект. Form Wizard заметно экономит время, поскольку он автоматически генерирует часть программного кода для формы.
ПОДСКАЗКАЕсли вы хотите, чтобы формы имели стандартный вид и при этом вам пришлось поменьше программировать, поручите свою работу Form Wizard.
Давайте воспользуемся Form Wizard и добавим в проект еще одну форму:
1. Щелкните правой кнопкой мыши в окне проекта и выберите из контекстного меню команду Add > Form. На экране появляется окно Form Wizard.
2. Включите в проект новую форму — для этого следует выбрать значок About Dialog в окне Add Form. Новой форме автоматически присваивается имя frm-
3. Дважды щелкните на строке frmMDI в окне проекта, чтобы активизировать MDI-форму.
4. Вызовите редактор меню и добавьте в форму новое меню — для этого следует щелкнуть на пустом месте под названием команды &New Form. Проследите, чтобы там не было многоточия (. ). — если оно присутствует, удалите его кнопкой со стрелкой влево. Теперь задайте свойству Caption значение &Help, a свойству Name — значение mnuHelp.
5. Нажмите кнопку Next, чтобы добавить следующую команду.
6. Добавьте новую команду в меню mnuHelp — для этого нажмите в редакторе меню кнопку со стрелкой вправо. Задайте свойству Caption значение &About, a свойству Name — значение mnuHelpAbout. Если не нажать кнопку со стрелкой, то вместо новой команды меню Help будет создано новое меню. Закройте редактор меню кнопкой ОК.
7. Щелкните правой кнопкой мыши в окне проекта и выберите из контекстного меню команду Project1 Properties.
8. В открывшемся диалоговом окне Project Properties перейдите на вкладку Make.
9. Замените содержимое поля Title текстом Пример MDI-приложения.
10. В группе Version Information выберите из списка Туре строку Company Name и введите название своей организации в поле Value.
11. Найдите в списке Туре строку Product Name и введите значение MDI-приложение, затем нажмите кнопку ОК.
12. Выполните команду Help > About из меню MDI-формы, чтобы открыть окно программы.
13. Включите в процедуру mnuHelpAbout_Click() следующую строку: frmAbout.Show vbModal
14. Запустите приложение и откройте диалоговое окно About (рис. 2.11).
Рис. 2.11. Диалоговое окно About, созданное Form Wizard
Напоследок давайте вернемся к ключевому слову vbModal. В уроке 4, «Работа с модулями и классами», вы научитесь передавать параметры вызываемым процедурам. В данном случае ключевое слово vbModal — параметр, который передается методу Show формы. Он сообщает Visual Basic о том, что диалоговое окно About должно отображаться в модальном режиме. Модальная форма временно берет на себя весь процесс общения пользователя с приложением. Пока модальное диалоговое окно остается на экране, пользователь не может работать с остальными формами приложения. Модальные формы используются во многих ситуациях. Например, диалоговое окно для регистрации пользователя стоит сделать модальным, чтобы к вашему приложению допускались лишь те пользователи, которые успешно прошли регистрацию.
Кроме обычных модальных форм существуют и системно-модальные формы. Пока системно-модальное окно остается открытым, пользователь не может работать не только с данным, но и со всеми остальными приложениями. Хорошим примером системно-модального окна служит программа сохранения экрана. Работа с приложениями становится возможной лишь после того, как будет введен правильный пароль. Тем самым обеспечивается простейшая защита для ваших программ.
ПОДСКАЗКАЕсли в окне Visual Basic накопится много лишних форм, закройте их. Самый простой способ вызвать форму на экран — дважды щелкнуть на ее имени в окне проекта.
Что нового мы узнали?
В этом уроке мы научились:
Создавать новые формы.
Работать с формами в Visual Basic.
Пользоваться важнейшими свойствами и методами при отображении форм.
Включать новый код в процедуры событий.
Создавать MDI-приложения с работающими меню.
Создавать специализированные формы при помощи Form Wizard.
УРОК 3
Выбор и использование
Управляющих
Элементов
Управляющие элементы
Панель элементов
Использование управляющих элементов
Группировка элементов
Добавление элементов на панель
Разработка интерфейсов в стиле Windows 95
Как вы узнали из предыдущего урока, приложения Visual Basic строятся на основе форм. Практически любое приложение содержит формы, а на формах находятся управляющие элементы, которые расширяют функциональные возможности приложения и обеспечивают его всем необходимым для взаимодействия с пользователем. В этом уроке мы рассмотрим самые распространенные и нужные управляющие элементы Visual Basic 6. В этом уроке нам не удастся подробно рассмотреть все элементы, и мы ограничимся лишь теми, с которыми вам придется работать больше всего. Не огорчайтесь! Остальные элементы будут рассмотрены в последующих главах.
Папиллярные узоры пальцев рук — маркер спортивных способностей: дерматоглифические признаки формируются на 3-5 месяце беременности, не изменяются в течение жизни.
Общие условия выбора системы дренажа: Система дренажа выбирается в зависимости от характера защищаемого.
Опора деревянной одностоечной и способы укрепление угловых опор: Опоры ВЛ — конструкции, предназначенные для поддерживания проводов на необходимой высоте над землей, водой.
Урок 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-приложения.
Запускаем Delphi. В меню «File» выбираем пункт «New Application».
Итак, содержание главного меню:
Файл | Правка | Окна | Помощь |
Новый | Вырезать | Упорядочить | О программе |
Открыть | Копировать | ||
Сохранить | Вставить | ||
Сохранить как: | |||
Закрыть | |||
Выход |
Выбираем пункт меню «Окна» и переименовываем его имя (идентификатор) Name в инспекторе объектов в WindowMenu.
Выбираем мышкой форму MainForm. В Object Inspector в свойстве WindowMenu устанавливаем их ниспадающего списка пункт меню WindowMenu . Теперь во время работы приложения все дочерние окна будут списком отображаться в меню » Окна «.
Поскольку дочерних окон в этом приложении будет много и по внешнему виду они будут подобные, то нет смысла проектировать каждое окно отдельно. Спроектируем одно. Для помещения в проект новой формы выбираем из меню » File » пункт » New Form «.
Устанавливаем размеры окна Form2 меньшими главного родительского окна.
Переименовываем свойство Name для этого окна из Form2 в ChildForm.
Устанавливаем свойство дочернего окна для MDI-приложения FormStyle в fsMDIChild .
Выбираем из палитры компонентов Memo и устанавливаем его в дочернюю форму ChildForm .
Меняем свойство Align для этого компонента на alClient . Он немедленно расширяется на все доступное пространство окна.
Далее будем писать событие выбора пункта меню «Новый». При нажатии на него должно появляться дочернее окно. Поступаем следующим образом. Поскольку дочерних окон будет множество, то мы программа должна их автоматически при необходимости создавать. По умолчанию Delphi устанавливает автоматическое создание окна во время запуска приложения. Это избавляет программиста от написания некоторых команд. В данном случае мы все сделаем сами. Выбираем из меню » Project » пункт » Options: «. На вкладке Forms снимаем установку » Auto-create forms » для окна ChildForm . Для этого выбираем его и перегоняем одинарной стрелкой в сторону » Available forms «. Нажимаем кнопку OK.
Сохраняем проект на диске. Для этого проводником Windows создаем отдельную папку для хранения этого примера. В меню » File » выбираем пункт » Save Al l». Дальше появляются диалоги сохранения модулей окон и файл проекта. Модуль Unit1 родительского окна можно назвать, сохранив его под именем MainUnit . Модуль Unit2 дочернего окна приложения. можно сохранить под именем ChildUnit . Весь проект можно сохранить под именем MyEdit .
Поскольку в этом окне создается другое, то в переименованный модуль MainUnit необходимо подключить ChildUnit . Для этого выбираем из меню » File » пункт «Use Unit: » и указываем модуль ChildUnit . Нажимаем OK.
Все, запускаем программу на выполнение. Во время работы обратите внимание на список появившихся окон в меню «Окна», по которым удобно переключаться на необходимое окно.
В следующих уроках мы подробнее остановимся на написании этого примера. Если в этом уроке у вас что-то не получается, то пример на данном этапе разработки можно скачать здесь (2 KB). Если вы в последствии открываете свой или скаченный проект, не забывайте, что нужно открывать DPR файл.
Часть урока для продвинутых программистов
Перетаскивание файлов в приложение
Иногда очень полезно избавить пользователя от лишних операций при открытии файла. Он должен нажать на кнопку «Открыть», затем найти интересующий каталог, выбрать файл. Проще перетащить мышкой файл сразу в окно приложения. Рассмотрим пример перетаскивания Drag & Drop в окно произвольного текстового файла, который сразу же открывается в компоненте Memo1.
Для начала в разделе 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
Эффективный способ применения интерфейсов в mdi приложениях
Термин MDI (Multiple Document Interface) дословно означает многодокументный интерфейс и описывает приложения, способные загрузить и использовать одновременно несколько документов или объектов. Примером такого приложения может служить диспетчер файлов (File Manager).
Обычно MDI-приложения состоят минимум из двух форм — родительской и дочерней. Свойство родительской формы FormStyle установлено равным fsMDIForm. Для дочерней формы установите стиль fsMDIChild.
Родительская форма служит контейнером, содержащим дочерние формы, которые заключены в клиентскую область и могут перемещаться, изменять размеры, минимизироваться или максимизироваться. В вашем приложении могут быть дочерние формы разных типов, например одна — для обработки изображений, а другая — для работы с текстом.
Создание форм
В MDI-приложении, как правило, требуется выводить несколько экземпляров классов формы. Поскольку каждая форма представляет собой объект, она должна быть создана перед использованием и освобождена, когда в ней больше не нуждаются. Delphi может делать это автоматически, а может предоставить эту работу вам
.
Автоматическое создание форм
По умолчанию при запуске приложения Delphi автоматически создает по одному экземпляру каждого класса форм в проекте и освобождает их при завершении программы. Автоматическое создание обрабатывается генерируемым Delphi кодом в трех местах.
Первое — раздел интерфейса в файле модуля формы.
В данном фрагменте кода объявляется класс TForm1.
Вторым является место, в котором описывается переменная класса.
var Form1: TForm1;
Здесь описана переменная Form1, указывающая на экземпляр класса TForm1 и доступная из любого модуля. Обычно она используется во время работы программы для управления формой.
Третье место находится в исходном тексте проекта, доступ к которому можно получить с помощью меню View/ Project Source. Этот код выглядит как:
Процесс удаления форм обрабатывается с помощью концепции владельцев объектов: когда объект уничтожается, автоматически уничтожаются все объекты, которыми он владеет. Созданная описанным образом форма принадлежит объекту Application и уничтожается при закрытии приложения.
Динамическое создание форм
Хотя автоматическое создание форм полезно при разработке SDI-приложений, при создании MDI-приложении оно, как правило, неприемлемо.
Для создания нового экземпляра формы используйте конструктор Create класса формы. Приведенный ниже код создает новый экземпляр TForm1 во время работы программы и устанавливает его свойство Caption равным ‘New Form’.
Form1:= TForm1.Create(Application);
Form1.Caption:= ‘New Form’;
Конструктор Create получает от вас в качестве параметра потомка TComponent, который и будет владельцем вашей формы. Обычно в качестве владельца выступает Application, чтобы все формы были автоматически закрыты по окончании работы приложения. Вы можете также передать параметр Nil, создав форму без владельца (или владеющую собой — как вам больше нравится), но тогда закрывать и уничтожать ее придется вам. В случае возникновения необрабатываемой ошибки такая форма останется в памяти, что не говорит о высоком профессионализме программиста.
В приведенном ниже коде Form1 указывает только на последнюю созданную форму. Если вам это не нравится, воспользуйтесь приведенным ниже кодом — возможно, он более точно отвечает вашим запросам:
with TFormI.Create(Application) do
Caption:= ‘New Form’;
Совет: При разработке MDI-приложения метод Show не нужен, так как Delphi автоматически показывает все вновь созданные дочерние MDI-формы. В случае SDI-приложения вы обязаны использовать метод Show.
Даже при динамическом создании форм Delphi попытается навязать вам свои услуги по созданию экземпляра каждой формы. Чтобы отказаться от них, воспользуйтесь диалоговым окном Project Options, изображенным на рис. 1.14, и удалите классы форм из списка Auto-create forms.
Рис. 1.14. Диалоговое окно Project Options позволяет установить опции для текущего проекта
Если вы захотите получить доступ к отдельному дочернему экземпляру класса, используйте свойство MDIChildren, описываемое в следующем разделе.
MDI-свойства TForm
Объект TForm имеет несколько свойств, специфичных для MDI-приложений.
ActiveMDIChild
Это свойство возвращает дочерний объект TForm, имеющий в текущее время фокус ввода. Оно полезно, когда родительская форма содержит панель инструментов или меню, команды которых распространяются на открытую дочернюю форму.
Например, представим, что проект использует дочернюю форму, содержащую элемент TMemo, названный memDailyNotes. Имя класса этой дочерней формы— TfrmMDIChild. Родительская форма содержит кнопку Clear в панели инструментов, которая удаляет содержимое memDailyNotes в активной дочерней форме. Вот как это реализуется.
procedure TfrmMDIParent.spbtnClearClick(Sender: TObject);
begin
if not (ActiveMDIChild = Nil) then
if ActiveMDIChild is TfrmMDIChild then
TfrmMDIChild(ActiveMDIChild).memDailyNotes.Clear;
end;
В первой строке проверяется, равен ли ActiveMDIChild значению Nil, так как в этом случае обращение к объекту вызовет исключительную ситуацию.
Совет: ActiveMDIChild равен Nil, если нет открытых дочерних форм или свойство FormStyle не равно fsMDIForm.
Поскольку ActiveMDIChild возвращает объект TForm, компилятор не имеет доступа к memDailyNotes — объекту TfrmMDIChild. Вторая строка проверят соответствие типов, т.е. действительно ли ActiveMDIChild указывает на объект TfrmMDIChild.
Третья строка выполняет преобразование типа и вызывает метод Clear компонента memDailyNotes.
MDIChildren и MDIChildCount
Свойство MDIChildren является массивом объектов TForm, предоставляющих доступ к созданным дочерним формам. MDIChildCount возвращает количество элементов в массиве MDIChildren.
Обычно это свойство используется при выполнении какого-либо действия над всеми открытыми дочерними формами. Вот код сворачивания всех дочерних форм командой Minimize All.
procedure TFormI.mnuMinimizeAllClick(Sender: TObject);
var
iCount: Integers;
begin
for iCount:= MDIChildCount-1 downto 0 do
MDIChildren[iCount].WindowState:= wsMinimized;
end;
Если вы будете сворачивать окна в порядке возрастания элементов массива, цикл будет работать некорректно, так как после сворачивания каждого окна массив MDIChildren обновляется и пересортировывается , и вы можете пропустить некоторые элементы.
TileMode
Это — свойство перечислимого типа, определяющее, как родительская форма размещает дочерние при вызове метода Tile. Используются значения tbHorizontal (по умолчанию) и tbVertical для размещения форм по горизонтали и вертикали.
WindowMenu
Профессиональные MDI-приложения позволяют активизировать необходимое дочернее окно, выбрав его из списка в меню. Свойство WindowMenu определяет объект TMenuItem, который Delphi будет использовать для вывода списка доступных дочерних форм.
Для вывода списка TMenuItem должно быть меню верхнего уровня . Это меню имеет свойство Caption, равное swindow.
MDI-события TForm
В MDI-приложении событие OnActivate запускается только при переключении между дочерними формами. Если фокус ввода передается из не MDI-формы в MDI-форму, генерируется событие OnActivate родительской формы, хотя ее свойство Active никогда и не устанавливается равным True. Эта странность на самом деле строго логична: ведь, если бы OnActivate генерировался только для дочерних форм, не было бы никакой возможности узнать о переходе фокуса ввода от другого приложения.
MDI-методы TFor m
Специфичные для MDI-форм методы перечислены ниже.
Arrangelcons выстраивает пиктограммы минимизированных дочерних форм в нижней части родительской формы.
Cascade располагает дочерние формы каскадом, так что видны все их заголовки.
Next и Previous переходит от одной дочерней формы к другой, как будто вы нажали > или >.
Tile выстраивает дочерние формы так, что они не перекрываются .
Пример MDI-приложения
В этом разделе мы расширим возможности созданной ранее программы просмотра изображений.
Создание интерфейса
Интерфейс MDI-приложения очень похож на интерфейс разработанного ранее SDI-приложения, но каждое изображение выводится в отдельной, а не в главной форме. Выполните следующие действия для создания родительской формы.
1. Выберите команду File/New Application, и появится пустое приложение.
2. Установите следующие свойства.
Свойство Значение
Caption Image Viewer
FormStyle fsMDIForm
Name frmMDIParent ShowHint True
3. Поместите компонент TPanel в форму. Установите следующие его свойства.
Свойство Значение
Align alTop
Caption —
4. Поместите три компонента TSpeedButton в TPanel и назовите их spbtnLoad, spbtnStretch и spbtnCenter. Установите следующие их свойства.
Свойство Значение
spbtnLoad.Hint Load
spbtnLoad.Left 8
spbtnLoad.Top 8
spbtnStretch.AllowAlIUp True
spbtnStretch.Grouplndex 1
spbtnStretch.Hint Stretch
spbtnStretch.Left 48
spbtnStretch.Top 8
spbtnCenter.AllowAlIUp True
spbtnCenter.Grouplndex 2
spbtnCenter.Hint Cente r
spbtnCenter.Left 80
spbtnCenter.Top 8
Свойства Glyph установите те же, что и для SDI-приложения.
5. Добавьте в форму компонент TOpenDialog и установите следующие его свойства.
Свойство Значение
Filter Bitmaps (*.bmp)]*.bmp
Name opndlgLoad
Options [ofPathMustExist,ofFileMustExist]
Теперь создадим дочернюю форму.
1. Выберите из меню File/New Form, и появится пустая форма.
2. Установите следующие ее свойства.
Свойство Значение
FormStyle fsMDIChild
Name frmMDIChild
Position poDefaultPosOnly
3. Поместите компонент TImage во вновь созданную форму и установите его следующие свойства.
Свойство Значение
Align alClient
Name imgMain
Удалите дочернюю форму из списка автоматически создаваемых форм следующим образом.
1. Выберите команду Project/ Options, и появится диалоговое окно Project Options, показанное на рис. 1.14.
2. Выберите frmMDIChild в списке Auto-create forms.
3. Щелкните на кнопке. Форма frmMDIChild при этом будет перенесена в список Avai lable forms.
4. Щелкните на кнопке ОК.
Теперь самое время сохранить проект, выбрав команду File/Save Project As. Сохраните Unit1 как MDIParent, а проект — как EgMDIApp.
Написание кода
Создав интерфейс, перейдем к написанию исходного текста приложения, который будет очень похож на код для SDI-приложения.
Сначала загрузим изображение. Введите следующий код в обработчик события OnClick компонента spbtnLoad.
procedure TfrmMDIParent.spbtnLoadClick(Sender: TObject);
begin
if opndlgLoad.Execute then
with TfrmMDIChild.Create(Application) do
begin
Caption:= opndlgLoad.FileName;
imgMain.Picture.LoadFromFile(opndlgLoad.FileName);
ClientW >
ClientHeight:= imgMain.Picture.Height;
end;
end;
После запуска диалогового окна создается новый экземпляр дочерней формы и загружается файл изображения . После загрузки размеры дочерней формы изменяются так, чтобы можно было видеть все изображение.
Еще пара штрихов— и приложение заработает, как и предусматривалось. Поскольку модуль ссылается на тип TfrmMDIChild, находящийся в модуле MDIChild, после строки implementation следует добавить еще одну строку:
Теперь можно приступить к компиляции и запуску приложения. Однако заметьте, что, когда вы щелкаете на кнопке Close, дочерняя форма не закрывается, а сворачивается в пиктограмму. Чтобы заставить ее закрыться, следует добавить в код обработчика OnClose класса TfrmMDIChild маленькую деталь— изменить свойство Action:
Компоненты TSpeedButton Stretch и Center выполняют те же функции, что и в SDI-приложении, однако их обработчики события OnClick следует изменить следующим образом
if not (ActiveMDIChild = Nil) then
if ActiveMDIChild 15 TfrmMDIChild then
TfrmMDIChild(ActiveMDIChild).imgMain.Stretch:= spbthStretch.Down;
if not (ActiveMDIChild = Nil) then
if ActiveMDIChild is TfrmMDIChild then
TfrmMDIChild(ActiveMDIChild).imgMain.Center:= spbthCenter.Down;
Остается последняя проблема — состояния кнопок Stretch и Center одинаковы для всех дочерних форм Для решения этой задачи добавьте в обработчик события OnActivate класса TfrmMDIChild строки.
frmMDIParent.spbtnStretch.Down:= imgMain.Stretch;
frmMDIParent.spbtnCenter.Down:= imgMain.Center;
И, наконец, самый последний из последних штрихов— в модуле MDIChild добавьте после строки implementation строку.
Многооконные приложения. SDI- и MDI-интерфейсы
Цель лекции
Научиться создавать многооконные приложения, применять модальные и немодальные окна.
Многооконные приложения
До сих пор мы с вами все приложения делали с одним единственным окном. А между тем, в современном программировании редко встречаются программы, имеющие только одно окно. Даже простые стандартные утилиты, вроде Калькулятора calc.exe или игры «Сапер» — winmine.exe имеют по нескольку окон. Я недавно закончил проект для одной организации, проект этот можно считать средней сложности, а он содержит 102 окна! В этой лекции мы с вами научимся делать многооконные приложения.
Имеется два типа интерфейсов: SDI (Single Document Interface — однодокументный интерфейс ) и MDI (Multi Document Interface — многодокументный интерфейс ). SDI -приложения работают одновременно с одним документом, MDI -приложения предназначены для одновременной работы со множеством однотипных документов. При этом все документы располагаются внутри одного контейнера, которым служит, как правило, главная форма. Компания Microsoft не рекомендует использовать MDI -интерфейсы, хотя сама использует их в различных служебных программах, например, в консолях вроде Диспетчера устройств. Кроме того, разработка MDI -приложений в Lazarus пока не реализована, так что подробно рассматривать MDI -интерфейсы мы не будем, хотя вкратце и коснемся этой темы. Но вначале — SDI .
В SDI -приложениях окна могут быть двух видов — модальные и немодальные. Создаются они одинаково, разница заключается только в способе вывода этих окон на экран. Модальное окно блокирует программу, не даёт с ней работать, пока вы это окно не закроете. Стандартный пример модального окна — окно «О программе«, которое присутствует почти в любом приложении. Как правило, такое окно находится в меню «Справка«. Пока вы не нажмете «ОК«, закрыв это окно, вы не сможете работать с основной программой.
Немодальные окна позволяют переключаться между ними, и программой, и работать одновременно и там, и там. Типичный пример — окна Lazarus — вы можете переключаться между Инспектором объектов, Редактором кода, Редактором форм, и другими окнами — они не мешают друг другу, так как все они немодальные.
Изучим работу с различными окнами на примерах.
Модальные окна
Если вы помните, в «Блокнот — шифратор» мы делали лабораторную работу — Блокнот-шифровальщик. Там мы предусмотрели в меню «Справка» подменю «О программе«, но само окно не делали. Пришло время исправить это упущение. Вы должны были сохранить проект в папку 18-01 под именем CodeBook. Убедитесь, что Lazarus закрыт, и загрузите файл CodeBook.lpi — это информационный файл проекта. В результате, загрузится Lazarus с этим проектом (с тем же успехом можно было бы загрузить файл CodeBook.lpr).
Выберите команду меню «Файл -> Создать форму» или нажмите одноименную кнопку на Панели инструментов. Появится новая форма с именем по умолчанию Form1. Мы с вами договаривались называть все формы понятными именами, и в начале имени ставить префикс f , что означает форму. Поэтому в свойстве Name этой формы напишите fAbout , затем нажмите кнопку «Сохранить все» (или выберите «Файл -> Сохранить все«), и модулю этого нового окна дайте имя About . Переключитесь клавишей в Редактор кода — вы увидите вкладки модулей:
Два из этих модулей — Main и About имеют формы. Переходя по этим вкладкам можно переключаться между модулями. Но нам сначала нужно сделать само окно «О программе«. Так что клавишей переключитесь обратно в Редактор форм. Прежде всего, в свойстве BorderStyle формы fAbout выберите значение bsDialog , так как нам не нужно, чтобы пользователь имел возможность изменять размеры окна, разворачивать или сворачивать его. Затем в свойстве Position выберите poMainFormCenter , чтобы окно появлялось по центру главного окна. До сих пор мы не устанавливали это значение у окон, так как все наши приложения содержали единственное, оно же главное окно. Окно «О программе» — не главное, поэтому его желательно выводить на экран по центру главного окна. Главным в проекте считается окно, созданное первым, его мы обычно называем fMain.
В свойстве Caption формы напишите «О программе«.
Установите на форму простую панель TPanel, очистите ее свойство Caption . Чтобы сделать из панели красивую рамку, установите в её свойстве BevelInner значение bvLowered .
Далее, на панель установите две метки TLabel и один TMemo . В TMemo мы будем выводить многострочный текст с пояснением о назначении программы. Поскольку нам не нужно, чтобы пользователь мог редактировать этот текст, свойство ReadOnly компонента Memo1 установите в True . Текст в Memo1 придется вводить встроенным Редактором через свойство Lines .
Ниже панели установите кнопку TBitBtn с вкладки Additional Палитры компонентов, в свойстве Kind кнопки выберите значение bkOK .
Для экономии места я не буду подробно расписывать, как вводить в метки текст, менять у компонентов шрифты и размеры — вы прекрасно должны уметь делать это сами. В результате у вас должна получиться примерно такая форма:
Замечу, что во всех компонентах я выбирал свой любимый шрифт — Times New Roman — вы же можете выбрать свой, только подберите подходящие размер и начертание.
Отдельно остановлюсь на строчке Copyright . Слово Копирайт (англ. Copyright) означает авторское право . Причем авторское право может быть двух видов — имущественное и неимущественное. Если вы делаете программу на заказ, то имущественное авторское право принадлежит заказчику — он может устанавливать эту программу на сколько угодно компьютеров, продавать или дарить ее. Неимущественное право в любом случае принадлежит автору программы, то есть, вам. Оно подразумевает, что программу нельзя переименовывать или изменять её код без вашего согласия, и что в программе вы обязательно должны упоминаться, как автор . Таким образом, если вы делаете программу на заказ, вы не обязаны вместе с программой отдавать исходный код вашего проекта! Иначе получится, что вы передаете заказчику не только имущественное, но и неимущественное право, а это уже будет цена продукта на порядок выше.
Так вот, в строчке Copyright указывается имущественный правообладатель. Если вы делаете программу на заказ, здесь вы должны указать заказчика. Себя же вы можете упомянуть строчкой ниже, установив еще одну метку, и начав ее текст, как «Автор: «. Но поскольку в данном проекте заказчика у нас нет, то все авторские права принадлежат нам. Кстати, указывайте не мою, а свою фамилию, ведь я добровольно выкладываю этот код для общего использования, а проект по моим описаниям делали все же вы!
И еще. Знак авторского права © имеет в таблице символов код 0169. Чтобы вставить его в Caption метки, при вводе текста нажмите , и удерживая его, наберите 0169. Затем отпустите . Символ должен появиться в метке. Вместо этого знака иногда указывают упрощенный вариант: » (с) «. Сделайте, как считаете нужным.
Окно мы сделали, нужно теперь научить программу выводить его по требованию пользователя. Кнопкой перейдите в Редактор кода, затем, щелкнув по вкладке Main, перейдите на модуль главной формы. Вот так, сходу, мы ещё не сможем вызвать форму fAbout, сначала нужно подключить её модуль к главной форме. В разделе uses главной формы, после модуля MyCript через запятую добавьте модуль новой формы About . Теперь мы сможем вызывать это окно!
Сгенерируйте событие OnClick для команды меню «Справка -> О программе» (если вы еще помните, для этого достаточно просто выбрать данную команду). Её код очень простой:
Метод ShowModal , указанный в коде, вызывает на экран окно fAbout в модальном режиме. Пока окно не закроется, с программой работать будет нельзя. Как только оно закроется, управление передастся обратно в программу. Сохраните проект, запустите его на выполнение и убедитесь, что окно «О программе» вызывается по требованию пользователя и закрывается кнопкой «ОК«. Однако не спешите закрывать проект, он нам еще понадобится.
Эффективный способ применения интерфейсов в mdi приложениях
Приложения с многооконным интерфейсом (MDI) позволяют отображать несколько документов сразу, при этом каждый документ отображается в отдельном окне. Приложения с MDI-интерфейсом часто содержат элементы меню Window с вложенным меню для переключения между окнами или документами.
Примечание |
---|