    Основные понятия 

    ГЛАВА 3 

    Хотя данная книга предназначена не для тех, кто совершенно незнаком с 
Delphi, я счел нужным остановится вкратце на основных понятиях, используемых 
при разработке приложений с помощью Delphi. Эта информация может оказаться 
полезной для тех разработчиков, которые ранее работали с системами, 
кардинально отличающимися от Delphi. В таком случае краткое изложение 
некоторых концепций поможет вам быстрее освоится в новой для вас среде 
разработки. Если же эти концепции вам уже хорошо известны, можете пропустить 
эту главу и сразу перейти к главе 4, "Соглашения". 
    В этой главе вы ознакомитесь с основными понятиями, которыми оперирует 
Delphi при разработке приложений. Вы узнаете, что такое проекты, библиотеки, 
программные модули, формы, модули данных и включаемые файлы. Последнее (по 
порядку изложения, но отнюдь не по значимости) понятие, описание которого 
ожидает вас в этой главе, — компоненты. 

    Два слова о проектах 

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

    Проекты Delphi 

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

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

    Глава 3. Основные понятия 47 

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

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

    Листинг 3.1. Файл проекта RENTMAN 

    program RENTMAN; 

    uses 
      Forms, 
      RENTDATA in 'RENTDATA.pas' {dmRENTMAN: TDataModule'}, 
      ANYFORM in '..\..\CH09\CODE\ANYFORM.pas' {fmAnyForm}, 
      DBFORM in '..\..\CH09\CODE\DBFORM.pas' {finDatabaseForm}, 
      EDITFORM in ' .. \..\CH09\CODE\EDITFORM.pas' {fmEditForm}, 
      REMPENTO in 'REMPENTO.pas' {fmREMPENTO}, 
      RSYSMANO in 'RSYSMANO.pas' { fmRSYSMANO}, 
      RWKTENTO in 'RWKTENTO.pas' {fmRWKTENTO}, 
      CGRDFORM in '..\..\CH09\CODE\CGRDFORM.pas' {fmControlGridForm}, 
      RTENCGDO in 'RTENCGDO.pas' (fmRTENCGDO}, 
      RPROCGDO in 'RPROCGDO.pas' {fmRPROCGDO}, 
      RLEACGDO in 'RLEACGDO.pas' {fmRLEACGDO}, 
      MSTRFORM in 'MSTRFORM.pas' {fmMasterDetailForm}, 
      GRIDFORM in 'GRIDFORM.pas' {fmGridForm}, 
      RWORGRDO in 'RWORGRDO.pas' {fmRWORGRDO}, 
      RWORMDEO in 'RWORMDEO.pas' {fmRWORMDEO}, 
      RCALGRDO in 'RCALGRDO.pas' {fmRCALGRDO}, 
      RCALEDTO in 'RCALEDTO.pas' {fmRCALEDTO}, 
      RPROLSTO in 'RPROLSTO.pas' {frRPROLSTO}; 
    
    ($R *.RES) 

    begin 
      Application.Initialize; 
      Application.HelpFile := 'C:\Data\Word\CSD\CH13\Code\Rentman.hlp' ; 
      Application.CreateForm(TfmRSYSMANO, fmRSYSMANO) ;
      Application.CreateForm(TdmRENTMAN, dmRENTMAN) ; 
      Application.CreateForm(TfmREMPENTO, fmREMPENTO) ;
      Application.CreateForm(TfmRWKTENTO, fmRWKTENTO) ;
      Application.CreateForm(ТfmRTENCGDO, fmRTENCGDO) ;
      Application.CreateForm(TfmRPROCGDO, fmRPROCGDO) ;
      Application.CreateForm(TfmRLEACGDO, fmRLEACGDO) ;
      Application.CreateForm(TfmRWORGRDO, fmRWORGRDO) ;
      Application.CreateForm(TfmRWORMDEO, fmRWORMDEO) ;
      Application.CreateForm(TfmRCALGRDO, fmRCALGRDO) ;
      Application.CreateForm(TfmRCALEDTO, fmRCALEDTO) ;
      Application.CreateForm(TfrRPROLSTO, frRPROLSTO) ;
      Application.Run ;
    end. 

    Ключевое слово program 

    Обратите внимание на ключевое слово program в первой строке листинга 3.1. 
Оно сообщает компилятору, что данная программа предназначена для создания 
выполняемого файла. В файлах, после компиляции которых создаются библиотеки 
динамической компоновки или программные модули, ключевое слово program 
заменяется словом library или unit, соответственно. 

    48 Часть I. Основы 

    Оператор uses 

    В операторе uses перечисляются программные модули Object Pascal, которые 
система Delphi должна скомпоновать с данной программой при создании 
выполняемого файла. Программные модули (unit) — это молекулы, из которых 
состоит приложение, разработанное в Delphi. При компиляции система проверяет 
дату последней модификации каждого программного модуля и, если выясняется, что 
эта дата более "свежая", чем дата создания бинарного откомпилированного файла 
модуля, выполняется автоматическая перекомпиляция каждого такого программного 
модуля. В некоторых системах разработки такие операции выполняются утилитой 
или командой make. 
    Модуль Forms, с которого в листинге 3.1 начинается перечень модулей 
проекта, — одна из составных частей библиотеки визуальных компонентов (VCL — 
Visual Component Library) Delphi. Назначение этого модуля, как видно из 
названия, состоит в определении характеристик форм в приложениях, 
разрабатываемых в Delphi. Остальные .модули представляют собой формы, 
созданные для данного конкретного проекта. В каждой строке приведено имя 
модуля, имя файла, указанное по правилам операционной системы, а также имя 
формы, хранящейся в данном модуле. Имя формы берется из значения свойства Name 
каждого объекта класса ТForm в том виде, в котором оно отображается в окне 
Object Inspector Delphi. С тех пор, как в Delphi была добавлена поддержка 
длинных имен, имя модуля и имя файла, в котором он хранится, могут совпадать 
без каких-либо ограничений, за исключением, конечно, расширения имени файла. 
Если во время компиляции Delphi не сможет найти модуль по его длинному имени, 
компилятор предпримет попытку использовать краткое (усеченное) имя. 

    Директива $R 

    Под перечнем модулей проекта в. листинге 3.1 находится так называемая 
директива компилятора $R. Она сообщает компилятору, что в проект нужно 
включить ресурс Windows, указанный в тексте директивы. Символ звездочки, 
использованный в качестве имени файла, означает, что имя файла ресурса 
совпадает с именем файла проекта. При компиляции проекта в выполняемый файл 
Delphi создает ресурсный файл как для самого проекта, так и для каждой его 
формы. Если какой-то из таких ресурсных файлов не будет найден во время 
компоновки приложения, Delphi выдаст сообщение типа File not found xxx.RES. 

    Application.CreateForm 

    Операторы Application.CreateForm предназначены для загрузки форм в 
память. Обычно в файле проекта с помощью этих операторов создаются все формы 
приложения. Однако вы можете отключить режим автоматического создания форм с 
помощью команды Options=>Projects главного меню интегрированной среды 
разработки (IDE — Integrated Development Environment) Delphi. Ссылка на каждый 
объект формы хранится в соответствующей переменной экземпляра формы 
(например fmRSYSMANO), объявляемой в разделе interface программного модуля 
формы. Так как файл проекта с помощью оператора uses подключает все 
программные модули форм, он может различать классы форм и передавать их в 
качестве параметров при вызове метода CreateForm объекта Application. Методы 
Application.CreateForm загружают формы указанных классов в память и 
возвращают указатели на них в соответствующих переменных экземпляра. 
    Порядок следования операторов Application.CreateForm определяет 
последовательность, в которой создаются формы. Форма, создаваемая с помощью 
первого оператора Application.CreateForm, является главной формой приложения. 
Если вы хотите изменить порядок создания форм, не редактируйте исходный текст 
проекта, а используйте команду Project=>Options=>Application. 

    Application.Run 

    Вызовом метода Run объекта Application начинается собственно работа 
приложения. Этот метод запускает цикл обработки сообщений, на котором 
построена работа приложения, завершающаяся при поступлении сообщения о 
закрытии приложения. 

    Библиотеки 

    В Delphi реализован очень удобный подход к разработке библиотек 
динамической компоновки (DLL) Windows. В отличие от других языков 
программирования для Windows, в языке Object Pascal предусмотрены специальные 
конструкции, предназначенные для разработки DLL, — ключевые слова library и 

    Глава 3. Основные понятия 49 

exports. Первое из этих ключевых слов, как я уже упоминал, используется в 
начале программного модуля вместо ключевого слова program, если необходимо, 
чтобы компилятор создавал файл в формате DLL, а не ЕХЕ. С помощью ключевого 
слова exports объявляются функции, которые будут экспортироваться из этой 
библиотеки DLL другими выполняемыми файлами. В листинге 3.2 приведен пример 
исходного текста небольшой библиотеки DLL. 

    Листинг 3.2. Библиотека StrUtil 

    library StrUtil; 

    Uses 
      SysUtils; 
    function Pad(InString: String; Len: Integer): String; 
    begin 
      Result:=Format('%-*s', [Len, InString]) ; 
    end; 
    function LPad(InString: String; Len: Integer): String; 
    begin 
      Result:=Format('%*s',[Len, InString]) ; 
    end; 
    exports 
      Pad index 1; 
      LPad index 2; 
    begin 
    end. 

    Как видно из листинга 3.2, по форме исходный текст библиотеки почти не 
отличается от исходного текста обычных программ. Обратите внимание, что в 
начале листинга использовано ключевое слово library, а не program. Оператор 
exports сообщает компилятору, что функции Pad и LPad нужно обработать как 
экспортируемые, чтобы другие выполняемые файлы могли получить к ним доступ. 

    Программные модули 

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

    Листинг 3.3, Пример исходного текста программного модуля 

    unit RTENCGDO; 
    interface 
      uses 
         Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, 
         CGRDFORM, Buttons, DBCtrls, StdCtrls, DBCGrids, ExtCtrls, Mask; 
      type 
        TfmRTENCGDO = class(TfmControlGridForm) 
          detTENANT_NUMBER: TDBText; 
          dedNAME: TDBEdit; 
          dedEMPLOYER: TDBEdit; 
          dedEMPLOYERADDRESS: TDBEdit; 
          dedEMPLOYERCITY: TDBEdit; 


    50 Часть I. Основы 


      dedEMPLOYERSTATE: TDBEdit; 
      dedEMPLOYERZIP: TDBEdit; 
      dedHOMEPHONE: TDBEdit; 
      dedWORKPHONE: TDBEdit; 
      dedICEPHONE: TDBEdit; 
      dedCOMMENTS: TDBEdit; 
      Name: TLabel; 
      Label2: TLabel ;
      Label3: TLabel ;
      Label4: TLabel ;
      Label5: TLabel ;
      Label6: TLabel ;
      Label7: TLabel ;
      Labels: TLabel ;
      Label9: TLabel ;
      Label11: TLabel ; 
      Label1: TLabel ;
    private 
      { Private declarations ) 
    public 
      ( Public declarations } 
    end; 

    var 
      fmRTENCGDO: TfmRTENCGDO ; 
      DefaultPetDeposit: Integer; 

    implementation 

    uses RENTDATA; 

      ($R *.DFM) 

    initialization 
      DefaultPetDeposit := 150; 
    end. 

    Раздел interface 

    Как видно из листинга 3.3, программный модуль состоит их трех разделов, 
обозначенных ключевыми словами interface, implementation и initialization. В 
интерфейсном разделе приводится информация о содержимом программного модуля, 
доступном для других модулей и программ. Такой информацией могут быть 
объявления функций и процедур, определения переменных, констант и типов. Если 
вы знакомы с принципами программирования на языке С, то узнаете в интерфейсном 
разделе функциональный эквивалент заголовочных файлов, используемых в С. 
Однако, в отличие от С, в языке Object Pascal для хранения такой информации не 
применяется отдельный файл, включаемый в файлы модулей, а используется 
интерфейсный раздел файла программного модуля. Сведения из интерфейсного 
раздела помещаются в заголовок откомпилированного программного модуля. Когда 
компилятор обнаруживает в операторе uses одного модуля ссылку на другой 
модуль, он ищет нужную информацию в заголовке бинарного файла 
откомпилированного модуля, а не в исходном тексте соответствующего 
программного модуля. 
    Такой подход позволяет использовать файлы откомпилированных модулей без 
каких-либо дополнительных заголовочных файлов. Более того, данная технология 
избавляет от необходимости перекомпиляции заголовочных файлов при каждой 
компиляции модуля, использующего такие файлы. (Предкомпиляция заголовочных 
файлов в некоторой степени также решает эту проблему, однако не все 
компиляторы с языка С обладают такой возможностью.) Безусловно, данный подход 
является более прогрессивным и удобным, чем использование заголовочных файлов, 
применяемое в языках С и C++. 

    Раздел implementation 

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

    Глава 3. Основные понятия 51 

ления в интерфейсный раздел этого модуля. Типичным случаем организации 
программного модуля является помещение объявления функции в разделе 
interface, а операторов этой функции — в разделе implementation. 

    Переменные экземпляров форм 

    Обратите внимание на переменную экземпляра формы, находящуюся в операторе 
объявления переменных интерфейсного раздела (см. листинг 3.3): 

    var 
      fmRTENCGDO: TfmRTENCGDO; 

    Эти операторы объявляют элемент, представленный идентификатором 
fmRTENCGDO, как переменную типа TfmRTENCGDO. Тип TfmRTENCGDO — это созданный с 
помощью конструктора форм Delphi класс, происходящий от класса TForm. 
Переменная fmRTENCGDO инициализируется оператором Application.CreateForm, о 
котором мы говорили выше. Так как эта переменная объявлена в интерфейсном 
разделе модуля, можно к ней обращаться и модифицировать ее значение из других 
модулей, в операторе uses которых указано имя данного модуля, а также из файла 
проекта. 

    Раздел initialization 

    Если вы хотите, чтобы при первой загрузке модуля выполнялись какие-то 
операции, поместите соответствующий код в раздел инициализации программного 
модуля. Все операторы, помещаемые в такие разделы модулей, выполняются при 
загрузке приложения в память. Порядок их выполнения определяется порядком 
следования модулей в операторе uses проекта. В листинге 3.3 раздел 
инициализации состоит из одной строки, находящейся между ключевыми словами 
initialization и end. 

    initialization 
      DefalutPetDeposit := 150; 
    end. 

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

    Раздел finalization 

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

    Формы 

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

    52 Часть I. Основы 

    Листинг 3.4. Текстовое представление простой формы 

    inherited fmDatabaseForin: TfitiDatabaseForm 

       Left = 75 
       Top = 124 
       Width = 554 
       Caption = 'fmDatabaseForm' 
       PixelsPerInch = 96 
       TextHeight = 13 
       inherited paTop: TPanel     
          Width =546 
      end 
      inherited paMiddle: TPanel     
        Width = 546 
      inherited paBottom: TPanel 
        Width =546 
       object paRight: TPanel 
           Left = 385 
           Top = 1 
           Width = 160 
           Height = 37 
          Align = alRight 
          BevelOuter = bvNone 
          TabOrder = 0 
         object bbOK: TBitBtn 
            Left = 4 
           Top = 8 
           Width = 75 
           Height = 25 
          TabOrder = 0 
          Kind = bkOK 
       end     
       object bbCancel: TBitBtn 
         Left = 82 
         Top = 8 
         Width = 75 
         Height = 25 
         TabOrder = 1 
         Kind = bkCancel 
      end 
    end     
    object bbPrintForm: TBitBtn 
       Left = 280 
       Top = 8 
       Width = 75 
       Height = 25 
       Caption s: 'Print Form' 
       TabOrder = 1 
       OnClick = bbPrintFormClick 
       Glyph. Dat.a = {     
          76010000424D7601000000000000760000002800000020000000100000000100 
           04000000000000010000130В0000130ВОООООООООООООООООО00000000000000 
           800000800000008080008000000080008000808000007F7F7FOOBFBFBFOOOOOO 
           FFOOOOFFOOOOOOFFFFOOFFOOOOOOFFOOFFOOFFFFOOOOFFFFFF00300000000000 
          00033FFFFFFFFFFFFFFF0888888888888880777777777777777F088888888888 
          8880777777777777777FOOOOOOOOOOOOOOOOFFFFFFFFFFFFFFFFOF8F8F8F8F8F 
          8F80777777777777777F08F8F8F8F8F8F9F0777777777777777FOF8F8F8F8F8F 
          8F807777777777777F7F0000000000000000777777777777777F3330FFFFFFFF 
          03333337F3FFFF3F7F333330FOOOOFOF03333337F77773737F333330FFFFFFFF 
          03333337F3FF3FFF7F333330FOOF000003333337F773777773333330FFFFOFFO 
         33333337F3FF7F3733333330F08FOF0333333337F7737F7333333330FFFF0033 
         33333337FFFF7733333333300000033333333337777773333333) 
    NumGlyphs = 2 
  end 
  object DBNavigatorl: TDBNavSearch 


    Глава 3. Основные понятия 

         Left = 8 
         Top = 8 
         Width = 253 
         Height = 25 
         TabOrder = 2 
       end 
     end 
  end 


    Модули данных 

    В Delphi используются формы специального вида — так называемые модули 
данных (data module). Для создания модуля данных нужно воспользоваться 
командой New Data Module, находящейся в подменю File главного меню Delphi. 
Применение модулей данных позволяет собрать все невизуальные компоненты 
приложения (чаще всего это компоненты для работы с базами данных) в одной 
форме. Создав модуль данных, вы обращаетесь к нему из других форм приложения и 
получаете, таким образом, доступ к компонентам для работы с базами данных. 
Кроме того, модули данных, как и обычные формы, можно поместить в хранилище 
объектов Delphi, а затем использовать их напрямую или в качестве прототипов 
других модулей данных. Помните, что в модули данных можно помещать только 
невизуальные компоненты. 

    Включаемые файлы 

    Компилятор Delphi, как и компиляторы других систем разработки, 
поддерживает использование включаемых файлов. Включаемые файлы (include files) 
— это текстовые файлы, содержащие информацию, которую вы хотели бы 
использовать совместно в нескольких модулях. Поскольку Delphi при обнаружении 
в тексте программы включаемых файлов перекомпилирует их, я рекомендую не 
злоупотреблять этими файлами, чтобы не снижать производительность. 
    Чаще всего включаемые файлы применяются для перечисления директив 
компилятора, используемых совместно несколькими модулями, а также для того, 
чтобы обеспечить автоматическую перекомпиляцию таких модулей путем внесения 
изменений в содержимое включаемого файла. Ниже приведен фрагмент такого файла. 
    
    {$В-, F-, G+, I-, К+, М-, Р+, Q-, R-, S+, Т-, V+, W-, X+} 
    {$IFNDEF DEBUG} 
      <$D-} 
    ($ELSE) 
      {$D+, L+, Y+) 
    {$ENDIF} 
    
    Основное назначение этого программного кода — облегчение настройки 
параметров режима отладки. Обратите внимание на строку {$IFNDEF DEBUG}. Она 
означает, что в том случае, если не определена директива компилятора с 
названием DEBUG, — три параметра режима отладки ($D, $L и $Y) должны быть 
отключены. (В следующей строке явно отключается только параметр $D, так как 
два остальных параметра при его отключении также автоматически отключаются.) 
Если же директива DEBUG определена, то все три параметра включаются. Создав 
такой файл, достаточно включить его во все исходные тексты программных модулей 
приложения, после чего для выбора того или иного режима компиляции достаточно 
будет использовать директиву DEBUG. Лично мне такой метод работы нравится 
больше, чем выключение и включение соответствующих флажков в диалоговом окне, 
открывающемся с помощью команды Project=> Options. 
    Для подключения созданного включаемого файла к исходному тексту модуля или 
программы используется директива компилятора $I, например: 

    {$I WINMAC32.INC} 

    На заметку 
    Условные директивы компилятора не распространяются на все модули, как 
можно было бы ожидать. Когда компилятор Delphi открывает файл нового 
программного модуля, он устанавливает значения директив компилятора равным 
значениям соответствующих параметров диалогового окна Project Options или 
значениям, указанным в командной строке запуска компилятора. 

    54 Часть I. Основы 


    Компоненты 

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

    Листинг 3.5. Исходный код компонента ТАггауТаblе, созданного автором книги 

    ( 
      Компонент АггауТаЫе. 
      Предназначен для создания интерфейса таблицы, подобного массиву. 
      Синтаксис для обращения к нужному полю: 
      Records[RecNum].Fields[FieldNum].AsType 
      Автор — Кен Хендерсон. 
      Copyright (с) 1995 by Ken Henderson. 
    } 
    unit АггауТаblе; 

    interface 

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

    type 
      ТАггауТаblе = class (TTable) 
      private 
          { Объявления скрытых элементов } 
          function GetRecords(RecNum: Longint): TDataSet; 
       protected 
          { Объявления элементов с ограниченным доступом } 
       public 
          ( Объявления общедоступных элементов } 
          property Records[RecNum: Longint]: TDataSet read GetRecords; 
       published 
          { Объявления тиражируемых элементов } 
      end; 

    procedure Register; 

    implementation 

    function TArrayTable.GetRecords(RecNum: Longint): TDataSet; 
    begin 
      First; 
      MoveBy(RecNum) ; 
      Result := Self; 
    end;

    procedure Register; 
    begin 
      RegisterComponents('Data Access', [TArrayTable]); 
    end; 

    end. 

    Данный компонент является подклассом стандартного компонента Table Delphi 
и отличается от последнего наличием одного общедоступного свойства Records. С 
помощью этого свойства можно обращаться к ячейкам таблицы как к элементам 
массива. Например, следующий оператор возвращает значение 

    Глава 3. Основные понятия 55 

ячейки, находящееся на пересечении третьего столбца и пятой строки 
таблицы  представленноё в видё строки (начальным значением свойства Records 
компонента АггауТаblе, как и свойства Fields компонента Table, является нуль): 

    TArrayTable1.Records[4].Fields[2].AsString; 

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

    На заметку 
    Хотя это не сразу понятно из исходного текста компонента ТАггауТаblе, но 
обращение к свойству Records изменяет положение указателя текущей записи. 
Элементы управления для работы с базами данных в Delphi устроены таким 
образом, что данный недостаток неизбежен. Хранение прежнего значения указателя 
не имеет смысла, так как свойство Fields компонента TTаblе всегда указывает на 
текущую запись. Одним из возможных решений этой проблемы является сохранение в 
специальной переменной номера текущей записи перед оператором обращения к 
свойству Records рассматриваемого компонента. Затем, используя эту переменную, 
можно будет возвратиться к сохраненному значению указателя текущей записи. 

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

    Резюме 

    В этой главе вы ознакомились с основными понятиями, используемыми при 
создании приложений в среде Delphi. Мы рассмотрели следующие элементы. 
    Q Проекты. Проект — это перечень файлов, составляющих приложение, 
созданное с помощью Delphi. 
    Q Библиотеки. Библиотека — это выполняемый файл в формате DLL, 
используемый в Windows для экспорта процедур в приложения. 
    О Программные модули. В Delphi программные модули, содержащие формы, 
являются основными строительными блоками, из которых состоит приложение. 
    Q Формы. Формы содержат элементы визуального интерфейса приложений, 
созданных с помощью Delphi. 
    Q Включаемые файлы. Включаемые файлы предназначены для совместного 
использования несколькими модулями одного и того же программного кода. 
    Q Компоненты. Компоненты — это элементы, из которых состоят формы. 

    Что дальше... 

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

    56 Часть I. Основы 
