Как сделать компонент активным delphi

Обновлено: 07.07.2024

Как я могу создать компонент во время выполнения, а затем работать с ним (изменение свойств и т. Д.)?

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

Для невизуальных компонентов

Для визуальных компонентов:

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

Несколько пояснений к приведенному выше коду:

Установив владельца компонента (параметр конструктора), компонент уничтожается, когда форма собственности уничтожается.
Установка Parent свойства делает компонент видимым. Если вы забудете, ваш компонент не будет отображаться. (Легко пропустить этот :))

Если вы хотите, чтобы многие компоненты могли делать то же самое, что и выше, но в цикле:

Это добавит 10 кнопок в левой части формы. Если вы хотите изменить кнопки позже, вы можете сохранить их в списке. ( TComponentList наилучшим образом подходит, но также взгляните на предложения из комментариев к этому ответу)

Как назначить обработчики событий:

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

Чтобы упростить процесс создания компонента времени выполнения, вы можете использовать GExperts .

Создайте компонент (или несколько компонентов) визуально и установите его свойства.
Выберите один или несколько компонентов и выполните команду GExperts, Components to Code.
Вставьте сгенерированный код в ваше приложение.
Удалите компоненты (компоненты) из конструктора визуальной формы.

Пример (код создания TButton, созданный таким образом):

Я хотел бы добавить, что при динамическом добавлении элементов управления . это хорошая идея добавить их в список объектов (TObjectList), как предлагается в by @Despatcher.

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

Это позволяет затем использовать методы и свойства этого элемента управления. Не забудьте создать TObjectLists, возможно, в форме create event .

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

Ответ был предложен - самым простым способом является Список объектов (компонентов). TObjectList является самым простым в использовании (в условных обозначениях). Списки великолепны!

// Вы можете получить более сложные и объявить // TNotifyevents и назначить их, но пусть это упростит :). , ,

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

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

Создание компонентов в Delphi

В этой статье мы рассмотрим основные стадии построения компонента, сосредоточившись на вопросах конструирования, тестирования и установки компонента в Delphi.

Ниже будут подробно разобраны подготовка каркаса компонента, а также создание свойств, методов и событий компонента.

Мы последовательно рассмотрим все шаги данного процесса на примере Control-а. Любой control является наследником TComponent и шаги по созданию control-ов ничем не отличаются от аналогичных для чистых компонентов, а стало быть, для большей визуальности мы рассмотрим создание именно control-а. Наш компонент будет отличаться от стандартного тем, что по умолчанию цвет текста в нем будет не черным, а синим. Шрифт будет жирным. Кроме того, будут изменены ширина и высота по умолчанию. Данный компонент вряд ли поразит воображение пользователей, однако позволит подробно рассмотреть этапы создания компонента, не увлекаясь его внутренней функциональностью.

Создание модуля компонента. Рекомендации по проектированию.

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

Модуль компонента можно создать вручную или с помощью эксперта построения компонентов.

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

Начнем с последнего способа, как наиболее часто применяемого.

Рисунок 1.

Эксперт (рисунок 1) вызывается с помощью пункта меню Component/New Component в IDE Delphi. Диалоговое окно эксперта содержит следующие поля:

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

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

Palette Page: закладка, на которой будет установлен компонент. Можно выбрать из выпадающего списка набор существующих страниц или ввести новое наименование.

UnitFileName: имя модуля, в котором будет размещен исходный текст компонента.

Search Path: пути, в которых среда Delphi будет искать нужные ей файлы для компиляции кода компонента.

Для нашего компонента наиболее близким по функциональности является класс TLabel, он и будет родителем нашего компонента. Часто в качестве родителей следует выбирать не ближайший по функциональности компонент, а ближайший так называемый Custom-компонент. Например, непосредственным предком TLabel является TCustomLabel. Класс TCustomLabel реализует всю функциональность TLabel, однако не выносит объявление многих свойств в секцию published, потому что можно только увеличивать область видимости членов класса, но не уменьшать ее. Критерием для выбора между классом и custom-классом служит необходимость оставить скрытыми от пользователя некоторые поля компонента. Например, в TLabel свойство Align переобъявлено в секции published, тогда как в TCustomLabel оно объявляется как protected. Если не нужно давать пользователю компонента доступ к свойству Align, то в качестве предка можно выбрать класс TCustomLabel. Также заметим, что эксперт предлагает в качестве родителя два класса TLabel. Один из модуля StdCtrls, второй из QStdCtrls. Первый относится к иерархии классов VCL, второй к CLX. В примере мы рассмотрим создание VCL-компонента.

ПРИМЕЧАНИЕ

Как правило, модули исходного кода, начинающиеся с Q, относятся к CLX.

Нажав кнопку ОК в окне эксперта, мы получим модуль со следующим текстом:

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

Можно, конечно, написать это все вручную, но радости в этом никакой.

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

Следующим этапом в разработке компонента является создание свойств, методов и событий. Данный этап наиболее длителен и сложен. Какие свойства, методы и события будет содержать компонент – решать вам, однако можно дать несколько общих рекомендаций.

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

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

Очень желательно предварять имя класса префиксом. Для компонентов в этой статье я выбрал префикс mg (мои инициалы). Класс нашего компонента будет назваться TmgCoolLabel.

Имя модуля я предваряю префиксом u (сокращение от Unit). Остальная часть имени совпадает с именем класса без буквы T. Данное требование не обязательно, однако поможет вам и вашим коллегам быстро отыскать, в каком модуле объявлен компонент, и не вызовет при этом путаницы.

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

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

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

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

События OnChange, Before и After придают компоненту дополнительную гибкость.

Код компонента

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

Главная работа по установке новых начальных значений свойств выполняется в конструкторе Create. Переопределение свойств Height и Width необязательно, но очень желательно. Если этого не сделать, значения по умолчанию для данных свойств будут записываться в файл формы, что будет замедлять загрузку формы.

На практике этап проектирования и кодирования компонента является одним из самых долгих и кропотливых.

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

Delphi автоматически производит сохранение в файл формы состояния свойств, описанных в области видимости Published. Published – это область видимости, аналогичная директиве public. Помещение декларации элемента класса в секцию published заставляет компилятор добавить дополнительную информацию о типе времени выполнения (run-time type information, RTTI) для данного элемента. По этой причине в секции published могут быть объявлены не все типы данных, а лишь простые типы данных (ordinal datatypes), строки, классы, интерфейсы, указатели на методы и массивы.

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

На рисунке 1 схематично изображен процесс сохранения свойств формы в файл. Все начинается с того, что IDE Delphi вызывает метод WriteComponentResFile. Метод объявлен следующим образом:

Первый параметр – имя файла, в который нужно сохранить форму, второй - сохраняемый компонент. Код метода очень прост:

Метод создает файловый поток (TFileStream) и вызывает его метод WriteComponentRes. Метод WriteComponentRes всего лишь вызывает WriteDescendentRes(ResName, Instance, nil). WriteDescendentRes формирует заголовок ресурса компонента и вызывает метод WriteDescendent, который и отвечает за запись свойств компонента в поток.

Код метода WriteDescendent так же прозрачен:

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

Класс TWriter извлекает информацию о свойствах записываемого в поток объекта. Данный класс является наследником абстрактного класса TFiler – базового класса, используемого для записи или чтения информации о свойствах компонента в/из потока.

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

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

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

Свойство Ancestor позволяет определить, значения каких свойств должны быть записаны в поток. Дело в том, что необходимо сохранить лишь те свойства, значения которых отличаются от заданных по умолчанию директивой default. Если значение свойства Ancestor равно nil, записываются все свойства, в противном случае проводится анализ необходимости записи. Свойство Ancestor не равно nil лишь в случае сохранения форм, разработанных в визуальном дизайнере.

Свойство IgnoreChildren указывает, нужно ли, помимо свойств самого компонента, записывать свойства компонентов, владельцем которых он является. Если значение свойства равно True, "дети" данного компонента не записываются.

Свойство LookupRoot указывает на локальный корневой (записываемый/считываемый) компонент. Свойство доступно только для чтения и используется для разрешения имен вложенных фреймов. При сохранении или чтении вложенных во фрейм компонентов указывает на этот фрейм.

Метод FlushBuffer - абстрактный метод синхронизации с потоком, содержащим данные компонента.

DefineProperty – метод для чтения/записи значения свойства. Устанавливает указатели на методы чтения и записи свойства с именем, указанным в первом параметре.

DefineBinaryProperty – метод чтения/записи бинарных данных как значений свойства. Устанавливает указатели на методы чтения и записи свойства с именем, указанным в первом параметре.

Класс TFiler имеет двух наследников TWriter и TReader. TWriter отвечает за запись значений свойств, а TReader за чтение.

Наследники добавляют методы чтения и записи различных типов данных.

Загрузка значений свойств происходит аналогично процессу записи. При этом средой Delphi вызывается метод ReadComponentResFile, и создается объект TReader.

Данный механизм применяется при сохранении свойств в файлы формата ресурсов Windows. Последние версии Delphi (6, 7) по умолчанию сохраняют свойства в файлах текстового формата. Преобразования из одного формата в другой можно выполнить глобальными методами ObjectBinaryToText и ObjectTextToBinary.

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

Механизм одинаково работает и для VCL, и для CLX.

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

Загрузка формы в run-time

Одним из интересных методов использования механизма загрузки/чтения свойств является загрузка формы из файла dfm в ходе выполнения программы. Так как в последних версиях Dephi по умолчанию используется текстовый формат хранения свойств формы (второй способ - это хранение в формате ресурсов Windows), то появляется возможность изменять вид формы без перекомпиляции программы.

Создадим новый проект с помощью пункта меню File/New Applcation. На главной форме приложения разместим две кнопки и диалог открытия файла. Установим свойство Caption кнопки Button1 равным LoadForm, а Button2 - SaveForm. Внешний вид формы приведен на рисунке 3.

Рисунок 3.

Ниже приведен текст модуля главной формы.

Основную работу по загрузке формы выполняет метод ReadFormProperties, а по записи WriteFormProperties. Оба метода осуществляют конвертацию между двоичным и текстовым представлением свойств формы, используя для этого два потока и вызовы ObjectBinaryToText и ObjectTextToBinary.

Запустим приложение. При нажатии на кнопку LoadForm создается второй экземпляр главной формы приложения. Отредактировав во время выполнения программы файл формы (Unit1.dfm) в текстовом редакторе, и снова нажав кнопку LoadForm, можно убедиться, что сделанные изменения отражаются на внешнем виде формы. Нажатие кнопки SaveForm записывает форму в указанный файл.

Сохранение непубликуемых или нестандартных свойств компонентов

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

Итак, для хранения истории изменений на этапе проектирования свойства Text компонент имеет свойство property TextHistory : TStrings read FTextHistory;

Метод SetText, отвечающий за установку значения свойства Text, сохраняет старое значение. При сохранении формы необходимо сохранить историю изменений, а при загрузке восстановить ее. Так как свойство TextHistory объявлено в секции public, то автоматически оно сохранено не будет.

Чтобы среда Delphi узнала о необходимости сохранения свойства TextHistory и о том, как это делать, необходимо переопределить метод DefineProperties компонента. Переопределенный метод DefineProperties после вызова метода предка производит вызов:

чтобы указать, какие методы необходимо использовать для загрузки и сохранения свойства TextHistory. Загрузка производится методом ReadTextHistory, а сохранение WriteTextHistory.

Метод ReadTextHistory вызывается в ходе загрузки свойств компонента. В качестве параметра он получает объект Reader : TReader. Метод находит и считывает из потока данных маркер начала списка, затем в цикле загружает строки элементов и считывает маркер окончания списка.

Метод WriteTextHisory отвечает за сохранение свойства TextHistory. В качестве параметра он принимает объект TWriter. Метод записывает маркер начала списка в поток данных, и в цикле сохраняет каждый элемент списка в поток. При достижении конца списка в поток записывается маркер конца списка.

Остается только скомпилировать и зарегистрировать пакет, в который помещен данный компонент.

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

Как видим, свойство TextHistory действительно сохраняется в файле формы.

Заключение

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

Статья написана на основе материалов новой книги Михаила Голованова, посвященной компонентам Delphi.

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

Это современная, мощная и в то же время очень доступная для освоения система программирования, основанная на языке Object Pascal, поддерживающем ООП.
Многие компоненты Delphi имеют свое визуальное изображение, что облегчает и ускоряет создание приложений.
Delphi является очень перспективной на настоящее время системой программирования, так как последние версии Delphi работают под управлением современных операционных систем(например WINDOWS 95), развитию которых придается особое значение.
Delphi пригодна, как для написания простых программ, так и для создания мощных современных приложений.

Delphi состоит из:

Внешней оболочки
Языка программирования Object Pascal

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

Главное меню – содержит все необходимые меню для работы с Delphi (File, Edit и т. д.).
Полоса быстрого доступа к командам меню – содержит пиктограммы, позволяющие выполнять некоторые, наиболее часто используемые команды
Палитра компонентов – содержит компоненты, из которых строится программа.
Окно “Object Inspector”(окно инспектора объектов) – это окно, в котором можно устанавливать свойства компонентов и назначать программы для обработки необходимых событий.
Окно формы – это окно в котором визуально размещаются формы и другие компоненты будущего приложения
Окно “Code Editor”(окно редактора кода) – это окно, в котором непосредственно вводится и редактируется исходный текст программы.

