Справочник по компонентам Delphi. Часть 1

Сначала ознакомимся с общими принципами работы компонентов. 

Класс TList

Класс TList — универсальный список. Он представляет собой массив нетипированных указателей и поэтому годится для хранения набора любых, в том числе разнотипных, данных и объектов. При добавлении/удалении в список данные не создаются и не уничтожаются — эта обязанность лежит на программисте. Приведем доступные ему методы и свойства класса:

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

Наконец, если приведенных методов почему-либо недостаточно, то свойство

 property List: pPointerList; pPointerList = ^TPointerList;
TPointerList = array[0..65520 div SizeOf(Pointer)] of Pointer; 

возвращает указатель непосредственно на список указателен ((ко) означает, что свойство доступно только для чтения).

Класс TStrings

Многофункциональный класс, предназначенный для хранения текстовых строк и связанных с ними объектов (любых потомков TObject). TStrings — абстракт­ный класс; он только описывает методы работы с наборами строк и сопут­ствующих им объектов, но как именно они хранятся, на его уровне не опре­делено. Его потомки очень многочисленны; они играют основную роль в компонентах-списках (TListBox, TComboBox), редакторе (TMemo) и других. Так что вам чаще всего придется иметь дело с TStrings как со свойством одного из компонентов. В дальнейшем экземпляры этого класса и порожденных от него классов мы-будем называть наборами строк. Для создания собственных наборов строк вне компонентов предназначен потомок TStrings — TStringList, который будет рассмотрен ниже.

К строкам и объектам соответственно можно получить доступ через свойства:

 property Strings[Index: Integer]: string; property Objects[Index: Integer]: TObject; 

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

 property Count: Integer; 

Класс TStrings также предназначен для хранения пар вида 'параметр=значение', например, в файлах инициализации (.INI). Эту возможность реализует следу­ющее свойство:

 property Values[const Name: string]: string; 

При обращении к этому свойству для чтения ищется строка, содержащая подстроку (параметр) Name и символ '='. Если она найдена, возвращается то, что находится в этой строке после '='. Если нет, ValuesfName] равно пустой строке. При записи: если строка, содержащая параметр Name, найдена — ее значение после '=' заменяется новым значением, если нет — строка добавля­ется. Если существующему параметру присваивается пустая строка (Values[Name] := ";), то он удаляется из набора строк.

Методы класса приведены в таблице:

Шесть методов предназначены для экспорта/импорта наборов строк:

а) в поток:

procedure LoadFromStream(Stream: TStream); procedure SaveToStream(Stream: TStream); 

б) в файл (создавая поток и вызывая два предыдущих метода):

procedure LoadFrornFile (const FileName: strings-procedure SaveToFile(const FileName: string);

в) в данные в формате текстового редактора (подряд расположенные строки, оканчивающиеся парой символов CR/LF (16-ричные коды SOD/SOA)).

При этом метод

function GetText: PChar; 

выгружает строки в единый массив, где они разделены парами символов CR/LF; в конце такого массива ставится нулевой байт. Размер массива не может превышать 65520 байт; поэтому строки выгружаются до тех пор, пока их суммарная длина не превосходит этого значения.

Метод

procedure SetText(Text: PChar); 

читает строки из массива Text.Строки в массиве должны быть отделены друг от друга парой символов CR/LF; допускается и один символ LF (16-ричный код $ОА). Символы с кодами 0, $lA(+) воспринимаются как конец текста. При этом прежнее содержимое набора уничтожается.

Класс TStringlist

Этот класс объединяет в себе свойства TStrings и TList простейшим способом — указатель на объект и соответствующая строка объединяются в запись, ука­затель на которую хранится в списке. В классе переопределены многие вирту­альные методы TStrings: Add, Clear, Delete, Exchange, IndexOf, Insert; он явля­ется полностью функциональным и вы можете создавать экземпляры TStringList в своей программе для работы с наборами строк и объектов (помимо тех, которые уже есть в компонентах).

Кроме унаследованных от TStrings, определены дополнительно полезные ме­тоды и свойства:

Класс TStream

Класс TStream не нов для библиотек фирмы Borland; он и его потомки на­зываются потоками. Со времен появления в библиотеке Turbo Vision он не претерпел существенных изменений, но теперь потоки стали обязательными составными частями там, где нужно прочитать или передать во внешний источник какую-либо информацию.

TStream "является абстрактной моделью совокупности данных, обладающей двумя свойствами — длиной Size и положением текущего элемента Position:

 property Position: Longint; (Ro) property Size: Longint; 

От TStream порождены дочерние объекты, позволяющие пользоваться мета­форой потока при работе с файлами, блоками памяти и т. п. Так, в модуле CLASSES описаны классы TMemoryStream и TFileStream.

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

 function Read(var Buffer; Count: Longint): Longint; virtual; abstract; 
function Writetconst Buffer; Count: Longint): Longint; virtual; abstract;

Метод

function Seek(0ffset: Longint; Origin: Word): Longint; virtual; abstract; 

позиционирует поток. В зависимости от значения параметра Origin новая позиция выбирается так:

1 - текущая позиция смещается на Offset байт;

2 - новая позиция находится на Offset байт от конца потока.

Методы

procedure ReadBuffer(var Buffer; Count: Longint); 
procedure WriteBuffer(const Buffer; Count: Longint); 

представляют собой оболочки над Read/Write, вызывающие в случае неудачи операции исключительные ситуации EReadError/EWriteError.

Метод

function CopyFromfSource: TStream; Count: Longint): Longint; 

дописывает к потоку Count байт из потока Source, начиная с его текущей позиции. Если значение Count равно нулю, то дописывается весь поток Source с его начала.

Основным отличием реализации TStream в VCL является введение ряда мето­дов, обеспечивающих чтение и запись компонентов в потоки. Они полезны на уровне разработчика новых компонентов и здесь подробно не рассматрива­ются:

 function ReadComponent(Instance: TComponent): TComponent; 
function ReadComponentRes(Instance: TComponent): TComponent; 
procedure WriteComponent(Instance: TComponent); 
procedure WriteComponentRes (const ResName: string; Instance: TComponent); 
procedure ReadResHeader; 

Справочник по функциям Delphi

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

• функции, содержащиеся в модуле SYSTEM и составляющие неотъем­лемую часть самого языка Паскаль. Они не изменялись фирмой Borland уже на протяжении многих версий, и приводить их здесь нет необ­ходимости;
• некоторые функции, относящиеся к тем или иным компонентам и описан­ные в главе 3 вместе с ними.

Большинство упомянутых здесь функций сосредоточено в модуле SYSUTILS. Для функции, которая относится к другому модулю, приведено его имя.

Функции работы со строками

В Delphi вынужденно уживаются два стандарта работы со строковыми дан­ными. Первый из них, когда длина строки записывается в ее первом байте, традиционен для Паскаля. Ему соответствует тип данных string. Другой подразумевает, что строка заканчивается нулевым символом. Такие строки имеют тип PChar и применяются в основном при обращении к функциям API Windows.

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

Первая таблица содержит функции для работы с типом string. Все перечисленные в ней функции находятся в модуле SYSUTILS.

Следующая таблица содержит функции для работы со строками типа PChar (также находятся в модуле SYSUTILS):

Функции работы с файлами

Эта часть библиотеки претерпела изменения в Delphi. К функциям, которые работали с файлом через файловую переменную, добавились функции, рабо­тающие с дескриптором файла. Они рассматривают файл как двоичный; с текстовыми файлами нужно работать "по старинке".

Файловые функции, описанные в модуле SYSUTILS, приведены в таблице:

1. Допустимы следующие режимы открытия файлов:

2. Файлы могут иметь следующие атрибуты:

 faReadOnly = $01; 
faHidden = $02; 
faSysFile = $04; 
faVolumeID = $08; 
faDirectory = $10; 
faArchive = $20; 
faAnyFile = $3F; 

3. Формат структуры TSearchRec таков:

TSearchRec = record
     Fill: array[1..21] of Byte;
     Attr: Byte; 
     Time: Longint; 
     Size: Longint; 
     Name: string[12]; 
end; 

Приведем типовой вариант организации групповой обработки файлов при помощи функций FindFirst, FindNext и FindClose. В нем в список добав­ляются имя и длина всех файлов в каталоге с именем CADELPHI:

var 
    SearchRec: TSearchRec; 
    I : Integer; 
    List : TStringList; 
begin 
    List := TStringList.Create; 
    I := FindFirst('c:\delphi\*.*', faAnyFile, SearchRec); 
    while I = 0 do 
    begin
        List.Add(Format (' File %s has length %d bytes ', [SearchRec.Name, SearchRec.Size]));
        I := FindNext(SearchRec);
    end; 
    FindClose(SearchRec); 
    List.Free; 
end; 
 

При поиске файла наиболее вероятным является код ошибки -18 (файл не найден).

Процедура FindClose не делает ничего в 16-разрядной версии Delphi, однако будет играть роль в 32-разрядной. Употреблять ее следует из соображений переносимости приложений.

4. Ряд "старых" функций переименованы: это связано с появлением одно­именных методов у объектов. Теперь вместо Assign следует употреблять AssignFile, вместо Close — CloseFile. Старые имена поддерживаются ддя совместимости, но могут вызвать проблемы при одновременном употреб­лении с именами методов.

Функции форматирования строк

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

В Delphi существует группа функций форматирования строк. Их рассмотрение начнем с наиболее часто встречающегося представителя — функции Format:

function Format (const Format: string; const Args: array of const) : string;

Первым параметром функции выступает форматирующая строка. Это — обыч­ная текстовая строка, но в ней на нужных местах стоят специальные символы, которые определяют, какие и как туда будут подставлены параметры.

Второй параметр функции Format называется списком аргументов. Он и со­держит "вставляемые" в форматирующую строку параметры. Обратите внимение, что этот открытый массив имеет тип array of const. и в нем может передаваться переменное число разнотипных параметров. Например, после выполнения

S := FormatC Product %s , version %d.%d', [ 'Borland Delphi' , 1, 0]);

строке S будет присвоено • Product Borland Delphi , version 1.0'. Рассмотрим подробнее правила, по которьм составляется форматирующая строка.

"Специальные" места в ней называются спецификаторами формата и пред­ставляют собой следующие конструкции

"%" [index":"] ["-"I [width] ["."prec] type

• символ -%", с которого начинаются все спецификаторы формата (обяза­тельный);
• поле индекса аргумента [ index " : " ] (необязательное);
• признак выравнивания по левому краю ["-"I (необязательный);
• поле ширины [width] (необязательное);
• поле точности [ - . - prec ] (необязательное);
• символ типа преобразования type (обязательный).

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

Функция Format поддерживает следующие символы типа преобразования:

1. Форматирующие символы можно задавать как в верхнем, так и в нижнем регистрах.

2. Тип преобразования m (денежный) тесно связан с правилами представления, принятыми в конкретной стране. Для этого в модуле SYSUTILS определены значения ряда типизированных констант, начальные значения которых бе­рутся из секции [Inti] файла WIN.INI. Вы можете изменять их значения в соответствии с вашими потребностями:

Мы закончили рассмотрение символа типа преобразования. Рассмотрим осталь­ные составные части спецификатора формата.

Поле ширины устанавливает минимально допустимое количество символов в преобразованной строке. Это означает, что если она короче, чем задано в этом поле, то происходит добавление пробелов до требуемого количества. По умолчанию пробелы добавляются спереди (выравнивание по правому краю), но признак выравнивания по левому краю ("-"; он должен стоять перед полем ширины) позволяет выравнивать строку по-иному.

Поле индекса позволяет динамически изменить последовательность извлечения аргументов из массива. Обычно аргументы извлекаются последовательно, по мере их востребования спецификаторами формата. Поле индекса означает, что следующим нужно извлечь аргумент с данным индексом. Пользуясь индексом, одни и те же аргументы могут быть использованы многократно. Например, вызов Format ( ' %s %s %0 : s %s ', [ 'Yes', 'No' ] ) Даст на выходе строку 'Yes No Yes No'.

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

Поля индекса, ширины и точности могут быть заданы напрямую или косвенно. Первый способ подразумевает явное указание значения поля (например, ' %10 . 5f '). Для косвенного задания значений нужно в соответствующих местах цифры заменить звездочками (например, '%*.*f'). В этом случае вместо звездочек будут подставлены следующие значения из списка аргументов (они обязательно должны быть целыми числами). Например, выражение

Format('Value is %*.*',[10,5, 2.718]);

Format('Value is %10.5',[2.718]);

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

Функции преобразования чисел с плавающей точкой

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

Первый — самый простой — представлен функцией FloatToStr:

function FloatToStr(Value : Extended): string;

Число, заданное параметром Value, преобразуется в возвращаемую функцией строку. Формат преобразования соответствует типу преобразования g функции Format, причем длина выходной строки принимается равной 15 символам.

Больше возможностей для управления форматом вывода дает функция:

 function PloatToStrF(Value: Extended; Format: TFloatFormat; Precision, Digits: Integer): string; 

Здесь Value — преобразуемое значение, Format — один из предопре­деленных форматов. Хотя этот параметр имеет тип TFloatFormat, он имеет очень много общего с типами преобразований в функции Format (ссылки на них есть в предлагаемой таблице). Параметр Precision задает общее число символов в выходной строке и не должен превышать 7 для фактичес­кого параметра типа Single, 15 — для Double и 18 — для Extended. Digits — это параметр, интерпретируемый в зависимости от значения параметра Format:

В случае, когда в функцию переданы значения Value, соответствующие особым случаям сопроцессора ("не-число", плюс и минус бесконечность), она возвра­щает соответственно строки 'NAN', 'INF' и '-INF'.

Наконец, возможность полного управления форматом предоставляет функция FormatFloat:

 function FormatFloat(const Format: string; Value: Extended): string; 

Она преобразует число в строку в соответствии со спецификатором формата, содержащимся в параметре Format. Правила его задания следующие:

1. Число всегда округляется до той точности, которую позволяет заданное программистом количество полей для размещения цифр ('0' и '#').

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

3. Символ ';' позволяет задать три разных формата вывода для чисел с разным знаком. При различном количестве форматов они применяются следующим образом:

• один: применяется для всех чисел;
• два: первый применяется для чисел, больших или равных нулю, второй — для отрицательных;
• три: первьш применяется для положительных, второй — для отрицательных чисел, третий — для нуля.

Если форматы для отрицательных чисел или нуля пусты, применяется формат для положительных чисел.

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

Применение спецификатора иллюстрируется в таблице на примере преобразо­вания четырех чисел:

Две следующие функции применяют те же правила, что и рассмотренные выше функции, но отличаются параметрами:

Перейдем к рассмотрению функций преобразования текстовой строки в число. Их две — соответственно для строк типа string и PChar:

 function StrToPloat(const S: string): Extended; 
function TextToFloat(Buffer: PChar; var Value: Extended): Boolean; 

Общие правила для передаваемой в функцию строки таковы:

• допускаются как научный, так и фиксированный форматы;
• в качестве десятичной точки должен выступать символ, который содержится в DecimalSeparator;
• не допускаются символы-разделители тысяч (ThousandSeparator), а также символы обозначения денежньк единиц.

В случае ошибки преобразования функция StrToFloat генерирует исключитель­ную ситуацию EConvertError, a TextToFloat — возвращает значение False.

Функции работы с датами и временем

В Delphi для хранения дать! и (или) времени предусмотрен формат TDateTime, представляющий собой, на самом деле, обычное число с плавающей точкой.

При этом дата представляется целой частью числа, а время — дробной. Преимущество этого подхода в том, что теперь дать! и времена можно кор­ректно складывать и вычитать, например:

var 
    StartTime: tDateTime;

procedure TFormI.PormCreate(Sender: TObject);
begin 
    StartTime := Now; 
end; 

procedure TFormI.FormClick(Sender: TObject); 
begin 
    Labell.Caption := 'Co времени запуска прошло' + DateTimeToStr(Now - StartTime); 
end;
 

Функции этой группы приведены в таблице:

1. Правила задания спецификатора формата для даты и времени отлича­ются от рассмотренных выше. В первую очередь надо иметь в виду то, что функции вроде FormatDateTime оперируют над одним значением TDateTime, а спецификаторы формата извлекают из него те или иные составные части. При этом могут использоваться:

Например, результатом вызова функции с параметрами

FormatDateTime (' "Совещание состоится в" dddd, dirrmim, yyyy, ' + ' "в" hh:nn', StrToDateTime('12/31/95 23:55')) ;

будет строка 'Совещание состоится в среду, 31 декабря 1995 в 23:55' (естес­твенно, если вы переопределили значения элементов массива LongMonth-Names).

3. Спецификаторы могут быть указаны как в верхнем, так и в нижнем регистрах символов — это не играет роли.

4. Начальные значения всех используемых при форматировании даты и вре­мени переменных берутся из секции [inti] файла WIN.INI.

Функции для работы с памятью

Для работы с памятью Delphi предоставляет следующие функции:

Память, выделенная при помощи этих функций, может быть освобождена при помощи функции FreeMem.

У компонента же определение конструктора на удивление лаконично, но в нем присутствует указатель на Owner:

 constructor Create(AOwner: TComponent); 

Ответ прост: Owner — тот объект, который при создании вызывает конструк­торы всех объектов, владельцем которых он является, а при уничтожении — их деструкторы. Таким образом, поместив при разработке компонент на форму, вы можете не заботиться о его создании и уничтожении в программе. Все свойства таких компонентов и все связи между ними запоминаются в файле формы .DFM и при запуске приложения создаются вновь автоматически.

 Деструктор компонента destructor Destroy; 

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

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

Принадлежащие компоненты оформлены в виде списка, доступного через свой­ство Components. В классе TComponent предусмотрен набор методов и свойств для управления этим списком:

Изменять владельца компонента во время исполнения можно, но без особой необходимости не нужно. Дело в том, что используемый для этого метод RemoveComponent не только вычеркивает компонент из списка, но и обнуляет указатель на него в соответствующем поле владельца. Например, если во время визуального проектирования вы поместили на форму кнопку Buttoni, а затем во время выполнения изменили ее владельца, то все обращения к ней в прог­рамме как к Buttoni стали недействительны.

Рассмотрим другие свойства компонента. Он может находиться в одном из множества следующих состояний:

 property ComponentState: TCornponentState; 

TComponentState= set of (csLoading, csReading, csWriting, csDestroying, csDesigning) ;

Эти состояния используются средой во время визуального проектирования, при загрузке/выгрузке компонентов из файлов ресурсов. Во время исполнения приложения множество состояний пусто. Лишь метод

 procedure Destroying; 

устанавливает в состоянии компонента флаг csDestroying и вызывает ана­логичный метод у всех потомков из списка. Он также используется в дест­рукторе компонента.

Свойство Designlnfo относится к стадии разработки (конструирования) приложения:

 property Designlnfo: Longint; 

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

Элементы управления

Потомком TComponent является класс TControl — элемент управления Win­dows. Все то, что видит (или может увидеть) пользователь в клиентской области вашей формы во время выполнения, порождено от класса TControl (клиентская область — вся рабочая поверхность окна Windows, исключая заголовок, полосу меню и обрамление). Таким образом, потомки TControl являются визуалъньши компонентами. Далее будем называть их, как принято в Windows,элементами управления, или, где это уместно, просто элементами.

Отметим также подвох, связанный с названием "Библиотека визуальных ком­понентов" (Visual Components Library, VCL). Называя так свою библиотеку, разработчики из фирмы Borland были абсолютно правы, так как речь идет в первую очередь о новой — визуальной — технологии программирования. Но нужно помнить, что в VCL входит множество полноправных невизуальных компонентов. Например, меню — оно, конечно, видимо на экране, но не в клиентской области; поэтому формально меню не является визуальным ком­понентом.

Большинство из свойств, которые вы будете видеть и изменять в визуальных компонентах, помещенных в Инспектор объектов, впервые описаны в классе TControl. Этот класс уже обладает "поведением" — в нем предусматривается реакция на основные события.

Объект класса TControl не является окном Windows и в силу этого не может получить фокус ввода. Однако у него обязательно имеется родительский эле­мент (см. главу 2, раздел "Наследование. Методы"), обладающий этим свой­ством и отвечающий за показ дочернего элемента и обработку некоторых поступающих ему сообщений. (Раз TControl не является окном, то он не имеет контекста устройства для рисования. Этот контекст обеспечивает ему родитель. Тип родительского элемента — TWinControl — будет рассмотрен ниже).

Обратите внимание на терминологию: Owner — это владелец компонента, а Parent — его родитель, определяемый свойством

 property Parent: TWinControl; 

Элемент управления может обрабатывать сообщения Windows. Чтобы послать собственной функции обработки элемента сообщение Windows вида Msg с параметрами WParam и LParam, можно воспользоваться методом:

 function Perform(Msg, WParam: Word; LParam: Longint): Longint; 

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

 property Caption: TCaption; TCaption= string[255]; 

либо

Text: property Text: TCaption; 

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

 function GetTextBuf(Buffer: PChar; BufSize: Integer): Integer; 
procedure SetTextBuftBuffer: PChar); function GetTextLen: Integer; 

Все три метода работают, посылая в собственную функцию-обработчик со­общений объекта (через вызов метода Perform) сообщения Windows вида WM_GETTEXT, WM_SETTEXT и WM_GETTEXTLENGTH.

Курсор, который будет устанавливаться на компоненте, определен свойством:

 property Cursor: TCursor; TCursor = -32768..32767; 

В Delphi предопределены стандартные типы курсоров. Их имена:

crDefault, crNone, crArrow, crCross, crIBeam, crSize, crSizeNESW, crSizeNS, crSizeNWSE, crSizeWE, crUpArrow, crHourGlass, crDrag, crNoDrop, crHSplit, crVSplit, crMultiDrag, crSQLWait.

Этим именам соответствуют константы со значениями от 0 до -17; под этими идентификаторами все курсоры доступны в свойстве Cursors глобального объекта Screen. Можно добавить к ним собственные курсоры, загрузив их из ресурсов и присвоив положительные идентификаторы:

{$R cursors.RES} 

const
    Curl = 1;
    Cur2 = 2;

procedure TFormI. For-mCreate (Sender: TObject);
begin
    Screen.Cursors[Curl] := LoadCursor(hinstance, 'CUR_1');
    Screen.Cursors[Cur2] := LoadCursor(hinstance, 'CUR_2');
end; 
 

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

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

Первый из них — набор флагов, управляющих поведением компонента:

 property ControlStyle: TControlStyle;
TControlStyle = set of (csAcceptsControls, csCaptureMouse, csDesignInteractive, csClickEvents, csFramed, csSetCaption, csOpaque, csDoubleClicks, csFixedWidth, csFixedHeight);

Эти флаги означают, что данный компонент имеет следующие особенности:

Набор флагов, отражающих состояние элемента, описывается свойством:

 property ControlState: TControlState;
TControlState = set of (csLButtonDown, csClicked, csPalette, csReadingState, csAlignmentNeeded, csFocusing, csCreating);

Свойства ControlStyle и ControlState описаны не в пользовательской докумен­тации, а в документации разработчика новых компонентов. Вы можете читать их значения для получения информации об элементе управления, но изменять их стоит только тогда, когда вы полностью отдаете себе отчет в том, к чему это приведет.

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

 property PopupMenu: TPopupMenu; 

Подробно о его создании и использовании рассказано в разделе, посвященном меню.

Положение, размеры и выравнивание элементов управления

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

 property BoundsRect: TRect; 

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

procedure SetBounds(ALeft, АТор, AWidth, AHeight: Integer);

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

(pb) property Left: Integer; J property Top: Integer; property Width: Integer; 
(Pb) property Height: Integer; 

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

 (Ro) property ClientRect: TRect; 

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

 property ClientHeight: Integer; 
property ClientWidth: Integer; 

Свойство ClientOrigin задает положение начала клиентской области относитель­но экрана:

 (Ro) property ClientOrigin: TPoint; 

Если же нужно связать с координатной системой экрана произвольную точку, пользуйтесь парой методов (не путать с одноименными функциями Windows API):

 function ClientToScreen(const Point: TPoint): TPoint; 
function ScreenToClient(const Point: TPoint): TPoint;

Очень важную часть работы по управлению размерами и расположением эле­ментов выполняет свойство:

 (Pb) property Align: TAlign; 

Оно определяет выравнивание компонента относительно границ родителя. Может принимать одно из предопределенных значений:

alTop, alBottom, alLeft, alRight — выравнивание происходит по соответст­вующей стороне родителя;

alClient — компонент занимает все пространство клиентской области родителя.

Выравнивание гарантирует, что при изменении размеров родителя относитель­ная позиция дочернего элемента не меняется. Это свойство имеет приоритет над простым изменением положения и размеров. Если новые координаты эле­мента противоречат способу его выравнивания (например, перемещение вверх при alBottom), изменения отвергаются и элемент возвращается к первоначаль­ным координатам. Свойство Align незаменимо при организации панелей инструментов и строк состояния — они могут перемещаться и видоизменяться вместе с содержащей их формой. Для временного отключения действия свойства Align предназначены методы:

 procedure DisableAlign; procedure EnableAlign; 

Эти методы управляют возможностью выравнивания потомков данного эле-мекга, они должны вызьшаться в паре. Для восстановления выравнивания элементов в соответствии с Align есть метод:

 procedure Realign; 

В следующем примере использование методов DisableAlign и EnableAlign поз­воляет настроить выравнивание панели по тому краю формы, на который пользователь перетащит ее мышью:

procedure TFormI.FormCreate(Sender: TObject); 
begin 
    Panell.Align := alBottom; 
    Moving := False; 
end;

procedure TFormI.PanellMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin 
    if not Moving then 
    begin
        Formi.DisableAlign;
        Moving := True;
    end;
end;

procedure TFonnl.PanellMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer)
begin
    if Moving then with Panell do 
    begin
        Left := Left + X - Width div 2;
        Top := Top + Y - Height div 2;
        Panell.Caption := Format('%d,%d',[Left,Top]);
    end; 
end;

procedure TFormI.PanellMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var 
    LastPos : TPoint; 
    r0, rl, r2 : real;
begin 
    if Moving then 
    begin
        Moving := False;
        Panell.Caption := '';
        LastPos := Point(Panell.Left + X, Panell.Top + Y);
        if LastPos.X<=0 then 
            LastPos.X := 1;
        if LastPos.X>=ClientWidth 
            then LastPos.X := ClientWidth-1;
        if LastPos.Y<=0 
            then LastPos.Y := 1;
        if LastPos.Y>=ClientHeight 
            then LastPos.Y := ClientHeight-1;
        r0 := ClientWidth/ClientHeight;
        rl := LastPos.X/LastPos.Y;
        r2 := LastPos.X/(ClientHeight - LastPos.Y);
        with Panell do 
            if rl < r0 then 
                if r2 < r0 then 
                    Align := alLeft 
                else
                    Align := alBottom 
            else 
                if r2 < r0 then 
                    Align := alTop 
                else 
                    Align := alRight;
        Formi.EnableAlign; 
    end; 
end; 

Активность и видимость элементов управления

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

 (Pb) property Enabled: Boolean; 

Значение True делает управляющий элемент активным. При смене состояния Enabled выполняется перерисовка его на экране, при которой пассивные эле­менты, как правило, изображаются серьм цветом.

Свойство, определяющее возможность видимости элемента во время испол­нения:

(Pb) property Visible: Boolean;

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

 procedure Show; procedure Hide; 

Напомним, что, так как Visible является свойством, то выражение visible: =True не является простым присваиванием. Оно неявно содержит все необходимые операции для показа элемента управления. Это же касается всех остальных свойств компонентов, реакция на изменение которых должна произойти не­медленно.

Почему выше была применена формулировка "возможность видимости", а не "видимость"? Чтобы элемент был виден на экране, одного значения свойства Visible недостаточно. Нужно, чтобы видимыми были все предки элемента в иерархии. Реально видимость элемента можно узнать, пользуясь свойством:

 (Ro) property Showing: Boolean; 

Это свойство устанавливается при изменении свойства Visible. Оно доступно только для чтения. Нужно иметь в вицу, что при изменении видимости родительского элемента Showing не изменяется и может в какой-то момент не соответствовать истинному состоянию. Обновляет состояние свойства Showing для компонента метод:

 procedure UpdateControlState; 

Отрисовкой (изменением изображения на экране) элемента управления "заве­дуют" следующие методы:

Внутренний интерфейс Drag&Drop

Для библиотеки VCL фирмой Borland реализована собственная версия интер­фейса Drag&Drop (переводится как "перетащить"). Интерфейс этот внут­ренний — передавать и принимать можно любые управляющие элементы Del­phi внутри формы' (кроме самой формы). Он реализован без использования соответствующих функций API Windows — их нужно применять при организации общения с другими задачами путем перетаскивания.

Нажав левую кнопку мыши над элементом управления, мы можем "пере­тащить" его на любой другой элемент. С точки зрения программиста это означает, что в моменты перетаскивания и отпускания клавиши генерируются определенные события, которыми передается вся необходимая информация — указатель на перетаскиваемый объект, текущие координаты курсора и др. Получателем событий является тот элемент, на котором в данный момент находится курсор. Обработчик такого события должен сообщить системе, принимает ли данньш элемент управления "посылку" или нет. При отпускании кнопки над принимающим элементом управления генерируется еще одно или два события, в зависимости от готовности приемника.

Способ работы с этим интерфейсом в VCL определяется свойством:

 (Pb) property DragMode: TDragMode;
TDragMode = (dmManual, dmAutomatic);

Для автоматического включения механизмов, имеющихся в VCL, необходимо, чтобы свойство компонента DragMode было установлено в dmAutomatic. Это означает, что на всех стадиях перетаскивания нужные функции вызываются без участия программиста. Его задача состоит только в том, чтобы определить методы-обработчики соответствующих событий. В режиме dmManual (принимаемом по умолчанию) все необходимые вызовы функций нужно делать самому.

Рассмотрим подробнее формат обработчиков трех основных событий интер­фейса Drag&Drop.

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

(pVl property OnDragOver: TDragOverEvent;
TDragOverEvent = procedure(Sender, Source: TObject; X, Y: Integer;
State: TDragState; var Accept: Boolean) of object; Параметры события: 

• Sender — элемент, над которьм находится курсор;
• Source — перетаскиваемый элемент;
• X, Y — координаты курсора (в системе координат клиентской области Sender);
• State — одно из трех состояний:

TDragState = (dsDragEnter, dsDragLeave, dsDragMove); 

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

• dsDragEnter — курсор мыши появился над элементом;
• dsDragMove — курсор мыши переместился над элементом;
• dsDragLeave — курсор мыши ушел с элемента или была отпущена кнопка.

Обработчик этого события должен возвратить решение, примет ли данный элемент объект Source или нет, в булевой переменной Accept. Если обработчик этого события отсутствует, то элемент управления не может работать приемником, т. е. на него нельзя "перетащить".

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

 (Pb) property DragCursor: TCursor; 

Если компонент не является приемником Drag&Drop, или обработчик события OnDragOver отсутствует или возвращает False, то появляется другой курсор (по умолчанию crNoDrop).

Событие:

(Pb) property OnDragDrop: TDragDropEvent;
TDragDropEvent = procedure(Sender, Source: TObject; X, Y: Integer) of object;

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

В приведенном примере вы можете перетащить одну из геометрических фигур в вашей форме (компонент TShape) на статический текст Label 1. Для этого в Label 1 описано два метода: Label IDragOver сигнализирует о готовности принять только компоненты класса TShape, a Label IDragDrop вычисляет пло­щадь фигуры в квадратных сантиметрах в зависимости от ее вида (эллипс, прямоугольник, прямоугольник с закругленными углами).

procedure TForm1.Label1DragOver (Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean); 
begin 
    Accept := Source is TShape; 
end; 

procedure TForm1.Label1DragDrop (Sender, Source: TObject; X, Y: Integer); 
var 
    f : single; 
    i : Integer; 
begin
    with Source as TShape do 
    begin 
        i := Width; 
        if i > Height then 
            i:= Height;
        case Shape of 
            stRectangle: f := Width*Height; 
            stSquare: f := i * i; 
            stCircle: f := Pi * i*i / 4;
            stEllipse: f := Pi * Widths-Height / 4;
            stRoundRect, stRoundSquare: begin 
                    if Shape = stRoundRect then 
                        f := Width*Height 
                    else 
                        f := i * i; 
                    i := (i - Pen.Width + 1) div 4; 
                    f := f - (4-Pi)*i*i; 
                end; 
            end; 
    end; 
    f := f / Sqr(Forml.PixelsPerInch / 2.54);
    Label1.Caption := FloatToStrF(f, ffFixed, 5, 2)+ ' кв.см';
end; 
 

При завышении перетаскивания, вне зависимости от готовности приемника всегда возникает еще одно событие:

 (Pb) property OnEndDrag: TEndDragEvent;
TEndDragEvent =procedure(Sender, Target: TObject; X, Y: Integer) of object;

Его параметры идентичны описанным выше.

Для управления перетаскиванием вручную (в режиме dmManual) есть следу­ющие возможности. Начало перетаскивания происходит при вызове метода:

 procedure BeginDrag(Immediate: Boolean); 

Программист должен связать вызов этого метода с каким-либо событием в системе. (Если свойство DragMode установлено в dmAutomatic, BeginDrag вы­зывается функцией окна при нажатии левой кнопки мыши). Параметр Imme­diate определяет, когда именно возникает состояние Drag&Drop: в случае True немедленно, в случае False — после смещения мыши с нажатой левой кнопкой на 5 точек по любой из осей. Последний вариант дает возможность исполь­зовать нажатие левой кнопки и для перетаскивания, и для регистрации щелчков на элементе управления (скажем, на кнопке). В режиме dmAutomatic такой возможности нет. Метод:

 procedure DragDrop(DragObject: TObject; X, Y: Integer); dynamic; 

вызывает обработчик события OnDragDrop, а производит все завершающие действия метод

procedure EndDrag(Drop: Boolean); 

Он инициирует события OnDragDrop (при возможности приема) и OnEndDrag.

 Метод function Dragging: Boolean; 

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

Ярлычки и оперативная подсказка

Совсем недавно, с легкой руки Microsoft, признание получили ярлычки с оперативной подсказкой (Hints). Если задержать курсор, например, над кноп­кой или компонентом палитры самой среды Delphi, появляется маленький прямоугольник яркого цвета (окно подсказки), в котором одной строкой ска­зано о названии этого элемента или связанном с ним действии. Delphi под­держивает механизмы создания и отображения таких ярлычков в создаваемых программах.

Свойство, определяющее активность системы подсказки у элемента управления:

 (Pb) property ShowHint: Boolean; 

Если свойство ShowHint установлено в True, и во время выполнения курсор задержался над компонентом на некоторое время, в окне подсказки высвечива­ется текстовая строка с подсказкой:

 (Pb) property Hint: string; 

Подсказка компонента может быть пустой строкой — в этом случае система ищет в цепочке первый родительский компонент с непустой подсказкой. Если в строке Hint встречается специальный символ-разделитель '|', то часть строки до него ("короткая") передается в окно подсказки, а после ("длинная") — присваивается свойству Hint объекта Application. Ее можно использовать, например, в строке состояния внизу главной формы приложения (см. пример ниже).

Система оперативных подсказок имеет свойства и методы, общие для всех форм в приложении. Неудивительно, что они сосредоточены в Application — глобальном объекте, соответствующем работающему приложению. Все описан­ные ниже в этом разделе свойства относятся не к компоненту, показывающему подсказку, а именно к Application.

Цвет окна подсказки можно изменить посредством свойства:

 (Pb) property HintColor: TColor; 

У объекта Application значение свойства ShowHint нужно устанавливать во время выполнения, например, в обработчике OnCreate главной формы приложения. Оно является главенствующим для всей системы подсказок: если оно установлено в False, ярлычки не возникают.

Есть еще один способ получения подсказки. При смене текста в свойстве Hint, т. е. при смене текущего элемента управления, у Application возникает событие:

 (Рb) property OnHint: TNotifyEvent; 

Пример:

procedure TFormI.AppHint(Sender: TObject); 
begin
    Pane 11.Caption:= Application.Hint;
end;

procedure TFormI.FormCreate(Sender: TObject);
begin 
    Application.OnHint := AppHint; 
end; 

В этом примере текст подсказки будет отображаться в строке состояния Panel 1 независимо от значения ShowHint у любого объекта — лишь бы этот текст был в наличии. Для этого разделяйте подсказку у элементов управления вашего приложения на две части при помощи символа '|' — краткая информация появится рядом с элементом, а более полная — в строке состояния.

когда курсор мыши останавливается над элементом управления или пунктом меню, и приложение не занято обработкой сообщения, происходит проверка, и если ShowHint у элемента или у одного из его родительских элементов в иерархии равно True, то запускается специальный таймер на интервал времени HintPause:

 (Pb) property HintPause: Integer; 

Интервал времени по умолчанию равен 800 мс. После истечения времени таймера, если мышь осталась над тем же элементом, наступает момент

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

 (Pl) property OnShowHint: TShowHintEvent;
TShowHintEvent = procedure (var HintStr: string; var CanShow: Boolean; var Hintlnfo: THintInfo) of object; 

с параметрами:

• HintStr — отображаемый текст;
• CanShow — необходимость (возможность) появления подсказки. Если в переменной CanShow обработчик вернет False, то окно подсказки вы­свечиваться не будет;
• Hintlnfo — структура, несущая всю информацию о том, какой элемент управления, где и как собирается показать подсказку. Ее тип:
  

  THintInfo = record HintControl: TControl; 
       HintPos: TPoint; 
       HintMaxWidth: Integer; 
       HintColor: TColor; 
       CursorRect: TRect; 
       CursorPos: TPoint; 
  end; 

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

procedure TFormI.AppShowHint(var HintStr: string; var CanShow: Boolean; var Hintlnfo: THintInfo); 
begin 
    if HintStr='' then 
    begin 
        HintStr := Hintlnfo.HintControl.Name; 
        Hintlnfo.HintColor := ciRed; 
        CanShow := True; 
    end; 
end;
 

Присвоив этот метод обработчику Application.OnShowHint, установив Forml.ShowHint:=True и очистив все строки Hint, получим в качестве под­сказки имя каждого элемента.

"Спрятать" окно подсказки можно с помощью метода:

 procedure CancelHint; 

Без повторного перемещения мыши на текущий элемент оно более не возникнет.

Оконные элементы управления

Понятие окна Windows инкапсулировано в потомке TControl — классе TWinControl. Такой компонент получает соответствующий атрибут _ дескриптор окна, определяемый свойством:

 (Ro) property Handle: HWnd; 

С помощью этого дескриптора вы можете вызывать функции API Windows, если средств VCL вам недостаточно для решения задачи. Компоненты-потомки TWinControl — в дальнейшем будем называть оконными элементами управ­ления, а элементы управления, не имеющие дескриптора окна, — неоконными.

Возможны ситуации, когда компонент уже создан, но еще не имеет дескриптора как окно. Два метода управляют созданием дескриптора:

 function HandleAllocated:Boolean; procedure HandleNeeded; 

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

Важным свойством TWinControl является то, что он может содержать другие — дочерние — элементы управления. Они упорядочены в виде списка. Если быть точным, то списков на самом деле два — для неоконных и оконных дочерних элементов. Но "видны" они как один объединенный — сначала первый, потом второй. Методы и свойства для работы с этим списком приведены в таблице:

С каждым оконным компонентом можно связать контекстную помощь. Кон­текст помощи — это индекс, указывающий на определенную информацию в файле справочной системы, связанном с приложением:

 property HelpContext: THelpContext; 

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

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

Прокрутку (скроллинг) элементов на интервал DeltaX, DeltaY осуществляет метод:

 procedure ScrollBy(DeltaX, DeltaY: Integer); 

Прибегая к вызову этой процедуры, можно при желании осуществить про­крутку нестандартным способом, т. е. без привлечения полос прокрутки. При­веденный ниже фрагмент кода — составная часть примера IMGSCROL на дискете— позволяет "тащить" изображение Imagel вслед за мышью с нажатой кнопкой:

type 
    TMouseState = (msNormal, msDragging); 

var 
    OldPos, NewPos, MaxShift: TPoint; 
    PMouseState : TMouseState; 
    
procedure TFormI.ScrollMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin 
    MaxShift.X := Imagel.Parent.Width - Imagel.Width; 
    MaxShift.Y := Imagel.Parent.Height - Imagel.Height; 
    if (MaxShift.X > 0) and (MaxShift.Y > 0) then Exit; 
    FMouseState := msDragging; OldPos := Point(X, Y); 
    Screen.Cursor := crDrag; 
end; 

procedure TFormI.ScrollMouseMove(Sender : TObject; Shift: TShiftState; X, Y: Integer);
begin 
    if FMouseState = msDragging then 
    begin 
        NewPos := Point(X - OldPos.X, Y - OldPos.Y); 
        if Imagel.Left + NewPos.X > 0 then NewPos.X := - Imagel.Left; 
        if Imagel.Left + NewPos.X < MaxShift.X then NewPos.X := MaxShift.X - Imagel.Left; 
        if Imagel.Top + NewPos.Y > 0 then NewPos.Y := - Imagel.Top; 
        if Imagel.Top + NewPos.Y < MaxShift.Y then NewPos.Y := MaxShift.Y - Imagel.Top; 
        Imagel.Parent.ScrollBy(NewPos.X, NewPos. Y); 
    end; 
end; 

procedure TFormI.ScrollMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); 
begin 
    FMouseState := msNormal; 
    Screen.Cursor := crDefault; 
end; 
 

Обратите внимание, что прокрутка неоконного компонента Imagel осуществ­ляется посредством вызова Image l.Parent.ScrollBy. Это свидетельствует о том, что конкретный родительский тип для этого безразличен. В примере изобра­жение помещено на панель (TPanel). Впрочем, метод ScrollBy используется также и полосами прокрутки, которые есть в компоненте TScrollingWinControl и его потомках, например, в TForm.

В VCL предусмотрена возможность написания приложений, которые будут сохранять относительный размер и положение при всех разрешениях дисплея. Более подробно эти механизмы описаны в разделе, посвященном формам; для TWinControl упомянем лишь метод

 procedure ScaleBy(M, D: Integer); 

который изменяет масштаб элемента управления в M/D раз, при этом верхний левый угол остается неподвижным. Так же изменяются и размеры всех дочерних элементов. Соответственно изменяется и масштаб шрифта (свойство Font). Флаги csFixedWidth и csFixedHeight в свойстве ControlStyle предотвращают изменение ширины или высоты.

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

 (Рb) property Ctl3D: Boolean; 

Нужно уточнить, что это свойство есть не у всех компонентов. Для части компонентов трехмерность реализована средствами VCL; другая же часть (радиокнопки, флажки и др.) требует для создания трехмерного эффекта до­ступа к библиотеке CTL3DV2.DLL.

Шрифт, которым выводится текст, связанный с элементом управления:

 property Font: TFont; 

Кисть, используемая для закрашивания рабочей области оконного элемента управления, представлена свойством:

 (Ro) property Brush: TBrush; 

Она имеет цвет, содержащийся в свойстве Color (по умолчанию clWindow). На уровне TControl оно доступно только по чтению:

property Color: TColor;

Подробно о последних двух типах см. в разделе "Графическая подсистема".

Реакция на события от мыши и клавиатуры

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

(рt) property OnMouseDown: TMouseEvent;
(Pb) property OnMouseUp: TMouseEvent; 
TMouseEvent = procedure(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer) of object;

• Sender — элемент-источник сообщения (обычно равен Self);
• Button — идентификатор одной из кнопок;
• TMouseButton = (mbLeft, mbRight, mbMiddle);
• Shift — множество, которое может содержать элементы:
• ssAlt, ssCtrl, ssShift — в зависимости от состояния этих клавиш;
• ssLeft, ssRight, ssMiddle, ssDouble — в зависимости от нажатия кнопок мыши (ssDouble — нажать! и правая, и левая кнопки);
• X, Y — координаты нажатия (в системе координат клиентской области получателя).

При перемещении мыши возникает событие:

 (Pb) property OnMouseMove: TMouseMoveEvent; 
TMouseMoveEvent = procedure(Sender: TObject; Shift: TShiftState; X, Y: Integer) of object; 

Использование сообщений от мьшш уже встречалось в примерах, приведенных вьппе (например, см. разд. "Положение, размеры и выравнивание элементов управления").

Два события извещают о щелчке и двойном щелчке левой кнопкой мыши над компонентом:

 (pt) property OnClick: TNotifyEvent; 
(Pb) property OnDblClick: TNotifyEvent; 

Отменить генерацию этих событий можно, удалив флаг csClickEvents из слова состояния элемента (ControlStyle). Для некоторых компонентов (например, кно­пок) OnClick возникает еще и при нажатии определенных клавиш на клавиатуре, а также вследствие вызова метода Click.

События, связанные с мышью, могут быть получены потомками TControl. В отличие от них, реакцию на события от клавиатуры могут иметь только оконные элементы управления ("могут", т. к. на уровне TControl и TWinControl эти события только описаны, но не опубликованы). Таким образом, есть компоненты (в том числе в Палитре компонентов), не имеющие связи с этими событиями из-за ее ненадобности. Впрочем, их меньшинство, и материал в этом разделе обобщен вполне обоснованно.

Нажатие и отпускание клавиш клавиатуры могут инициировать следующие события:

 property OnKeyDown: TKeyEvent; 
property OnKeyUp: TKeyEvent; 
TKeyEvent = procedure(Sender: TObject; var Key: Word; Shift: TShiftState) of object; 

Генерация этих событий встроена в обработчики сообщений Windows WMJCEYDOWN, WMJSYSKEYDOWN и WM_KEYUP, WM_SYSKEYUP соответст­венно. Обработчику передаются:

• Sender — источник сообщения;
• Shift — состояние специальных клавиш и кнопок мыши во время нажатия (отпускания);
• Key — код нажатой клавиши, представляющий собой виртуальный код клавиши Windows (константы вида VK_XX, например, VK_F1, VK_ESCAPE и т. п.). Обратите внимание, что Key является var-параметром; т. е. его значение может быть изменено программистом.

Другое событие, возникающее вследствие нажатия клавиши:

 property OnKeyPress : TKeyPressEvent;
TKeyPressEvent = procedure(Sender: TObject; var Key: Char) of object;

Это событие возникает при вводе с клавиатуры символа ASCII, т. е. оно не ге­нерируется, например, при нажатии функциональных клавиш или . Обработчик события вызывается при нажатии буквенных (в т. ч. вместе с ), цифровых клавиш, комбинаций + .. + (коды ASCII #1..#26), , , , + (код #3) и некоторых других. Также код ASCII можно сгенерировать, нажав <А11>+<десятичньш код символа> на числовой клавиатуре (Numeric Pad).

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

 (Pb) property KeyPreview: boolean; 

установлено в True, то сначала все три вида сообщений поступают к ее обработчикам, и только потом — к элементу управления. Если при этом в них обнулить параметр Key, то в элемент сообщение не поступит вообще. В приведенном ниже примере клавиша резервируется для изменения со­стояния формы:

procedure TFormI.FormCreate(Sender: TObject); 
begin 
    KeyPreview := True; 
end;

procedure TFonnl.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); 
begin 
    if Key = VK_F5 then 
    begin
        if ssCtrl in Shift then 
            WindowState := wsNormal
        else 
            if Shift = [] then WindowState := wsMaximized; 
        Key : = 0; 
    end;
end; 
 

Фокус ввода

Будучи окнами Windows, TWinControl и его потомки должны управлять фоку­сом ввода (состоянием, когда они получают и обрабатывают входные сооб­щения). Они имеют предназначенные для этого методы:

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

При получении и утере фокуса оконными компонентами происходят события:

 (Pb) property OnEnter: TNotifyEvent;
(Рb) property OnExit: TNotifyEvent;

TNotifyEvent — простейшее событие — извещение, не имеющее параметров. Свойство

 (Pb) property TabStop: Boolean; 

показывает, есть ли на данном элементе табулостоп. Между элементами формы, у которых TabStop установлено в Тше, можно передвигаться (перемещать фокус ввода) нажатиями клавиш /+. Очередность перехода фокуса определяется специальным списком. Положение элемента управления в родительском списке табулостопов определяется при помощи свойства:

 (Pb) property TabOrder: TTabOrder; 
TTabOrder = -1..32767; 

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

Можно получить и весь список, содержащий иерархию дочерних элементов, имеющих табулостоп:

 procedure GetTabOrderList(List: TList) ; 

Этот метод добавляет в уже существующий список List все дочерние компо­ненты, имеющие табулостоп; каждый из них при добавлении делает то же самое. Таким образом, элементы списка имеют тип TWinControl.

Два метода предназначены для управления показом перекрывающихся до­черних элементов управления:

 procedure BringToFront; procedure SendToBack; 

Метод BringToFront переносит элемент в конец родительского списка (визуа­лизация начинается с первого) и показывает его поверх остальных. SendToBack, наоборот, переносит элемент в начало и таким образом сверху окажутся все перекрывающиеся с ним. При этом элемент теряет фокус ввода (если имел).

Класс инкапсулирует шрифт Windows. В Delphi допускаются только горизон­тально расположенные шрифты. В конструкторе объекта по умолчанию принимается шрифт System цвета clWindowText размера 10 пунктов.

Привязка к родительским свойствам

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

(Pb) property ParentColor: boolean;
(Pb) property ParentCtl3D: boolean;
(Pb) property ParentFont: boolean; 
(Pb) property ParentShowHint: boolean; 

Все четыре свойства отвечают за наличие связи между соответствующими свойствами в родительских и дочерних элементах. Если какое-то из них у элемента установлено в True, это означает, что он наследует свойство от родителя и меняет цвет, трехмерность, шрифт или показ ярлычков вместе и вслед за ним. Но если само свойство дочернего элемента (например, Color или ParentColor) переустановить явно, то связь с родительским свойством разрьюается.

Графическая подсистема

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

Другой бич работы с графикой в Windows — проблема рационального исполь­зования ресурсов. Для больших программных комплексов она стала в по­следнее время нешуточной (это касается, по крайней мере, версий Windows до 3.11 включительно). Такие монстры, как Microsoft Office, потребляют во время работы львиную долю ресурсов. В Delphi ресурсами GDI незримо для пользователя "заведуют" специальные менеджеры, ведущие списки всех разме­щенных кистей, перьев, шрифтов и т. п. и управляющие их использованием.

Обязательным для любого объекта, связанного с графикой в Delphi является событие

 property OnChange: TNotifyEvent; 

Его обработчик вызывается всякий раз, когда изменились какие-то харак­теристики объекта, влияющие на его внешний вид.

В стандартном GDI основой для рисования служит дескриптор контекста устройства hDC и связанные с ним шрифт, перо и кисть. В состав VCL входят объектно-ориентированные надстройки над последними, назначением которых является удобный доступ к свойствам инструментов и прозрачная для поль­зователя обработка всех их изменений. Сначала опишем три этих класса.

Класс TFont

Свойства класса приведены в таблице:

Класс ТРеn

ТРеп = class(TGraphicsObject)

Инкапсулирует перо. В конструкторе по умолчанию создается непрерывное (psSolid) черное перо шириной в один пиксел. Свойства класса приведены в таблице:

Класс TBrush

Инкапсулирует кисть. Первоначально создается белая сплошная (bsSolid) кисть. Свойства класса приведены в таблице:

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

Класс TCanvas

 TCanvas = class(TPersistent) 

Этот класс — сердцевина графической подсистемы Delphi. Он объединяет в себе и "холст" (контекст конкретного устройства GDI), и "рабочие инстру­менты" (перо, кисть, шрифт) и даже "подмастерьев" (набор функций по рисованию типовых геометрических фигур).

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

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

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

 property Handle: HDC; 

Для рисования канва включает в себя шрифт, перо и кисть:

 (рb) property Font: TFont ; 
(Pt) property Pen: TPen; 
(Рb) property Brush: TBrush; 

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

property Pixels[X, Y: Integer]: TColor;

соответствует цвету точки с координатами (X,Y).

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

Метод

procedure Refresh; 

сбрасывает текущие шрифт, перо и кисть, заменяя их на стандартные, заимство­ванные из Windows (BLACK.PEN, HOLLOW_BRUSH, SYSTEM.FONT).

Предусмотрено два события для пользовательской реакции на изменение канвы:

 property OnChange: TNotifyEvent; 
property OnChanging: TNotifyEvent; 

Эти события возникают при изменениях свойств и вызовах методов TCanvas, меняющих вид канвы (то есть при любом рисовании. В MoveTo, например, они не возникают). Отличие их в том, что OnChanging вызывается до начала изменений, a OnChange — после их завершения.

Идентификатор (код) растровой операции при копировании прямоугольных блоков содержится в свойстве

 (Pb) property CopyMode: TCopyMode; 
TCopyMode = Longint; 

и определяет правило сочетания пикселов, копируемых на канву, с ее текущим содержимым. При этом можно создавать разные изобразительные эффекты. В Delphi определены следующие константы кодов: cmBlackness, cmDstInvert, cmMergeCopy, cmMergePaint, cmNotSrcCopy, cmNotSrcErase, cmPatCopy, cmPatInvert, cmPatPaint, cmSrcAnd, cmSrcCopy, cmSrcErase, cmSrcInvert, cmSrcPaint, cmWhiteness.

Все они стандартно определены в Windows, и подробное их описание можно найти в документации по GDI. Значением CopyMode по умолчанию является cmSrcCopy — копирование пикселов источника поверх существующих.

Использование графики иллюстрируют несколько примеров, имеющихся на дискете, прилагаемой к книге. Обратите внимание на пример MOVLINES — в нем показано, как создавать и использовать канву для всего экрана. Помимо графических примитивов, таких как линии и фигуры, на канве можно разместить готовые изображения. Для их описания создан класс TGraphic.

Класс TGraphic

 TGraphic = class(TPersistent) 

Этот абстрактный класс является родительским для трех видов изображений, общепринятых в графике Windows — значка (класс TIcon), метафайла (класс TMetafile) и растровой картинки (класс TBitmap).

Работая над приложением в Delphi, вы никогда не будете создавать объекты класса TGraphic, но переменной этого типа вы можете присваивать указатель на любой из классов-потомков. Метод

 procedure Assign(Source: TPersistent); 

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

Загрузку и выгрузку графики в поток осуществляют методы

 procedure LoadFromStream(Stream: TStream); 
procedure SaveToStream(Stream: TStream); 

а загрузку и выгрузку в файл:

procedure LoadFromFile(const Filename: string); 
procedure SaveToFile(const Filename: string); 

Эти методы создают соответствующий файловый поток и затем вызывают методы LoadFromStream/SaveToStream.

Два метода осуществляют взаимодействие с буфером обмена:

 procedure LoadFromClipboardFormat(AFomat: Word; AData: THandle; APalette: HPALETTE); 
procedure SaveToCiipboardPormat(var AFormat: Word; var AData: THandle; var APalette: HPALETTE); 

Здесь AFormat — используемый графический формат; AData и APalette _ данные и палитра (если она требуется). Потомок должен иметь свой формат и уметь обрабатывать данные, представленные в нем. Свойство

 (Ro) property Empty: Boolean; 

устанавливается в True, если графический объект пуст (в него не загружались данные).

Высота и ширина графического объекта:

 property Height: Integer; property Width: Integer; 

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

 property Modified: Boolean; 

показывает, модифицировался ли данный графический объект. Это свойство устанавливается в True внутри обработчика события OnChange.

Класс TPicture

 TPicture = class(TPersistent) 

Класс-надстройка над TGraphic, точнее — над его потомками. Он содержит поле Graphic, которое может содержать TBitmap, TIcon и TMetafile. Предна­значение TPicture — управлять вызовами соответствующих методов, скрывая при этом хлопоты с определением типа и детали их реализации.

Кроме того, на уровне TPicture определены возможности по регистрации и использованию других — определенных пользователем — классов графических объектов, порожденных от TGraphic. Доступ к графическому объекту осу­ществляется посредством свойства:

 property Graphic: TGraphic; 

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

 property Bitmap: TBitmap; 
property Icon: TIcon; 
property Metafile: TMetafile; 

Если в поле Graphic хранился объект одного класса, а затребован — другого, то прежний объект уничтожается, а вместо него создается пустой объект нуж­ного класса. Если же вы описали свой класс (допустим, TDIB), то к его методам и свойствам следует обращаться так:

 (Graphic as TDIB).My Property := MyValue; 

Перечислим остальные методы и свойства:

Все три разновидности графических объектов имеют свои системы кэширования. Это означает, что на один реально существующий в системе (и занимающий долю ресурсов!) дескриптор могут одновременно ссыпаться не­сколько объектов. Реализуется такое связывание через метод Assign. Выражение

 Iconi.Assign(Icon2) ; 

означает, что два этих объекта разделяют теперь один значок.

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

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

Кого-то может удивить отсутствие объявленных методов рисования вроде Draw у TIcon, TMetafile и TBitmap. Такие методы есть, но они недоступны. Все рисование должно осуществляться через вызовы методов Draw и StretchDraw канвы, содержащей графику, ибо канва несет тот контекст, в котором должна осуществляться операция. Рассмотрим предопределенные графические классы.

Класс TMetafile

TMetafile = class(TGraphic)

Инкапсулирует свойства стандартного метафайла Windows. В нем перекрыва­ются методы Assign, LoadFromStream, SaveToStream, LoadFromClipboardFormat, SaveToClipboardFormat. В буфер обмена объект помещает свое содержимое в формате CF_METAFILEPICT. Помимо общих, класс имеет свойства:

Класс TIcon

TIcon = class(TGraphic)

Не пытайтесь изменить размеры значка — они постоянны (равны GetSystemMetrics(SM_CXICON) и GetSystemMetrics(SM_CYICON)), и при попытке присвоить новые значения возникает исключительная ситуация EInvalidGraphicOperation. Значок нельзя также читать и писать в буфер обмена, так как в Windows нет соответствующего формата. В этом классе перекрываются методы класса TGraphic: Assign, LoadFromStream и SaveToStream. Дополнительно также определены:

Класс TBitmap

 TBitmap = class(TGraphic) 

Класс соответствует битовой карте, зависимой от устройства (Device — dependent bitmap, DDB). В нем перекрываются методы Assign, LoadFromClipboardFormat, LoadFromStream, SaveToClipboardFormat, SaveToStream. Объект взаимодействует с буфером обмена в формате CF_BITMAP.

Канва битовой карты доступна через свойство:

 (ro) property Canvas: TCanvas; 

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

Дескрипторы битовой карты и ее палитры доступны как свойства:

 property Handle: HBITMAP; 
property Palette: HPALETTE; 

Два метода

function ReleaseHandle: HBITMAP; 
function ReleasePalette: HPALETTE; 

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

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

 procedure Dormant ; 

— выгружает изображение в поток и уничтожает дескрипторы битовой карты и палитры,

 procedure Freelmage; 

— "освобождает" дескриптор битовой карты для дальнейшего использования и внесения изменений. Это означает, что если на данный дескриптор есть ссылки, то он дублируется; поток очищается.

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

 property Monochrome: Boolean; 

Значение True соответствует монохромной битовой карте. При его изменении происходит преобразование содержимого к требуемому виду.

"Фоновый" цвет битовой карты:

 (Ro) property TransparentColor: TColor; 

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

Функции для работы с графикой

В модуле GRAPHICS сосредоточен целый ряд полезных функций:

Для преобразования битовой карты из зависимого от устройства формата DDB в независимый (DIB) предназначены две функции:

Описание компонентов VCL

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

Для каждого из компонентов приводятся все методы и свойства, которые доступны программисту, работающему с этим компонентом, то есть описанные как public и published (в т. ч. недокументированные). Мы попытались проиллюстрировать некоторые неочевидные вещи хотя бы коротким фрагмен­том кода. В развернутом виде примеры использования компонентов можно найти на дискете, прилагаемой к книге.

Работа с меню

• Главное меню. Такое меню принадлежит форме и отображается вместе с ней под ее панелью заголовка. Если в приложении несколько форм, то для удобства можно объединять меню всех активных форм в одном.
• Всплывающее меню. Такое меню предусмотрено почти у всех компонен­тов — элементов управления Windows. Оно возникает (всплывает) при нажатии правой кнопки мыши на этом компоненте. Предусмотрено такое меню и у формы.

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

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

Принципы создания и работы с меню в Delphi очень просты. Каждому пункту меню соответствует свой компонент класса TMenuItem. Вы добавляете к меню новые пункты (а к форме — новые компоненты) либо во время разработки (при помощи Конструктора меню), либо во время исполнения. При выбо­ре пункта меню для описывающего его компонента инициируется событие OnClick, в обработчике которого и нужно предусмотреть соответствующие действия.

Компонент TMenuItem

 TObject—>TPersistent—>TComponent—>TMenuItein 

Модуль MENUS в Палитру компонентов не входит. Этот компонент, который является основой системы меню в Delphi, вы не встретите в Палитре компонентов — он входит в состав имеющихся там компонентов TMainMenu и

TPopupMenu

Текст, содержащийся в пункте меню, определяется свойством:

 (Pb) property Caption: string; 

Помимо основной, он несет еще две дополнительные нагрузки. Во-первых, если в строке имеется амперсанд ('&'), то он вместе с следующим за ним символом является акселератором. Например, для строки '&File' нажатие + означает выбор этого пункта. Во-вторых, если текст состоит из одного символа '-', то этот пункт служит в меню разделителем (имеет стиль MFJSEPARATOR);

Помимо акселератора может быть описана еще одна комбинация клавиш, нажатие которой равнозначно выбору пункта. Она должна содержаться в свойстве: •

 (Pb) property Shortcut: TShortCut; TShortCut = Low(Word)..High(Word); 

Способы выбора пункта меню — щелчок мышью, нажатие на сфо­кусированном пункте, нажатие акселератора или горячей комбинации, наконец, вызов метода

 procedure Click; 

приводят к возникновению события:

(Рb) property OnClick: TNotifyEvent;

Компонент TMenuItem может различать только это событие, с которьм до­лжны быть связаны действия, ради которых вы ввели данный пункт в меню. Воспринимают это событие те пункты меню, которые в данный момент активны, что означает-установленное в True свойство:

 (Рb) property Enabled: Boolean; 

Если Enabled равно False, пункт изображается серьм цветом и не воспринимает сообщений.

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

 (Pb) property Checked: Boolean; 

отвечает за то, является ли этот пункт отмеченным.

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

 (Pb) property Break: TMenuBreak;
TMenuBreak = (mbNone, mbBreak, mbBarBreak);

призвано решить эту проблему. Если оно установлено в mbBreak, то ко­манды меню, начиная с этой, располагаются в новом — соседнем с преж­ним — столбце (при этом их принадлежность не изменяется). Если оно равно mbBarBreak, столбцы при этом разделяются вертикальной чертой. В Delphi все компоненты меню типа TMenuItem могут быть как простыми командами, так и подменю, имеющими собственный список пунктов. В случае, если у компонента дочерних подменю и пунктов нет, для него имеет смысл свойство:

 (Ro) property Command: Word; 

Прежде при написании меню нужно было выдумывать и присваивать уникаль­ный идентификатор каждому его пункту — то есть собственно код команды, который посылался в качестве параметра сообщения WM.COMMAND. Сейчас эта задача возложена на Delphi — программист не только не определяет, но может и не знать кода команды, связанного с этим пунктом меню. Система выберет уникальное значение автоматически и присвоит это значение свойству Command. Изменять его не разрешается.

Интерпретация сообщений меню скрыта от программиста. Система сама опре­деляет, какой пункт выбран, и вызывает его обработчик события OnClick.

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

Если у компонента TMenuItem имеются дочерние пункты, то он является подменю, имеет статус MF_POPUP и дескриптор меню Windows, доступный для чтения через свойство:

(ro)property Handle: HMENU;

Пункты меню иерархически связаны. Методы и свойства для работы с до­черними пунктами меню приведены в таблице.

Если пункт меню находится в фокусе, нажатие вызовет систему помощи с контекстом, определенным в свойстве:

 (Pb) property HelpContext: THelpContext; 

Свойство (Pb)

property Grouplndex: Byte; 

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

Компонент TMenu

 TObject—>TPersistent->TComponent->TMenu 

Модуль MENUS В Палитру компонентов не входит. Этот компонент отсутствует в Палитре компонентов, но содержит методы и свойства, приведенные в таблице, общие для двух потомков — TMainMenu и TPopupMenu, которые туда входят.

В следующем примере метод обрабатывает сообщение Windows WM_MENUSELECT, которое возникает при перемещении фокуса между пунк­тами меню. В зависимости от типа пункта показывается его дескриптор или команда:

procedure TFormI.wmMenuSelect(var Msg :TWMMenuSelect); 
var 
    Anitem : TMenuItem; 
begin 
    with Msg do 
    begin
        if (MenuFlag and MF_POPUP <>0 ) then 
        begin 
            Anitem := Formi.Menu.Findltem(Idltem, fkHandle);
            if Anitemonil then 
                Labell.Caption := 'Handle:'+IntToHex(Anitem.Handle,4);
            end 
        else begin
            Anitem := Formi.Menu.Findltem(Idltem, fkCommand);
            if Anitemonil then Labell.Caption := 'Command:'+IntToHex(Anitem.Command,4); 
        end; 
    end; 
    inherited;
end;  
 

Компонент TMainMenu

 TObject—>TPersistent->TComponent->TMenu->TMainMenu 

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

• Если в приложении имеется несколько форм со своими меню, то для упрощения работы целесообразно соединить их в одно и управлять меню из главной формы.
• Объединение меню нужно при работе с интерфейсом MDI и его подокнами.
• Механизм объединения меню используется серверами OLE, запускаемыми по месту нахождения объекта OLE. Загружаясь, сервер дописывает осу­ществляемые им операции к меню другого приложения.

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

 (Рb) property AutoMerge: Boolean;

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

 procedure Merge(Menu: TMainMenu); 

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

procedure Unmerge(Menu: TMainMenu);

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

Объединение меню происходит по специальным правилам, в основе которых лежит использование группового индекса (свойства Group Index) каждого объек­та TMenuItem.

У пунктов меню одного уровня, в частности всех подменю верхнего уровня в главном меню, свойство Grouplndex является неубывающим, т. е. у после­дующего пункта групповой индекс больше либо равен индексу предыдущего. Это требование отслеживается как на этапе разработки, так и на этапе испол­нения. Например, пусть пункты меню имеют индексы О, 3, 4, 5, 6. Если вы включите пункт меню с индексом 5 между пунктами с индексами 0 и 3, то 3 и 4 будут изменены на 5. А вот изменить большее значение Х на меньшее Y, если впереди есть пункты с индексом, большим Y, невозможно. Если в этом примере попытаться изменить индекс 6 на 4, то это приведет к возникно­вению исключительной ситуации EMenuError.

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

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

К окнам интерфейса MDI все сказанное относится только при запуске приложения. Если в формах приложения со стилем fsMDIChild есть свои главные меню, то в этот момент они автоматически сольются с главным меню формы fsMDIForm независимо от состояния AutoMerge. На уровне работы с серверами OLE предусмотрены дополнительные возможности по объединению меню. Если в компонент TOLEContainer загружен объект OLE, то в конец подменю Edit обычно добавляется подменю, из которого можно вызвать функции открытия и редактирования этого объекта. После активизации сервера он может не только вставлять свои подменю в главное, но и добавлять новые пункты к уже существующим подменю.

Три метода TMainMenu используются для работы с меню OLE:

procedure PopulateOle2Menu(SharedMenu: HMenu; Groups:array of Integer; var Widths: array of Longint);
procedure GetOle2AcceleratorTable(var hAccel : THandle; var numAccels: Word; Groups: array of Integer);
procedure Set01e2MenuHandle(Handle: HMENU);

Конструктор меню Delphi поможет значительно упростить разработку меню. В нем имеются готовые шаблоны типовых подменю верхнего уровня: File, Edit и др; пример их использования см. в проекте DEMOEDIT на дискете, прилагаемой к книге. Можно также определить свои шаблоны.

Компонент TPopupMenu

TObject->TPersistent—>TComponent->TMenu->TPopupMenu

Модуль MENUS
Страница Палитры компонентов Standard

Этот компонент описывает всплывающее меню. В отличие от главного, собственное меню такого типа может быть почти у каждого оконного элемента управления на форме (кроме переключателей), а также у самой формы. Всплывающее меню обычно связывают с нажатием правой кнопки мьппи. Чтобы это правило соблюдалось, нужно установить в True свойство

(Pb) property AutoPopup: Boolean;

Для вызова этого меню из программы используйте метод:

procedure Popup(X, Y: Integer);

который показывает его, помещая в точку экрана (X,Y) точку панели меню, определенную свойством:

(Pb) property Alignment: TPopupAlignment;
TPopupAlignment = (paLeft, paRight, paCenter) ;

В зависимости от его значения в точке щелчка появится:

• paLeft — левый верхний угол;
• paRight — правый верхний угол;
• paCenter — середина верхней стороны.

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

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

(Pb) property OnPopup: TNotifyEvent;

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

property PopupComponent: TComponent;

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

Контекст помощи всплывающего меню задается свойством:

(Pb) property HelpContext: THelpContext;

Функции для работы с меню

Рассмотрим также описанные в модуле Menus полезные функции для управления меню.

Четыре функции предназначены для преобразования типа TShortCut, представляющего горячую комбинацию клавиш:
а) в символ+состояние специальных клавиш и обратно:

procedure ShortCutToKey(Shortcut: TShortCut; var Key: Word; var Shift: TShiftState);
function Shortcut(Key: Word; Shift: TShiftState): TShortCut;

б) в текст и обратно:

function ShortCutToText(Shortcut: TShortCut): string;
function TextToShortCut(Text: string): TShortCut;

Новые меню и их составные части можно создавать, пользуясь функциями: