Новая версия средства быстрой разработки Windows-приложений Delphi интересна не только своей новизной, но и тем, что это — продукт фирмы, выступающей уже под новым названием — INPRISE Corporation. Тем не менее знакомое всем название Borland сохраняется в виде тороговой марки, под которой объединены все средства разработки: Delphi, C++Builder и JBuilder.

В новой версии Delphi произошел ряд изменений и улучшений в среде разработчика. Среди них — “плавающие” окна, расширения функциональности, средства управления проектами, различные улучшения в редакторе и отладчике.

Главное окно Delphi 4 теперь состоит из ряда “плавающих” окон, каждое из которых может перемещаться по экрану. Это относится к панели инструментов, палитре компонентов и меню. Так, например, можно “растянуть” панель инструментов в один ряд и переместить палитру компонентов так, как это показано на следующем рисунке.

Процесс перемещения компонентов главного окна прост и интуитивен, и мы не будем тратить время на его подробное описание. Отметим лишь то, что любой элемент, имеющий слева специальную полоску, которая называется move handle, может быть перемещен в любое место главного окна, а также размещен в виде отдельного окна. Кроме того, есть возможность отменить для любого окна docking-style. В общем, вы настраиваете среду максимально удобным для вас образом.

Ряд полезных дополнений появился в редакторе кода. К ним относится, например, возможность автоматического создания шаблонов для методов, процедур и функций, опиcанных в секции объявления. Например, если мы введем новый метод Demo:

    type
    TForm1 = class(TForm)
    private
    { Private declarations }
    procedure Demo(S : String);
    public
    { Public declarations }
    end;

и подведем курсор к его описанию, то при нажатии комбинации клавиш Ctrl-Shift-C получим следующий шаблон в секции implementation:

    procedure TForm1.Demo(S: String);
    begin
    end;

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

    type
    TForm1 = class(TForm)
    private
    { Private declarations }
    procedure Demo(S : String);
    procedure Demo1(S : String);
    procedure Demo2(S : String);
    procedure Demo3(S : String);
    public
    { Public declarations }
    end;

то при выполнении указанной выше операции мы автоматически получим шаблоны для всех объявленных методов. Для перемещения между описаниями методов и их реализацией следует использовать комбинации клавиш Ctrl-Shift-UpArrow и Ctrl-Shift-DownArrow. Эта возможность распространяется также и на обычные процедуры и функции.

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

    type
    TForm1 = class(TForm)
    private
    { Private declarations }
    public
    { Public declarations }
    property DemoProp : String;
    end;

нажатие комбинации клавиш Ctrl-Shift-C приведет к автоматической генерации следующего кода:

    type
    TForm1 = class(TForm)
    private
    FDemoProp: String;
    procedure SetDemoProp(const Value: String);
    { Private declarations }
    public
    { Public declarations }
    property DemoProp : String read FDemoProp
    write SetDemoProp;
    end;

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

    procedure TForm1.SetDemoProp(const Value: String);
    begin
    FDemoProp := Value;
    end;

Данная технология называется Class Completion.

Module Explorer — это окно, располагаемое по умолчанию слева от редактора кода. Иерархическое представление составных частей нашей программы — методов, процедур, функций, переменных и констант, используемых модулей позволяет легко перемещаться по исходному тексту.


Различные настройки Module Explorer задаются на вкладке Explorer в панели Environment Options, вызываемой по команде Tools | Environment Options.

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

Новая версия утилиты Project Manager поволяет объединять вместе несколько проектов. Это облегчает работу над проектами, которые содержат более одного исполняемого файла. Используется один исполняемый файл и несколько DLL или комбинация из нескольких DLL, ресурсов и исполняемых файлов.

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

Добавлять к проекту новые элементы можно не командой File | New, а через нажатие правой кнопки мыши в группе проектов и выбор необходимого компонента.

В Delphi 4 введено понятие групы проектов как совокупности проектов исполнимых модулей (exe и dll), ресурсов и т.п. Файлы групп проектов сохраняются с расширением .BPG и представляют собой команды make:

    #———————————————————————————————
    VERSION = BWS.01
    #———————————————————————————————
    !ifndef ROOT
    ROOT = $(MAKEDIR)..
    !endif
    #———————————————————————————————
    MAKE = $(ROOT)binmake.exe -$(MAKEFLAGS) -f$**
    DCC = $(ROOT)bindcc32.exe $**
    BRCC = $(ROOT)binbrcc32.exe $**
    #———————————————————————————————
    PROJECTS = Project1.exe
    #———————————————————————————————
    default: $(PROJECTS)
    #———————————————————————————————
    Project1.exe: Project1.dpr
    $(DCC)

При этом проект, как и ранее, представляет собой программу на языке Pascal:

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

В Delphi 4.0 появился ряд полезных дополнений, помогающих облегчить процесс отладки разрабатываемых приложений. Выполните команду View | Debug Windows, и вы получите список различных окон, которые отображают информацию, полезную при отладке программ.

Назначение этих окон перечислено в следующей таблице.

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

В левой верхней части окна перечислены используемые модули, в нижней — модули, из которых собрано наше приложение. В правой части перечислены процедуры и функции, реализованные в данном модуле. Отсюда вы можете перейти в окно просмотра дизассемблера и регистров процессора — CPU Window. Достаточно выбрать какую-либо процедуру или функцию и дважды щелкнуть по ее имени.

Окно дизассемблера и регистров процессора позволяет отслеживать и модифицировать состояние регистров процессора и просматривать ассемблерный код выбранных процедур, функций и методов. Нажатие правой кнопки мыши обеспечивает доступ к набору команд: Run to Current, Toggle Breakpoint, Go to Address, Go to Current EIP, Follow, Caller, Previous, Search, View Source, Mixed, Change Thread и New EIP.

Окно EventLog служит для просмотра протокола событий, происходящих в системе во время работы вашей программы. Это окно может показать процесс загрузки стандартных компонентов Windows, таких как OLEAUT32.DLL или KERNEL32.DLL, а также отобразить стандартные сообщения Windows, сообщения типа WM-MOUSEMOVE и сообщения, выводимые с помощью функции OutputDebugString.

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

    procedure TForm1.Button1Click(Sender: TObject);
    begin
    OutputDebugString(‘Отладочное сообщение’);
    end;
    то сможем прочитать его в окне EventLog.

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

    {$DEFINE DEBUG}
    ...
    {$IFDEF DEBUG}
    // Если задан режим отладки
    ...
    OutputDebugString(‘Отладочное сообщение’);
    ...
    {$ENDIF}

В отладчике появилась возможность просмотра значений идентификаторов. Проще показать это на примере. Создайте новое приложение (File | New Application). Расположите в форме кнопку, в обработчике которой напишите следующий код:

    procedure TForm1.Button1Click(Sender: TObject);
    begin
    ShowMessage(‘Hello’);
    end;

Клавишей F5 установите точку останова на строке с вызовом метода ShowMessage.

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

    var
    Form1: TForm1;

Установите курсор на Form1 и дважды щелкните мышью для того, чтобы выбрать слово Form1. Теперь нажмите правую кнопку мыши и в меню выберите команду Debug | Inspect. В результате этих действий на экране появится окно Debug Inspector.

Как видно из приведенного рисунка, вкладки Data, Methods и Properties позволяют изучить значения величин (переменных, констант и свойств)и адреса методов. Если у нас используются какие-то компоненты (в данном примере TButton), то мы можем вызвать окно просмотра и для данного компонента.

Delphi поддерживает удаленную отладку EXE, DLL и пакетов, содержащих отладочную информацию. При удаленной отладке используются следующие компоненты: Клиентская среда, предоставляющая пользовательский интерфейс для отладки (delphi32.exe). Отладочный сервер на удаленной машине (borrdbg.exe). В функции сервера входит управление отлаживаемой программой и взаимодействие (через сетевое соединение) с клиентской средой. Отладочный сервер использует две специальные библиотеки — bordbk40.dll и dcc40.dll.

Для установки поддержки удаленной отладки следует запустить программу setup.exe из каталога RDEBUG на CD Delphi 4.0.

В Delphi 4.0 появился ряд новых расширений языка, среди которых можно выделить следующие: динамические массивы; перегрузка методов; параметры по умолчанию; 64-битные целые; 32-битные беззнаковые целые. Динамические массивы

В дополнение к обычным статическим массивам, которые объявляются, например, как:

    myArray : Array[0..255] of Byte; // Статический массив

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

myArray : Array of Byte; // Динамический массив

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

    SetLength(myArray, 16);

В результате вы получите массив, состоящий из 16 байт, с индексами от 0 до 15. Чтобы освободить память, отведенную под динамический массив, достаточно присвоить переменной значение nil:

    myArray := nil;

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

    var
    myArray, myCopy : Array of Byte;
    begin
    SetLength(myArray, 16);
    myArray[15] := $FF; // 255
    myCopy := myArray;
    myCopy[15] := $80; // 128
    end;

В результате работы данного кода значение myArray[15] будет не 255, как ожидается, а 128, так как myArray и myCopy используют одну и ту же область памяти.

При работе с динамическими массивами возможно использование функций Length (возвращает число элементов в массиве), High (возвращает самый большой индекс массива) и Low (возвращает самый маленький индекс массива). Например:

    var
    myArray : Array of Byte;
    I : Byte;
    begin
    SetLength(myArray, 16);
    for I := Low(myArray) to High(myArray) do
    begin
    myArray[I] := $FF;
    end;
    end;

Помимо создания одномерных динамических массивов в Delphi 4 возможно создание и многомерных динамических массивов. Например:

    var
    myArray : array of array of byte;
    I, J : Integer;
    begin
    SetLength(myArray, 16);
    for I := Low(myArray) to High(myArray) do
    begin
    SetLength(myArray [I], I);
    for J := Low(myArray[I]) to High(myArray[I]) do
    myArray[I,J] := I*J;
    end;
    end;

Возможность перегрузки функций и методов выла введена в Delphi 4.0 в первую очередь для обеспечения более простого взаимодействия между Delphi, C++Builder и JBuilder. Так, например, в С++ любой класс может иметь несколько методов с одинаковыми именами, каждый из которых отличается от другого только набором параметров. Введение перегрузки методов в Delphi позволяет обеспечить поддержку синтаксиса C++.

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

function OverloadDemo(val : Byte) : string; overload;
function OverloadDemo(val : Char) : string; overload;

Такой подход делает ваш код более простым, его легче сопровождать и расширять. Давайте посмотрим, как это работает. Сначала напишем объявления двух наших методов, которые должны находиться в секции private:

    type
    TForm1 = class(TForm)
    ...
    private
    { Private declarations }
    function OverloadDemo(val : Byte) : string; overload;
    function OverloadDemo(val : Char) : string; overload;
    public
    { Public declarations }
    end;

Вот код, который реализует эти методы:

    function TForm1.OverloadDemo(val: Byte): string;
    begin
    ShowMessage(‘Параметр типа Byte = ‘+IntToStr(val));
    end;
    function TForm1.OverloadDemo(val: Char): string;
    begin
    ShowMessage(‘Параметр типа Char = ‘+val);
    end;

Затем добавим в форму две кнопки, в обработчике события onClick первой из них напишем вызов функции OverloadDemo с параметром типа Byte:

    procedure TForm1.Button1Click(Sender: TObject);
    begin
    OverloadDemo($ff)
    end;

а в обработчике второй — вызов функции OverloadDemo c параметром типа Char:

    procedure TForm1.Button2Click(Sender: TObject);
    begin
    OverloadDemo(‘A’)
    end;

Запустим наше приложение и поочередно нажмем одну и другую кнопку. В первом случае мы получим сообщение “Параметр типа Byte = 255”, во втором — “Параметр типа Char = А”.

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

    type
    TClass1 = class(TObject)
    function OverloadDemo (val: Byte) : string;
    overload; virtual;
    end;
    TClass2 = class(TClass1)
    function OverloadDemo(val : Char) : string;
    reintroduce; overload;
    end;
    ...
    SomeObject := TClass2.Create;
    // Вызывается TClass2.OverloadDemo
    SomeObject.OverloadDemo (‘A’);
    // Вызывается TClass1.OverloadDemo
    SomeObject.OverloadDemo ($ff);

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

procedure Hello(Name : String = ‘Без имени’);

а ее код выглядит так:

    procedure TForm1.Hello(Name: String);
    begin
    ShowMessage(‘Здравствуйте, ‘ + Name);
    end;

Расположим в форме две кнопки — Hello1 и Hello2. В обработчике события onClick первой кнопки напишем следущий код:

    procedure TForm1.Button1Click(Sender: TObject);
    begin
    Hello
    end;

а в обработчике второй — такой код:

    procedure TForm1.Button2Click(Sender: TObject);
    begin
    Hello(‘Алексей’)
    end;

В первом случае процедура Hello вызывается без параметров и используется параметр по умолчанию. В результате на экране мы увидим сообщение “Здравствуйте, Без имени”. Во втором случае процедура Hello вызывается с указанием параметра — на экране мы увидим сообщение “Здравствуйте, Алексей”.

Для поддержки целочисленных значений, которые могут иметь очень большие величины для представления в виде 32-битного типа LongInt, в Delphi 4 введен новый тип данных — Int64 (64-битные целые). Диапазон значений этого типа данных — от –263 до 263 –1. Функции High, Low, Succ, Pred, Inc, Dec, IntToStr, IntToHex, Round и Trunc поддерживают тип Int64. Для поддержки нового типа данных также введены две новые функции StrToInt64 и StrToInt64Def.

В Delphi 4 введен новый тип данных LongWord, представляющий собой 32-битовые беззнаковые целые числа, находящиеся в диапазоне от 0 до 4 294 967 295. Тип данных Cardinal в Delphi 4 эквивалентен LongWord.

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

    TSomeIClass = class(TInterfacedObject, IOne, ITwo)

При этом интерфейсы IOne и ITwo должны были быть реализованы внутри класса TSomeIClass. Теперь мы можем “разнести” реализацию интерфейсов по отдельным классам, написав следующее объявление класса TSomeIClass:

    TSomeIClass = class
    private
    FOne : TOne;
    FTwo : TTwo;
    published
    property One : TOne read FOne implements IOne;
    property Two : TTwo read FTwo implements ITwo;
    end;

В данном объявлении класса мы указываем, что интерфейсы IOne и ITwo реализуются в своих собственных классах TOne и TTwo, что намного нагляднее и проще для реализации. Продемонстрированный выше подход называется делегированием интерфейсов.

Обратите внимание, что интерфейсы Delphi являются неотъемлемой частью языка Object Pascal и в своей основе никак не связаны с моделью COM. При этом совместимость с моделью COM составляет 100%.

Ряд расширений и изменений коснулся и библиотеки Visual Component Library (VCL). Эти новинки рассматриваются ниже.

Класс TObject пополнился двумя методами — AfterConstruction и BeforeDestruction, кторые доступны всем классам, так как известно, что TObject является предком для всех классов, создаваемых в Delphi.

Как следует из их названия, метод AfterConstruction вызывается автоматически сразу же после после конструктора объекта, метод BeforeDestruction — перед деструктором. Введение этих методов вызвано тем, что в некоторых ситуациях нам требуется вызвать метод сразу же после конструктора и непосредственно перед деструктором.

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

    //—————————————————————//
    // Пример использования методов
    // AfterConstruction и BeforeDestruction
    //—————————————————————//
    program D4Demo;
    uses
    SysUtils, Dialogs;
    type
    TDemo = class
    constructor Create; virtual;
    destructor Destroy; override;
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
    public
    S : String;
    end;
    { TDemo }
    procedure TDemo.AfterConstruction;
    begin
    Inherited;
    ShowMessage(S);
    end;
    procedure TDemo.BeforeDestruction;
    begin
    S := ‘Destructed...’;
    Inherited;
    end;
    constructor TDemo.Create;
    begin
    Inherited;
    S := ‘Constructed...’;
    end;
    destructor TDemo.Destroy;
    begin
    ShowMessage(S);
    Inherited;
    end;

    { Основная программа }
    var
    Demo : TDemo;
    begin
    Demo := TDemo.Create;
    Demo.Free;
    end.

Данное свойство позволяет задать минимальный и максимальный размер компонента. Свойство Constraints имеет тип TSizeConstraints, который содержит поля Control (для задания компонента, размеры которого устанавливаются) и MaxHeight, MaxWidth, MinHeight и MinWidth для непосредственного задания максимальных и минимальных значений высоты и ширины компонента.

Приведем небольшой пример использования свойства Constraints. Расположим в форме две кнопки (TButton) и компонент TMemo. В обработчике нажатия первой кнопки напишем следующий код:

    //
    // “Зафиксировать” размер компонента
    //
    procedure TForm1.Button1Click(Sender: TObject);
    begin
    with Memo1 do
    begin
    Constraints.MinHeight := Height;
    Constraints.MinWidth := Width;
    Constraints.MaxHeight := Height;
    Constraints.MaxWidth := Width;
    end;
    end;

а в обработчике второй — такой код:

    //
    // Уменьшить ширину и высоту на 50 пискелов
    //
    procedure TForm1.Button2Click(Sender: TObject);
    begin
    with Memo1 do
    begin
    Height := Height - 50;
    Width := Width - 50;
    end;
    end;

Если вы нажмете сначала первую кнопку, а затем вторую, изменения размера компонента TMemo не произойдет, так как он “зафиксирован” с помощью свойства Constraints. Если же после запуска программы вы сразу же нажмете вторую кнопку, размер компонента TMemo изменится.

В Delphi 4.0 появилась программная поддержка создания плавающих окон, которые могут “прикрепляться” к форме или другим компонентам. Ниже перечислены шаги, которые необходимо предпринять для того, чтобы преобразовать стандартную форму или компонент в площадку, куда можно “прикреплять” другие окна. Установите значение свойства DockSite в True. Установите значение свойства DragKind “плавающего” компонента в dkDock. Установите значение свойства DragMode “плавающего” компонента в dmAutomatic. Запустите приложение Теперь вы можете двигать “плавающие” компоненты. Списки действий (TActionList)

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

В Delphi 4.0 появился ряд новых интерфейсных элементов — компоненты TMonthCalendar, TPageScroller и TControlBar, назначение и использование которых рассматриваются ниже.

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

Свойство CalColors позволяет задать или изменить цвет фона всего компонента (BackColor), фона, на котором будет отображаться календарь (MonthBackColor), фона текста для дней (TextColor), текста дней недели (TitleBackColor), названия месяца (TitleTextColor) и текста для дней, не входящих в текущий месяц (TrailingTextColor). Обычно значения этих цветов задаются в момент разработки программы в ObjectInspector, но вы можете изменить их и программно. Ниже показано, как это сделать:

    procedure TForm1.Button1Click(Sender: TObject);
    var
    CC : TMonthCalColors;
    begin
    // Создать экземпляр TMonthCalColors
    CC := TMonthCalColors.Create(MonthCalendar1);
    // Задать цвет текста
    CC.TextColor := clWhite;
    // Уничтожить экземпляр
    CC.Free;
    end;

Свойство Date (тип TDate) содержит дату, выделенную в календаре. В момент запуска программы это свойство содержит текущую системную дату. Это свойство можно также использовать и для установки даты.

Свойство FirstDayOfWeek позволяет задать порядок следования дней недели в календаре. По умолчанию используются системные установки (dowLocaleDefault), но при необходимости это могут быть понедельник (dowMonday), вторник (dowTuesday)… воскресенье (dowSunday).

Свойства ShowToday и ShowTodayCircle позволяют указать, должен ли календарь отображать текущую дату и должна ли она быть выделена.

Также имеется возможность отображения номера недели — для этого используется свойство WeekNumbers.

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

    procedure TForm1.MonthCalendar1Click(Sender: TObject);
    begin
    {Показать выбранную дату}
    Edit1.Text := DateToStr(MonthCalendar1.Date);
    end;

Так как дата хранится в формате TDate, для вывода ее в виде текстовой строки необходимо выполнить преобразование — для этого мы используем функцию DateToStr.

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

Пример использования ряда свойств компонента TMonthCalendar показан ниже:

    unit MCUnit;
    interface
    uses
    Windows, Messages, SysUtils, Classes, Graphics,
    Controls, Forms, Dialogs,
    StdCtrls, ComCtrls;
    type
    TForm1 = class(TForm)
    MonthCalendar1: TMonthCalendar;
    Edit1: TEdit;
    ComboBox1: TComboBox;
    DateTimePicker1: TDateTimePicker;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    CheckBox1: TCheckBox;
    CheckBox2: TCheckBox;
    CheckBox3: TCheckBox;
    procedure MonthCalendar1Click(Sender: TObject);
    procedure ComboBox1Change(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure DateTimePicker1Change(Sender: TObject);
    procedure CheckBox1Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure CheckBox2Click(Sender: TObject);
    procedure CheckBox3Click(Sender: TObject);
    private
    { Private declarations }
    public
    { Public declarations }
    end;
    var
    Form1: TForm1;
    implementation
    {$R *.DFM}
    procedure TForm1.MonthCalendar1Click(Sender: TObject);
    begin
    {Показать выбранную дату}
    Edit1.Text := DateToStr(MonthCalendar1.Date);
    end;
    procedure TForm1.ComboBox1Change(Sender: TObject);
    begin
    {Изменить значение свойства FirstDayOfWeek}
    with ComboBox1 do
    begin
    MonthCalendar1.FirstDayOfWeek :=
    TCalDayOfWeek(ItemIndex);
    {Показать текущую дату}
    MonthCalendar1Click(Self);
    end;
    end;
    procedure TForm1.FormCreate(Sender: TObject);
    begin
    {Выбрать первый элемент из списка}
    ComboBox1.ItemIndex := 0;
    end;
    procedure TForm1.DateTimePicker1Change(Sender: TObject);
    begin
    MonthCalendar1.Date := DateTimePicker1.Date;
    {Показать текущую дату}
    MonthCalendar1Click(Self);
    end;
    procedure TForm1.CheckBox1Click(Sender: TObject);
    begin
    {Включить/Отключить отображение номеров недель}
    MonthCalendar1.WeekNumbers :=
    (Sender As TCheckBox).Checked;
    end;
    procedure TForm1.CheckBox2Click(Sender: TObject);
    begin
    {Включить/Отключить отображение текущей даты}
    MonthCalendar1.ShowToday :=
    (Sender As TCheckBox).Checked;
    end;
    procedure TForm1.CheckBox3Click(Sender: TObject);
    begin
    {Включить/Отключить выделение текущей даты}
    MonthCalendar1.ShowTodayCircle:=
    (Sender As TCheckBox).Checked;
    end;
    end.

Примечание. Компонент TMonthCalendar игнорирует значение свойства BiDiMode и отображает дату в соответствии с текущими системными установками.

Данный компонент (страница Win32 панели компонентов) аналогичен по функциональности компоненту TScrollBox, за исключением того, что он обеспечивает прокрутку только по одному направлению — по горизонтали (значение свойства Orientation равно soHorizontal) или по вертикали (значение свойства Orientation равно soVertical).

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

Размер области скроллера задается свойством ButtonSize, а отступ границы этой области от содержимого — с помощью свойства Margin.

Использование данного компонента лучше всего показать на примере. Создайте новое приложение, разместите в нем компонент TPageScroller и установите значение его свойства Align равным alClient. Затем поместите в форму, например, компонент TMemo и запустите приложение. Измените размер окна приложения. Вы увидите, что справа (или слева) появилась область для скроллирования.

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

Этот компонент (страница Additional панели компонентов) служит в качестве “подложки” для элементов инструментальной панели. Отличием данного компонента от TPanel является то, что отдельные элементы могут перемещаться внутри него. Лучшим примером использования данного компонента является сама среда Delphi 4.0 — посмотрите, как работают панели инструментов в верхней части экрана.

На следующих рисунках показано, как можно использовать компонент TControlBar для размещения нескольких компонентов TPanel — эти компоненты могут перемещаться внутри TControlBar. Значение свойства AutoSize установлено в True.

Примечание. Для того чтобы панели (или другие элементы) могли перемещаться внутри компонента TControlBar, значение свойства DockSite должно быть установлено в True.

На смену компонентам ActiveX фирмы NetManage, обеспечивавшим создание Internet-приложений в предыдущих версиях Delphi, в версии 4.0 появились VCL-компоненты FastNet, разработанные фирмой NetMasters.

Бесплатные обновления данных компонентов можно получить на Web-узле фирмы по адресу: http://www.netmastersllc.com/.

При выполнении команды File | New… мы попадаем в диалоговую панель New, на вкладке ActiveX которой мы найдем несколько новых иконок, среди них — Automation Object для создания контроллеров Automation и COM Object для создания небольших COM-объектов, не поддерживающих Automation. Последние могут при необходимости влючать в себя библиотеку типов.

Delphi 4 предоставляет разработчикам полную поддержку COM и текущих расширений этой модели в области многопоточности (MTS). Вам предоставляется полный спектр потоковых моделей: single, apartment, STA (Single Thread Apartment), free, MTA (Multi Thread Apartment) и both (сочетание apartment и free).


Редактор библиотек типов позволяет просматривать и редактировать библиотеки типов либо в формате IDL, либо в Object Pascal (по умолчанию). Поддерживается экспорт библиотек типов либо в Microsoft IDL, либо в CORBA IDL.

Технология Microsoft Transaction Server (MTS) представляет собой попытку фирмы Microsoft превратить COM в некоторое подобие CORBA. Она является средой выполнения, работающей на сервере, и обеспечивает сервисы транзакций, защиту данных, управление ресурсами и внедрение распределенных COM-приложений на сервере.

В состав Delphi 4 Client/Server Suite входит полный набор средств, предназначенных для создания приложений, использующих сервисы MTS. Создание приложения начинается с выполнения команды File | New и выбора вкладки Multitier. Затем вы выбираете либо MTS Object, либо MTS Data Module. И в том, и в другом случае вам необходимо создать ActiveX Library, что произойдет автоматически при выборе соответствующего “мастера”.

Объект MTS представляет Automation с двойственным интерфейсом, реализующий интерфейс IObjectControl и обеспечивающий доступ к объекту, реализующему интерфейс IObjectContext. Эти два интерфейса являются ключевыми для объекта MTS.

Модуль данных MTS data module (TMtsDataModule) является таким же, как и объект MTS, но его предком является класс TRemoteDataModule, а не TMtsAutoObject. Структура объектов создается с помощью редактора библиотеки типов, где вы задает необходимые характеристики объекта — флаги, поддержку транзакций и т.п.

После того как MTS-объект создан, вы устанавливаете его с помощью команды Run | Install MTS Objects...

Помимо MTS Delphi 4 поддерживает создание объектов CORBA (Common Object Request Broker Architecture), базирующихся на стандарте OMG. CORBA-клиенты могут обращаться к CORBA-объектам, реализованным на удаленных серверах. Следует отметить, что в отличие от MTS CORBA не является Windows-специфичным протоколом и, таким образом, CORBA-клиенты могут взаимодействовать с объектами не на Windows-платформах.

Delphi 4 Client/Server Suite содержит ряд средств для создания CORBA-объектов. Вы начинаете работу с выполнения команды File | New и выбора вкладки Multitier. Затем вы выбираете либо CORBA Object, либо CORBA Data Module. Вы используете редактор библиотеки типов для задания основных характеристик объекта. Для того чтобы объекты могли “общаться” друг с другом, необходим специальный “мост”, называемый ORB (Object Request Broker). В состав Delphi для этих целей входит Inprise VisiBroker.

В следующей таблице перечислены основные классы, обеспечивающие поддержку технологии CORBA.

Компонент TTable теперь содержит новые редакторы, позволяющие изменить модель хранения данных. Задав значение свойства TableName, вы можете переименовать или даже удалить саму таблицу. Если вы задали имя несуществующей таблицы, вы можете, используя редакторы для свойств FieldDefs и Indexdefs, создать новую таблицу прямо в дизайнере форм.

В состав Delphi 4 входит BDE 5, оспечивающий доступ к Access 97, расширенным типам полей Oracle 8, включая абстрактные типы данных (ADT), массивы, ссылки и вложенные таблицы. Для этого в библиотеке VCL реализованы новые классы — TADTField, TReferenceField, TDataSetField и TArrayField.

Компонент TDBGrid также поддерживает отображение ADT и вложенных таблиц.

Компоненты TQuery поддерживают запросы на языке SQL, которые можно создавать с помощью SQL Builder — средства, пришедшего на смену Visual Query Builder. Новый SQL Builder обеспечивает полную синхронизацию между текстом запроса на языке SQL и его визуальным представлением.

На странице QReport можно обнаружить несколько новых компонентов, среди которых — TQRTextFilter, TQRHTMLFilter и TQRCSVFilter. Эти компоненты позволяют сохранять отчеты не в формате QReport (файл с расширением *.qrp), но и в виде текстовых файлов, HTML-файлов или CSV-файлов.

Для публикации данных в Internet в Delphi 4 входит специальное средство DB Web Application Wizard.

С его помощью можно создавать приложения для серверов, поддерживающих протоколы ISAPI/NSAPI, CGI- и Win-CGI-приложения, отображающие “живые” данные из выбранной вами базы данных.

В данном обзоре мы рассмотрели основные новинки и возможности Delphi 4. В следующей таблице перечислены функциональные возможности Delphi 4, отсутствующие в версии Standard, и основные отличия между версиями Professional и Client/Server.

Дополнительную информацию можно получить на Web-узле фирмы по адресу: http://www.inprise.com/delphi/.

Одним из важнейших источников информации по Delphi, C++Builder и другим продуктам и технологиям Inprise являются группы новостей news-сервера forums.inprise.com (в сумме их более 120). Отличительной особенностью этих конференций является то, что вопросы, поднимаемые в этих конференциях, анализируются непосредственно специалистами Inprise, а в случае необходимости эти специалисты принимают активное участие в обсуждении поднимаемых проблем, наравне с постоянно действующей группой независимых консультантов — TeamB.

Ниже перечислены основные группы новостей, посвященные Delphi.