Рис1: Окно редактора Delphi 3.0

Структура программы в Delphi.

Delphi рассматривает любую программу как систему, состоящую из следующих частей:

1. Проект. Delphi предназначена для создания больших программ, которые неудобно размещать в одном файле, поэтому программа формируется из нескольких файлов. Основной частью программы является проект. Файл, в котором размещается проект имеет расширение .dpr. Проект формируется самой Delphi и хранит информацию о всех файлах, входящих в данный проект и связях между ними.
2. Модули. Модули-части программы из которых в программу включаются необходимые элементы. Файлы модулей имеют расширение .pas. Модули делятся на два типа: стандартные модули и модули, создаваемые разработчиком. Последние можно разделить на: модули, содержащие информацию о формах и модули, связанные с обработкой информации.
3. Файлы ресурсов, библиотеки DLL и другие вспомогательные части программы.

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

Запуск Delphi (Пуск | Программы Borland Delphi 3 | Delphi 3). После запуска автоматически создается проект (по умолчанию он называется Project1), первая форма (по умолчанию она называется Form1), модуль (по умолчанию он называется unit1) и файл модуля, описывающего эту форму (по умолчанию он называется unit1.pas). В модуль unit1 Delphi уже записала код, необходимый для создания и запуска приложения, состоящего из одной формы (Form1).
Сохранение программы на диске. При сохранении программы Delphi просит задать имя всех файлов модулей и имя файла проекта. Для сохранения изменений во всех файлах проекта-File | Save All. Для сохранения файла модуля-File | Save (или File | Save As…). Для сохранения файла проекта-File | Save Project As….
Компиляция программы. По типу транслятора Delphi является компилятором, поэтому перед запуском программы нужно ее откомпилировать. Для компиляции и запуска программы надо выполнить команду Run | Run. Откомпилированную программу Delphi сохраняет под именем Project1.exe.
Возврат в режим конструктора. Режимы работы в Delphi условно можно разделить на: режим конструктора, в котором создавать программу и режим просмотра, в котором можно просмотреть результат работы на данный момент. После компиляции и запуска программы Delphi работает в режиме просмотра, чтобы внести в программу изменения надо перейти в режим конструктора для этого надо закрыть главную форму-Form1.

Данная схема позволяет создать программу, состоящую из одной только формы. В подавляющем большинстве случаев, создаваемые программы содержат в себе более одной формы с компонентами, размещенными на каждой из ни, причем каждому компоненту (и форме в том числе) необходимо задать определенные свойства, методы, события и программы их обработки. Для создания новой формы необходимо выполнить: File | New Form или File | New… | Выбрать пиктограмму с подписью Form | OK.

Размещение компонентов на форме.

Все компоненты в Delphi размещены на палитре компонентов. Палитра компонентов представляет собой записную книжку, состоящую из нескольких страниц (например страницы Standard, Additional и т. д.). Все компоненты сгруппированы по определенному признаку и каждая группа занимает соответствующую страницу на палитре компонентов. Для размещения компонента на форме надо:

выбрать нужную страницу
выделить нужный компонент
щелкнуть левой кнопкой мыши на форме

Задание значений свойств компонентов.

Для задания значения свойства определенного компонента надо:

-выделить нужный компонент
-выделить окно “Object Inspector”
-перейти на страницу Properties в этом окне
-щелкнуть левой кнопкой мыши справа от названия нужного свойства (в строке ввода)
-задать значение для свойства

Общие свойства компонентов.

В Delphi имеется ряд свойств, которые являются общими для большинства компонентов. Рассмотрим эти свойства, представив их в виде таблицы, в которой указаны: параметры, за которые отвечает свойство; название свойства; примечание;

Свойство отвечает за:

Заголовок-подпись к компоненту

Цвет задается двумя способами: выбором из списка или выбором из палитры, которая вызывается двойным щелчком левой кнопкой мыши

Если свойство parentCtl3d установлено в true, то свойство ctl3d компонента будет изменяться вместе со свойством ctl3d главной формы

Форму курсора, находящегося над компонентом

Возможность доступа к компоненту

При значении true компонент доступен, при значении false он остается видимым, но становится не доступным

Изменение параметров шрифта

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

Свойство ShowHint главной формы и свойство ParentShowHint компонента должны иметь значение true

Расстояние от левого края компонента до левого края формы (экрана)

Свойство left формы показывает расстояние до левого края экрана, а свойство left других компонентов-до левого края формы

Расстояние от верхнего края компонента до верхнего края формы (экрана)

Свойство top формы показывает расстояние до верхнего края экрана, а свойство top других компонентов-до верхнего края формы

Имя, в отличие от заголовка, не может повторяться у различных форм в пределах одной программы и у других компонентов-в пределах одной формы в таком случае Delphi, по умолчанию, дает компонентам имена, различающиеся только порядковым номером, например: Form1, Form2, Form3 и т. д. или Button1, Button2, Button3 и т. д.

Для каждого компонента можно выбрать одно из ранее созданных контекстных меню

Данное свойство используется как дополнительное свойство, назначение которого заранее не определено

При значении этого свойства true компонент будет видимым, при значении false-не видимым

Обзор компонент

Каждый компонент имеет уникальное свойство Name. Первоначально Delphi назначает имя по умолчанию, например Form1 или Button2, выбирая первое незанятое имя. Его впоследствии можно изменить по своему усмотрению, подчиняясь при этом некоторым ограничениям: это имя не может уже использоваться другим компонентом и имя не может начинаться с цифры. В целом вы обнаружите, что вполне можно обходиться именами, предоставляемыми Delphi по умолчанию.
Основная палитра компонентов Delphi имеет двенадцать страниц.

Standard
Большинство компонентов на этой странице являются аналогами экранных элементов самой Windows. Меню, кнопки, полосы прокрутки — здесь есть все. Но компоненты Delphi обладают также некоторыми удобными дополнительными встроенными возможностям.

MainMenu — главное меню, создание меню для программ.
PopupMenu — всплывающее меню, создание всплывающего меню для различных компонент.
Label — метка, маркирует компоненты идентификационной надписью.
Edit — окно редактирования, прием от пользователя или вывод на экран одной строки текста.
Memo — окно редактирования, прием от пользователя или вывод на экран многострочного текста.
Button — кнопка, активизирует возможности вашей программы.
CheckBox — флажок параметра, осуществляет выбор одного или более непротиворечивых друг другу параметров.
RadioButton — Радио кнопка, осуществляет выбор между двумя или более взаимоисключающими параметрами.
ListBox — Список, отображение списка элементов с возможностью одиночного или множественного выбора.
ComboBox — комбинированный список, отображение списка элементов с возможностью одиночного выбора.
ScrollBar — полоса прокрутки, отображение или выбор значения из непрерывного числового множества.
GroupBox и RadioGroup — группа, объединение в группы переключателей и флажков параметров или других компонентов, имеющих что либо общее.
Panel — панель для размещения или объединения компонентов.

Additional
Эта страница содержит более развитые компоненты. Например, компонент Outline удобен для отображения информации с иерархической структурой, а MediaPlayer позволит вашим программам воспроизводить звук, музыку и видео. Данная страница также содержит компоненты, главное назначение которых — отображение графической информации. Компонент Image загружает и отображает растровые изображения, а компонент Shape украсит ваши формы окружностями, квадратами и т.д.

Win32
Эта страница содержит компоненты, позволяющие созданным с помощью Delphi программам использовать такие нововведения в пользовательском интерфейсе 32-разрядной Windows, как просмотр древовидных структур, просмотр списков, панель состояния, присутствующая в интерфейсе программы Windows Explorer (Проводник), расширенный текстовый редактор и др.

Data Access и Data Controls.
Delphi использует механизм баз данных компании Borland (Borland Database Engine, BDE) для организации доступа к файлам баз данных различных форматов. Компоненты этих двух страниц облегчают программам Delphi использование сервиса баз данных, предоставляемого BDE, например многопользовательского считывания, записи, индексации и выдачи запросов для таблиц dBASE и Paradox. С использованием этих компонентов создание программы просмотра и редактирования базы данных почти не требует программирования

Win 3.1
На этой странице находятся компоненты Delphi 1.0, возможности которых перекрываются аналогичными компонентами Windows 95.

Internet
Эта страница предоставляет компоненты для разработки приложений, позволяющих создавать HTML-файлы непосредственно из файлов баз данных и других типов, взаимодействующих с другими приложениями для Internet. С помощью компонентов страницы Internet довольно просто создавать обработчики событий для обращения к определенному URL (Uniform Resource Locator — Унифицированный локатор ресурса), представлению документов в HTML-формате и пересылки их клиент-программе.

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

ActiveX
Эта страница содержит компоненты ActiveX, разработанные независимыми производителями программного обеспечения: сетка, диаграмма, средство проверки правописания.

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

Самостоятельная работа
1) Запустить Delphi.
2) Найти главное окно программы, главное меню, полосу быстрого доступа, панель компонентов, окно “Code Editor”, окно “Object Inspector”, окно формы.
3) Создать папку “Мои программы” по адресу c:\Program Files\Borland\Delphi 3. Далее эту папку будем называть рабочей папкой.
4) Сохранить проект, в рабочую папку, используя для файла проекта и файла модуля имена, заданные Delphi по умолчанию ( Выполнить File | Save As…, File | Save Project As…).
5) Просмотреть содержимое рабочей папки, найти файл проекта и файл модуля, обратить внимание на их имена и расширения.
6) Создать новый проект (Выполнить File | New Application или File | New | Выбрать пиктограмму с подписью Application | OK.) Сохранить его в рабочей папке, файл проекта-под именем first_project, файл модуля под именем-first_unit.
7) Разместить на форме form1 по одному компоненту с каждой страницы палитры компонентов.
8) Создать новую форму
9) Сохранить сделанные изменения
10) Откомпилировать проект
11) Вернуться в режим разработки
12) Перейти на главную форму и удалить с нее все компоненты. Выделить все компоненты можно “шатром” или, держа нажатой клавишу Shift, щелкать по нужнум компонентам.
13) На второй форме разместить компонент Button со страницы Standard и задать ему следующие свойства:
-заголовок-“Кнопка1”
-изменить форму курсора
-изменить параметры шрифта, заголовка
-создать всплывающую подсказку (текс подсказки-произвольный)
-расстояние от левого края формы-200 точек, от верхнего края формы-100 точек
-высота-120 точек, ширина-200 точек
14) Разместить на этой же форме еще один компонент Button. Его свойство enabled установить в значение false.
15) Разместить на этой же форме третий компонент Button. Его свойство visible установить в значение false.
16) Просмотреть свойство name у всех трех компонентов и обратить внимание на отличия.
17) Откомпилировать и запустить программу. Обратить внимание на внешние различия между компонентами Button.
18) Вернуться в режим конструктора
19) Сохранить, сделанные изменения
20) Завершить работу с Delphi (Выполнить File | Exit).

"A good example is a debugger when it hits a breakpoint."

Сначала нужно вызвать

SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (LPVOID)0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);

Зтем можно вызывать SetForegroundWindow.

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

сначала сворачиваем нашу прогу
Application.Minimize;

если "сворачивали в трей", то
if not IsWindowVisible(Application.Handle) then
ShowWindow(Application.Handle, SW_SHOW);

ну и восстанавливаем.
Application.Restore;
а уже при ресторе окно вылазит вперёд

кстати, если кто-то предложит лучший метод (без Minimize), буду очень благодарен

Что значит что с ним что без него?
Функция SystemParametersInfo вообще отработала корректно или ты не проверял на предмет ошибки?

Так вот если не проверял то проверь. Это делается с помощью GetLastError если функция SystemParametersInfo вернёт тебе ноль.

Если же функция отработала успешно, то вызови её же но с параметром SPI_GETFOREGROUNDLOCKTIMEOUT и убедись что она возвратит ноль.

После корректного вызова этой функции и установки свойства SETFOREGROUNDLOCKTIMEOUT в ноль система будет сразу делать окно активным с помощью SetForegroundWindow. Система не будет вызывать функцию FlashWindowEx.

я не знаю, какие у вас винды, а уменя WinXp.
под Win2000 всё точно так же.

Да, такая ситуация тоже возможна и она является штатной. Если текущий foreground-процесс вызвал функцию LockSetForegroundWindow.

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

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

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

В результате на форме при нажатии кнопки появится новый компонент TLabel/

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

Назначать обработчики событий для таких компонентов также необходимо непосредственно в коде программы. В качестве примера зададим обработчик события OnClick для компонента TLabel созданного ранее.

Здесь LabelClick имя процедуры обработчика события.

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

Второй способ состоит в использовании процедуры FreeAndNil, которая выполнит оба указанных действия.

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

Работа с динамически создаваемыми компонентами имеет одну тонкость, связанную с особенностями работы редактора кода Delphi.

Чтобы этого избежать рекомендуется объявлять динамически созданные компоненты в других секциях. Например, private или public.

Читайте также: