Program — Ключевое слово Delphi


Содержание

Общая организация программы в Delphi

Структура проекта Delphi

Проект – это разрабатываемое на языке программирования приложение.

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

Проект Delphi представляет собой набор программных единиц – модулей, которые хранятся в отдельных файлах.

Примечание. В Delphi существуют файл проекта и файлы проекта. Это разные вещи. Файл проекта – это главный файл проекта (головная программа), имеющий расширение .Dpr, файлы проекта – это набор всех файлов приложения.

Файл с расширением .Dpr (главный файл проекта) содержит основную информацию о проекте. По умолчанию этот файл называется Project1.dpr.

Файл с расширением .Pas – это файл программного модуля. В нем хранится текст программы на языке Object Pascal. Для каждой формы, входящей в состав проекта, создается отдельный программный модуль. По умолчанию эти файлы называются Unit1.pas,. Unit2.pas и т.д.

Файл с расширением .Dfm содержит информацию о внешнем виде формы. Этих файлов столько, сколько форм в проекте. Информация в них закодирована.

Файл с расширением .Res – это файл ресурсов проекта, в котором хранится информация о картинках, курсорах, иконках и т.п.

Файл с расширением .Exe– исполняемый файл приложения.

Файлы с расширениями .

Pa – файлы со старыми версиями приложения.

У файлов с расширениями .Pas, .Dfm, .

Pa всегда одинаковое имя (по умолчанию Unit1).

У файлов с расширениями .Dpr, .Exe, .Res – также одинаковое имя (по умолчанию Project1).

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

· Копирование файлов проекта на дискету или в другую папку выполняется только с помощью файлового менеджера Windows (например, проводника). В среде Delphi это делать не следует.

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

Все объекты компонентов размещаются в объектах – формах. Форма обеспечивает создание графического интерфейса разрабатываемого приложения и представляет собой окно, на котором размещаются необходимые компоненты. Для каждой формы, проектируемой в приложении, Delphi автоматически создает отдельный модуль, в который пользователь может ввести собственный код, создавая обработчики различных событий. Именно в модулях и осуществляется программирование задачи.

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

где Объект — имя настраиваемого объекта;

Свойство — характеристика, которую нужно изменить;

Значение — новая установка свойства;

Метод — команда, которая используется для изменения объекта;

Параметр — аргумент, используемый методом.

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

2.3. Структура главного файла проекта *.dpr

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

program Project1; Программа начинается с ключевого слова program, после которого указывается имя программы. Оно совпадает с именем файла, в котором сохраняется проект. Это же имя присваивается исполняемому файлу приложения. По умолчанию используется имя Project1.
uses Forms, Unit1 in ‘Unit1.pas’ ; В разделе uses перечисляются все модули, загружаемые программой. Первый модуль Forms является системным (в нем содержатся характеристики форм приложения), а следующие – модулями разработанных пользователем форм. Данный проект состоит из одной формы с именем Form1, которая содержится в модуле Unit1. После ключевого слова in указывается имя файла, в котором содержится модуль Unit1.
Эта строка представляет собой директиву компилятора, которая связывает с исполняемым модулем файлы ресурсов Windows. Символ * означает, что имя файла ресурса совпадает с именем файла проекта.
begin Application.Initialize; Application.CreateForm (TForm1, Form1); Application.Run; end. Объект Application создается автоматически. Инициализация приложения начинается с вызова метода Initialize. Метод CreateForm загружает в оперативную память объекты главной формы приложения (остальные формы могут загружаться динамически в процессе работы приложения). Метод Run начинает выполнять приложение.

2.4. Структура модуля приложения Delphi *.pas

Текст программы, описывающей форму, хранится в модуле с расширением .Pas, его название должно совпадать с именем файла, по умолчанию Unit1.pas. Модуль состоит из разделов: интерфейса и реализации.

Структура модуля приложения Delphi:

Unit Unitl; Название модуля (это название используется в предложении Uses при подключении модуля к приложению)
Interface … Раздел интерфейса
Implementation … Раздел реализации (исполняемая часть)

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

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

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

Начинается раздел директивой <$R *.dfm>, указывающей файл, описывающий каждый компонент формы, включая значения всех свойств.

Замечание. Просмотреть файл *.dfm можно с помощью команды
View as Text контекстного меню в конструкторе форм.

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

Не нашли то, что искали? Воспользуйтесь поиском:

Лучшие изречения: Для студентов недели бывают четные, нечетные и зачетные. 9438 — | 7438 — или читать все.

Тема: [Цикл уроков программиста] 3. С++ Vs. Delphi

Опции темы
Поиск по теме

[Цикл уроков программиста] 3. С++ Vs. Delphi

Знающие люди советуют новичкам учить Pascal или Delphi (ранее известный под кодовым именем Object Pascal), а не C++. Основной тезис в пользу выбора Delphi звучит так:

C++ сложнее чем Delphi.
или
С++ сложнее чем Pascal.

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

После того как наивный новичок поддался на их уговоры, культисты Delphi совращают его всякими непотребствами: визуальным программированием и библиотеками VCL и CLX. Судьба программиста, выбравшего тёмную сторону силы, ужасна: в скором времени ему предстоит написать текстовый редактор, используя компоненты TMemo, TPopupMenu, TMainMenu. В процессе работы над редактором наступают необратимые нарушения в психике. Но это только начало! Выбравшему Delphi предстоит сделать невозможное для пользователя C++ — написать браузер, используя компонент TWebBrowser. Теперь новоявленный разработчик превращается в пропагандистскую машину, готовую уничтожить любого, кто заикнётся, что C++ не сложнее Паскаля.

Ну а теперь серьёзно:

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

Цель данной статьи посредством простых примеров опровергнуть совершенно лживое утверждение о сложности C++ по сравнению с Паскалем.

Создание Windows программы в Delphi за пять минут

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

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

Delphi и Object pascal

На данный момент Delphi и Object Pascal — это одно и то же. Раньше было разделение: Delphi — среда разработки (такая же как Visual C++), а Object Pascal — язык программирования (как C++).

И ещё одно: когда говорят Delphi, имеют ввиду Pascal. И наоборот. В настоящее время это два неразрывно связанных понятия.

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

Общая структура программ на Delphi и С++

Программы на любом языке состоят из операторов. Если совсем просто, оператор — это команда процессору выполнить какое-нибудь действие.

И в C++, и в Паскале (а соответственно и в Delphi) конец оператора обозначается точкой с запятой.

В обоих языках для комментариев используются символы // — две косых черты. Комментарий — это текст в программе, который не будет выполняться процессором. Теперь посмотрим на общую структуру программы на С++ и Delphi:

// программа на Delphi
program someProgram ;
// разделы

begin
// код программы — операторы
end .

Программа на C++ начинается с глобальной области видимости. Далее идёт строка int main(). После этой строки нужно поставить две фигурные скобки (открывающую и закрывающую). Код программы должен находиться внутри фигурных скобок. Обязательно нужно написать как минимум один оператор — return 0;.

Программа на Delphi начинается с ключевого слова program, после которого пишется имя программы. Далее идёт список разделов. Код программы должен находиться между ключевыми словами begin и end.

Тут самое важное: в C++ код находится между фигурных скобок, а в Pascal — между словами begin и end.
Переменные в Delphi и C++

Переменные предназначены для хранения и использования данных во время выполнения программы.

И С++, и Delphi — строго типизированные языки. Это значит, что в этих языках программирования для хранения разных данных используются разные типы переменных. Например, для хранения целого числа используется переменная одного типа, для хранения вещественного — другого.

Для целых чисел в C++ используется обозначение int, в Delphi — integer. Дробные числа в C++ — float, в Delphi — real.

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

int a ; // объявление переменной целого типа

int main ()
<
a = 2 ;
float b ; // объявление переменной вещественного типа
b = 0.5 ;
return 0 ;
>

Для создания переменной в C++ нужно написать тип и имя переменной.

В Delphi переменные обязательно должны объявляться в разделе var:

program someProgram ;
var
a : integer ; // объявление переменной целого типа
b : real ; // объявление переменной вещественного типа

Для создания переменной в Delphi необходимо, чтобы её объявление находилось в разделе var. Создание переменной в Delphi выглядит так: имя переменной, двоеточие, имя типа.

Для присваивания в C++ используется знак =, в Delphi — :=. Операция присваивания берёт то, что находится справа от знака и помещает это в переменную, находящуюся слева от знака присваивания. В обоих наших программах, после выполнения всех операторов, переменная a будет хранить значение 2, а переменная b — 0,5.

Управляющие структуры: ветвления и циклы на Delphi и C++

Управляющие структуры — самая важная часть любого языка. Они изучаются практически в самом начале знакомства с языком.

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

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

Следование . Данная управляющая структура говорит, что программа будет выполняться последовательно:

Глядя на этот код, можно с уверенностью сказать, что сначала переменной a будет присвоено значение 3, затем переменной b присвоится значение 1 и в конце переменной a будет присвоено значение 4. Это и называется последовательным выполнением. Т.е. процессор выполняет команды вашей программы сверху вниз одну за другой.

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

Если переменная a больше нуля, то b присваивается 1, а если переменная a меньше или равна нулю, то b будет равна нулю.

Как видим, отличия небольшие — использование ключевого слова then в Delphi и обязательные скобочки вокруг условия в C++. Существуют и другие формы ветвлений, но мы их рассматривать не будем.

Повтор . Для повторов кода используются циклы. Рассмотрим два вида — циклы for и while.

Циклы позволяют выполнить группу операторов несколько раз. В данном примере, после окончания цикла, переменная b будет принимать значение 10.

На C++ цикл for немного сложнее чем на Delphi. В цикле for на C++ нужно указать три параметра: инициализацию счётчика, условие выхода из цикла, изменение счётчика. На Delphi нужно указать только начальное и конечное значение.

Цикл while на C++ и Delphi почти одинаковый. На Delphi нет скобочек вокруг условия, и присутствует слово do.

Массивы в Delphi и C++

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

// массивы в Delphi
program someProgram ;
Var
a : array [ 1..10 ] of integer ; // объявление массива

begin
a [ 1 ] := 5 ; // использование массива
end ;

Массивы в Delphi объявляются в разделе var. Самое важное отличие: на Delphi элементы массива можно нумеровать с единицы, а на C++ — только с нуля. В остальном, массивы используются одинаково.

Функции в Delphi и C++

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

// функции в Delphi
program someProgram ;
var
b : real ;
c : real ;

function someF ( a : real ): real ; //определение функции
begin
someF := a ;
end ;

begin
c := 5 ;
b := someF ( c );
end .

// функции в c++
float b ;
float c ;

float someF ( float a ) // определение функции
<
return a ;
>

int main ()
<
c = 5 ;
b = someF ( c );
return 0 ;
>

Перед названием функции в Delphi указывается ключевое слово function. После круглых скобочек стоит двоеточие и имя типа возвращаемого значения. В C++ имя типа возвращаемого значения стоит перед именем функции.

Важное отличие: в C++ внутри определения функции используется оператор return, в то время как в Delphi для возвращения значения из функции используется имя этой функции.

На закуску: О простоте Delphi

Вам могло показаться, что в начале данной статьи я очерняю (или даже оскорбляю) поклонников Delphi. Уверяю вас это не так. Большнинство из них реально зомбированы!

Когда я начал писать статью, я хотел дать слово другой стороне. Ну, чтобы поклонники Delphi могли показать действительно простые по сравнению с C++ примеры кода. Для этого, я на одном из форумов попросил привести примеры кода на Delphi, когда в очередной раз была затронута тема C++ vs. Delphi. Мой собеседник не разочаровал:

type
TLogger = class
protected
class var
FLogger : TLogger ;
public
FText : TStringList ;
constructor Create ;
destructor Destroy ; override ;
class operator Implicit ( Line : String ) : TLogger ;

strict private
class var
class constructor Create ;
end ;

constructor TLogger . Create ;
begin
inherited ;

FText := TStringList . Create ;
end ;

destructor TLogger . Destroy ;
begin
FText . Free ;

class operator TLogger . Implicit ( Line : String ) : TLogger ;
begin
FLogger . FText . Add ( Line );

Result := FLogger ;
end ;

class constructor TLogger . Create ;
begin
FLogger := TLogger . Create ;
end ;

Я возликовал через пять минут, которые потребовались, чтобы разобраться в коде и оценить его гениальность (и конечно же, простоту). О таком подарке я даже и не мечтал!

Код в примере выше перегружает оператор присваивания. Вот как этот код будет выглядеть на C++:

Считаем: 9 строк на C++ против тридцати трёх на Delphi. А что, на C++ действительно сложнее получилось: видите там фигурные скобки какие-то дурацкие — ничего не разобрать! При этом код на C++ работает всегда, а код на Delphi будет работать только при выполнении определённых условий. При этом, при написании кода на Delphi использовались. ээммм. так сказать, не слишком известные особенности языка.

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

Вот такой вот коленкор.
Какой язык выбрать: C++ или Object Pascal, Delphi?

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

На начальном этапе разницу в сложности вы просто не заметите! Собственно, её и нет. Нужно быть психбольным, чтобы утверждать, что один дополнительный параметр в цикле for делает изучение C++ в разы сложнее.

Тут важный момент! Нужен хороший учебник. Я вот уже писал про книгу «Язык программирования C++». Если вы хотите забросить изучение C++ через пару часов после начала, лучшей книги вы не найдёте.

Кто говорит, что C++ сложнее Delphi, тот или не знает о чём он говорит, или лжёт. Можно с полной уверенностью утверждать, что сложность у них (как минимум) одинаковая. Думаю, мне удалось это показать на примитивных примерах.

В статье не были затронуты ещё две важные темы, с которыми придётся столкнуться новичкам: указатели и классы. Но там такая же ситуация — отличия минимальны.


Delphi for DotNet – первый взгляд

Delphi , Программа и Интерфейс , Dot Net

Автор: Михаил Полюдов
The RSDN Group
Источник: RSDN Magazine #2

Содержание.
Комплект поставки.

Такое событие, как выпуск новой, седьмой, версии Delphi, не прошло незамеченным для большинства разработчиков. Примечательно, что в поставку этого программного продукта включен дистрибутив Delphi .NET Developer Preview. Вот об этом новом продукте (вернее – его «примерочной» версии) и пойдет речь в данной статье.

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

В поставку входят:

  • два компилятора командной строки dccil.exe и dccasp.exe. Реально это один и тотже исполняемый файл переименованный и скопированный в другую директорию.
  • модули импорта стандартных сборок CLR.
  • небольшое количество документации в формате HTML.
  • лицензия и рекомендации по распространению. В рекомендациях по распространению написано только то, что оно запрещено :).

К счастью, на Borland Developer Network (http://bdn.borland.com) имеется открытое дополнение, которое позволяет использовать компилятор Delphi .NET из IDE Delphi 7 . Это дает возможность работать с привычным интерфейсом и подсветкой синтаксиса (Правда, не весь синтаксис подсветится правильно, а уж о работе Code Completion и речи быть не может. Почему — будет понятно позже).

Основные цели Borland при разработке данного продукта.

Можно предположить, что при разработке прототипа Borland стремился:

  • Создать CLR-совместимый компилятор языка Object Pascal.
  • Обеспечить возможность использования собственных библиотек в новом окружении с минимально необходимыми изменениями со стороны конечного разработчика :).
  • Добиться (хотя бы ограниченной) совместимости нового компилятора с unmanaged-версиями Delphi на уровне исходных текстов. Некоторые ограничения неизбежны в силу наличия таковых ограничений в самой платформе .NET.

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

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

Некоторую проблему для Borland представляет наличие встроенной в платформу .Net библиотеки Windows.Forms. Эта библиотека содержит функциональность, аналогичную достаточно большому сегменту библиотеки VCL, но не является ее полным аналогом. Borland должен обеспечить возможность компиляции старого кода с использованием Windows.Forms. Сейчас еще трудно оценить, насколько выполнимы обещания Borland. Но пока что все выглядит довольно оптимистично.

Добиться совместимости с VCL и при этом не сдублировать код Windows.Forms – крайне сложная задача. Однако именно ее и пытается решить Borland. В качестве решения проблемы Borland планирует использовать новую (для него) возможность – helper-классы, речь о которых пойдет ниже.

Другая проблема возникает там, где используется так называемый небезопасный код. Такие участки кода придется переписывать при переходе под новую версию компилятора. В принципе, MSIL может выдержать всё, что угодно, так как по сути является платформно-независимым ассемблером. Но Microsoft ввел такое понятие, как «безопасный» код. Во многих случаях применение небезопасного кода не допускается средой исполнения. В основном это связано с защитой. Так, при скачивании кода из Интернет происходит его верификация, и, если код содержит небезопасные фрагменты, или использует небезопасные с точки зрения системы защиты вызовы методов, он просто не допускается к исполнению. Borland, по крайней мере пока, декларирует, что Delphi.Net будет компилировать исключительно безопасный код. В компилятор Delphi 7 уже встроено предупреждение о небезопасных (unsafe) участках кода.

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

Вот так писать в Delphi будет нельзя:

Для работы с теми же массивами в .Net Framework предназначены специальные методы, позволяющие сериализовать содержимое массива как единый объект. Необходимость в unsafe-коде практически исчезает, хотя иногда это приводит к снижению эффективности кода.

Что нового в Delphi .NET Что такое .NET

О платформе .NET, а точнее — о CLR (Common Language Runtime) есть очень хорошая статья Владислава Чистякова, опубликованная на компакт-диске к предыдущему номеру нашего журнала. В других статьях на www.rsdn.ru можно найти материалы по другим аспектам .Net.

В этой статье я не буду подробно рассматривать платформу .NET. Здесь будет рассмотрено несколько вопросов, интересующих Delphi -программистов, рассматривающих вопрос о переходе на новую платформу.

Изменения языка в Delphi.NET

Как уже говорилось, главная задача Borland – это поддержка платформы .Net, и, одновременно, сохранение совместимости с уже существующим кодом, написанным в Delphi.

Unsafe code (небезопасный код).

Borland добавил в Delphi 7 три новых предупреждения о небезопасных типах, небезопасном коде и небезопасных преобразованиях типов.

Типы данных, не поддерживаемые в Delphi.Net:

  • PChar;
  • нетипизированные указатели;
  • нетипизированные var и out-параметры;
  • file of ;
  • real48;
  • вариантные записи (записи, содержащие перекрывающиеся поля).

Небезопасный код:

  • переменные по абсолютным адресам;
  • процедуры Addr(), Ptr(), Hi(), Lo(), Swap();
  • процедуры BlockRead(), и BlockWrite();
  • функция Fail();
  • процедуры GetMem(), FreeMem(), ReallocMem().

Небезопасные преобразования типов:

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

При нарушении этих ограничений компилятор Delphi 7 с настройками по умолчанию выдаст предупреждение, а компилятор Delphi.NET – ошибку.

Кроме вышеперечисленных небезопасных конструкций, Delphi запрещает использовать встроенный ассемблер (оператор asm), конструкцию ExitProc и некоторые из конструкций для поддержки COM/OLE/ActiveX технологий:

В CLR имеются идентификаторы (типы, классы), которые совпадают по написанию с ключевыми словами Delphi, например: type, object. Для работы с такими идентификаторами нужно использовать полное именование, т.е. System.object, System.type и т.д. Borland декларирует в своей документации, что вместо полного именования можно использовать имя с префиксом & (амперсанд). Есть только одно «но»: данная версия компилятора ругается на неправильный символ в исходных текстах :( .

Расширения и элементы, находящиеся в разработке.

Следующий список перечисляет конструкции языка, разработка некоторых из них еще не закончена по тем или иным причинам:

  • «запечатаные» (sealed) классы. Определено новое ключевое слово Delphi, «sealed». Атрибут «sealed» применяется к классу для указания того, что класс не может быть расширен где-либо в CLR (ни на Delphi, ни на любом другом языке программирования);
  • завершенные (final) методы. Еще одно новое ключевое слово «final». Данный атрибут применяется к методам для указания того, что они не могут быть перекрыты в потомках;
  • UTF-8 Unicode символы в исходном коде;
  • вложенные типы (т.е. описание типа внутри другого);
  • невиртуальные методы в записях;
  • статические (class, static) данные класса;
  • статические (class, static) свойства класса;
  • статические (class, static) методы;
  • виртуальные методы в helper-классах;
  • широковещательные (multicast) события (event). На текущий момент планируется использовать оператор ‘ := ‘ для замены последнего присвоенного события, не влияя на обработчики событий, назначенные из управляемого кода других средств разработки. Присвоение значения nil будет вызывать удаление последнего присвоенного обработчика событий;
  • Variant будет поддерживаться как TObject, а не как TVarData (реализация внутренних механизмов работы с Variant возлагается на CLR);
  • Автоматическое упаковка (boxing) value-типов (простых типов, таких, как Integer, и записей) в CLR объекты.

Пространства имен (Namespaces).

В Delphi .NET юнит остается основным контейнером для типов. CLR предоставляет еще один слой организации – пространство имен (namespace). В .Net Framework пространство имен – это концептуально контейнер типов. В Delphi for .Net пространство имен — это контейнер юнитов Delphi. Появление пространств имен дает Delphi возможность использовать и расширять классы .Net.

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

Например, класс MyClass из пространства имен MyNameSpace отличается от класса MyClass из YourNamespace. Во время исполнения CLR всегда обращается к классам и типам по их полным именам: имя сборки, за которым следует название пространства имен, содержащего тип.

В Delphi.NET файл проекта (программы, библиотеки или package’а) неявно вводит собственное пространство имен, называемое пространством имен проекта по умолчанию. Юнит может как входить в это пространство имен, так и явно объявить себя членом другого пространства имен. В любом случае юнит объявляет свою принадлежность к тому или иному пространству имен в выражении Unit. Например, вот так явно объявляется пространство имен:

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

Во-вторых, заметьте, что точки выражают концепцию вкладывания одних пространств имен в другие. Вышеприведенный пример говорит, что юнит MyUnit – это член пространства имен MyWidgets, которое, в свою очередь, содержится в пространстве имен MyCompany.

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

  1. Пространство имен данного юнита (если таковое существует).
  2. Пространство имен проекта по умолчанию.
  3. Пространство имен, указанное в выражении проекта Namespaces.
  4. Пространства имен, указанные в настройках компилятора

Приложение Delphi.NET

Попробуем написать три программы (консольное, простейшее оконное и чуть более сложное оконное приложение), пользуясь примерами и описаниями из документации.

Программа №1. “Hello .NET!”.

Данная программа – традиционный пример, используемый со времен Кернигана и Ричи. Эта программа будет всего лишь выводить на консоль строку «Hello, Delphi.NET!».

Итак, приступаем к созданию первого проекта на Delphi .NET.

ПРИМЕЧАНИЕ

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

Итак, создаем новый проект консольного приложения (File-New-Other-Console Application), сохраняем его как HelloDelphiNet.dpr.

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

либо выбрав пункт меню Delphi с установленным .NET расширением Delphi for .NET->Compile (или Build).

После компиляции запускаем готовый EXE-файл из командной строки (иначе мы просто не увидим результатов его работы) и видим следующее:

Что такое программирование в Windows без использования окон? Ну, вообще-то, это вполне нормально, есть достаточно много разнообразных программ, не использующих окон. Но Delphi не была бы Delphi без своих GUI-возможностей.

ПРИМЕЧАНИЕ

Не стоит удивляться тому, что в следующих примерах все элементы управления и формы создаются в коде, а не через модификацию/загрузку ресурсов. Это является обычным поведением для .NET-ориентированных языков. Дело в том, что одной из новинок, появившихся в .NET Framework, стала возможность сериализации в код. Тот же дизайнер форм Visual Studio сохраняет состояние формы и элементов управления в код программы. Это позволяет ускорить загрузку формы, а также вручную модифицировать код, сгенерированный дизайнером форм. Delphi поддерживает другую концепцию – сериализацию в собственный формат. Пока не ясно, как будут сериализоваться формы в Delphi.NET. Ясно одно – создать CodeDOM-провайдер, позволяющий использовать Delphi внутри VS.NET, будет несложно.

Программа №2. Нам нужны окна.

Borland пока не включил в Delphi.NET свою библиотеку VCL (но планирует сделать это, что явственно следует из документации). Основных причин, пожалуй, две:

  • сжатые сроки выпуска компилятора .NET, при продолжении развития основной линейки Delphi;
  • сложность реализации совместимости между VCL и Windows Forms.

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

Проблема №1. Множественные (multicast) обработчики событий.

В .Net все события компонентов множественные. Что это значит?

Проиллюстрирую примером на псевдокоде (псевдокод потому, что сама концепция есть не только в C# или там VB, а в CLR вообще):

Есть объект кнопка .

Прописываем в ее событие Нажато первый обработчик:

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

В обычной Delphi вторая строка кода заменит первый обработчик вторым, а в CLR должна добавить второй обработчик в очередь за первым (правда, в Borland еще не до конца решили, так это будет реализовано или не так, но об этом уже писалось выше).

в C# данная концепция реализована так:

Этот код, требует некоторых пояснений. Итак: EventHandler – это так называемый делегат – специальный класс из сборки System, позволяющий ссылаться на метод некоторого класса. У данного класса есть (если верить MSDN) следующие конструкторы:

Второй формат недоступен из C#, а первый – из Delphi. Самое странное, что в Delphi можно и нужно передавать не метод, а обычную процедуру, причем в качестве объекта может передаваться значение nil .

Проблема №2. Совместимость CLR и VCL.

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

Для того, чтобы создавать эффективные и небольшие приложения для CLR, нужно, чтобы VCL максимально использовала CLR. Если не реализовать VCL-обертку для CLR, код, который уже существует для VCL, под CLR придется переделывать очень долго. Borland придумал очень интересный выход: для каждого класса компонента CLR создается так называемый helper-класс, который расширяет функциональность класса CLR.

Детали этой технологии в Borland до конца еще не разработали, а вся информация почерпнута все из той же документации к Delphi.NET.

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

Обычно перед helper-классом идет объявление типа:

А за ним уже собственно объявление класса

Теперь существующий Delphi-код, ожидающий наличия у типа TMyClass функции ExistingDelphiFunc, будет работать как ни в чем не бывало.

Хорошим примером может служить класс System.Object, являющийся предком для всех .NET классов. В Delphi ему соответствует класс TObject. В Delphi for .Net TObject не наследуется от System.Object. Вместо этого он объявлен helper-классом для System.Object. Это позволяет использовать такие отсутствующие в System.Object методы, как ClassName и ClassType. Компилятор, не найдя реализаций Class-Name и ClassType в классе System.Object, обратится к helper-классу и возьмет их оттуда. Таким образом, helper-классы позволяют использовать в .Net возможности, уже реализованные в VCL.

Итак, проблемы обрисованы — попробуем написать код

Первый пример — просто окно с надписью.

Создаем новый проект Delphi .NET, TestForm1.dpr. Вот его начальный код:

Теперь заявим наше намерение использовать сборку System.Windows.Forms (В данной сборке содержатся стандартные элементы управления):

Теперь объявим глобальную переменную – форму:

В коде создадим форму.

Компилируем и запускаем.

На экране мы видим простую формочку без заголовка.

Попробуем добавить заголовок и переместить форму на центр экрана:

Получилось! Пора переходить к более сложным вещам, например к добавлению неких компонентов на форму.

Полный исходный текст TestForm1.dpr:

Новый проект назовем TestForm2.dpr, за основу берем TestForm1.dpr.

Для начала описываем новый класс:

Изменяем объявление переменной и конструирование формы:

Теперь создадим конструктор:

ПРЕДУПРЕЖДЕНИЕ

Внимание! ОБЯЗАТЕЛЬНО нужно выполнять вызов inherited конструктора.

Компилируем и запускаем — все осталось как и было, то есть все работает, но форма уже нашего класса.

Пишем тело конструктора:

Запускаем – все в порядке. Но пустая форма нам неинтересна – попробуем создать на ней кнопку:

Итак, у нас есть кнопка с надписью «закрыть» в левом верхнем углу формы, но сделать с ее помощью ничего пока нельзя. Пора начинать решать первую проблему Borland – обработчики событий. Пока что подключение и использование обработчиков событий в Delphi.NET до конца не реализовано. Поэтому приходится прибегать к некоторым ухищрениям, а именно – использовать в качестве обработчика событий процедуру, не являющуюся членом класса формы.

Из MSDN узнаем, что спецификация обработчика должна быть такой:

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

Компилируем, запускаем – работает. Единственное НО — использование глобальной переменной. Но эту ошибку, похоже, получится исправить только в следующей (нормальной?) версии компилятора.

  • компилятор есть, поддерживает как минимум часть стандартных сборок .NET Framework;
  • имеется, в принципе, среда написания кода, компиляции (с позиционированием ошибок) и запуска отладчика (с перекомпиляцией в DEBUG);
  • существует возможность писать как консольные, так и оконные приложения;
  • нет пока что портированной библиотеки VCL;
  • есть некоторые несоответствия между прилагаемой документацией и компилятором.

Таким образом, вполне нормально для Developer Preview, но не достаточно для качественной среды разработки от Borland. Ждем следующих версий.

Статья Delphi for DotNet – первый взгляд раздела Программа и Интерфейс Dot Net может быть полезна для разработчиков на Delphi и FreePascal.

Комментарии и вопросы

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

Блог GunSmoker-а

. when altering one’s mind becomes as easy as programming a computer, what does it mean to be human.

17 июня 2010 г.

Локализация проектов Delphi — родной способ (ITE — Integrated Translation Environment)

Как ни странно, в интернете полно рассказов про сторонние приложения для локализации ваших проектов, есть сравнительные обзоры разных утилит, но нет практически ничего про родной механизм Delphi для локализации. Более того, когда на форумах кто-то спрашивает, как ему лучше добавить в программу поддержку нескольких языков, ему советуют что угодно, но только не родной механизм Delphi. Видимо, второе является следствием из первого. Хотя ITE был в Delphi. аж с Delphi 5. Ещё один пример проблемы Copy&Paste? Когда решение из лохматых середины 90-х кочует аж до 2010-го? Кто знает.

В общем, эта статья призвана восполнить этот пробел (да, во многом это перевод справки, но далеко не всё).

Примечание: ITE работает для Win32 и Win64, но не для FireMonkey-приложений.

Обзор способов локализации

Локализация в Windows

В Windows каждый исполняемый модуль может содержать ресурсы — грубо говоря, это данные, вынесенные в отдельный блок внутри PE-файла. Бывают они разных типов, среди которых нас будут интересовать таблицы строк. Собственно, это ровно и есть то, что можно предположить по названию: таблица строк, т.е. — массив из строк. Сами строки идентифицируются по численному идентификатору (ID).

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


Сама возможность локализации заключается в том, что одна и та же строка в таблице может присутствовать в нескольких экземплярах, идентифицируемых по LangID — идентификатору языка. Т.е. конкретная строка идентифицируется с помощью 2-х параметров: ID строки и ID языка.

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

В действительности, это далеко не самый удобный способ, поскольку для перевода на доп. язык, надо модифицировать сам исполняемый модуль, язык нельзя добавить или удалить как «плагин». Сама ОС не слишком-то использует этот способ, тем не менее, он есть. В основном, как памятник философии старых времён: «но что, если это кому-нибудь нужно»?

Локализация в Delphi

В Delphi используется модификация базового механизма ОС. Заключается она в следующем. Мы по-прежнему используем ресурсы для хранения данных для локализации. Но в этот раз каждый исполняемый модуль содержит только строки для языка по умолчанию. Все прочие языки выносятся в отдельные модули — DLL, которые не содержат исполняемого кода, а содержат только ресурсы (так называемая ресурсная DLL или ресурсный модуль). Создаётся по одной DLL на каждый язык, каждая DLL содержит локализируемые данные программы, переведённые на соответствующий язык. Когда программа обращается к строке в таблице строк, берётся вариант строки из DLL, соответствующей текущему языку, а не из базового модуля.

В том или ином варианте эта же техника применяется и другими программами (написанными не на Delphi), в том числе и самой ОС (например, MUI). В действительности, это весьма (если не самый) распространённый способ.

В WinAPI нет функций, реализующих такую схему (по той простой причине, что вся «схема» заключается в указании одного параметра функции загрузки строки — модуля), поэтому Delphi использует свою реализацию. За счёт «магии компилятора», обращение к строке в ресурсах приводит к вызову функции, выбирающей ресурсную DLL и загружающей строку из неё. Для подробностей работы этого механизма — см. функции LoadResString и FindResourceHInstance в System.pas.

Замечу, что этот механизм всё ещё не исключает совмещения с предыдущим. Поскольку таблица строк всё ещё может содержать несколько вариантов строк в разных языках. Например, базовый модуль может включать в себя русский и английский, а все остальные языки — быть реализованными через ресурсные DLL. К сожалению, этот последний вариант не поддерживается Delphi. Модуль с несколькими языками вам придётся собирать руками (что, впрочем, не так сложно). Как крайний вариант — вы можете включить все языки в один исполняемый модуль. Это если вы не хотите дополнительных файлов.

Другие средства

Другие средства используют самые разнообразные способы. Но достаточно редко при этом используются ресурсы. Чаще всего локализированные данные оформляются отдельным текстовым файлом (ini, XML и custom-форматы).

Наиболее популярные сторонние решения:

  • dxGetText — адаптация GNU GetText для Delphi.
  • TJvTranslator из JVCL.
  • TsiLang — платный, но зато и самый мощный.

Плюсы/минусы каждого подхода смотрите самостоятельно. Лично мне нравится ITE (иначе писал бы я эту статью).

Локализация приложений с использованием Translation Manager

Утилиты для переводов

Delphi включает в себя набор утилит для локализации приложений (Translation Tools). Они доступны как для Delphi, так и для C++ Builder-а и работают для проектов любых типов.

Утилиты представлены в двух вариантах:

    Встроенный Translation Manager (Integrated Translation ManagerITM) — является частью IDE. Он помогает вам локализовать ваши проекты. ITM может создавать локализированные версии проектов для разных языков. Состоит он из таких частей:
  • Resource DLL Wizard (мастер создания ресурсных DLL) — создаёт проекты ресурсных DLL для выбранных вами языков. Вызывается через Project > Languages > Add.
  • Translation Editor — показывает табличку ресурсов. В каждой колонке показан оригинал, перевод, комментарий и т.п. Именно в нём вы делаете перевод своей программы. Вызывается через View > Translation Manager > Translation Editor или просто щелчком по файлу с ресурсами в менеджере проектов.
  • Translation Repository — предоставляет центральное хранилище для переводов. Попросту говоря, словарик. Это хранилище общее для всех проектов. Вы можете брать оттуда готовый перевод при локализации проекта или занести свой перевод в хранилище, когда вы закончили локализацию проекта. Вызывается по View > Translation Manager > Translation Repository.
  • Translation Tools Options — настройки утилит локализации. Вызывается по Tools > Options > Translation Tools Options.
  • Внешний Translation Manager (External Translation ManagerETM) — это автономная программа, которая может быть запущена на любой машине, даже без Delphi. Вы можете использовать её для локализации своих проектов без IDE. У ETM практически такая же функциональность, как и у Translation Editor, но с несколькими дополнительными менюшками, обусловленными автономной природой. ETM не может создавать новые проекты, но может импортировать существующие проекты. Вы можете дать ETM переводчикам, чтобы они могли делать переводы вашей программы.

Подготовка проекта

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

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

Если вы так делаете — вам повезло. Нет — пора бы начинать делать :)

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

Все строковые данные в своём коде вы должны оформить в виде констант. Если строка должна локализироваться — помещайте её в секцию resourcestring. Если нет — пихайте в const. Например:

Правило стиля: если вы используете resourcestring, то идентификатор обычно начинается с «rs» или «S». Для строк в const такого правила нет, но префикс «S» выглядит достаточно удобно. Вы можете захотеть различать типы строк в коде (rs/S) или использовать всегда одинаковое наименование (S/S) — ваш выбор.

Рассматривайте строки в ресурсах как обычные константы. Вы можете использовать в тексте идентификатор строки и компилятор сам позаботится о загрузке этой строки из модуля ресурсов. Вам ничего не нужно для этого делать. Более того, вам также ничего не надо делать для получения локализованной версии строки. Никаких вызовов типа GetTranslatedString(SResult). Используйте константу напрямую, а магия компилятора сделает остальное — загрузит нужный язык и подставит перевод. Достаточно просто.

Блоки resourcestring обычно располагаются в модуле сразу после implementation или же их выносят в отдельный модуль типа StrConsts.pas. Поступайте как вам угодно.

Оформив код таким образом, вбейте значения для языка по умолчанию во все строковые константы, а также строковые свойства компонент на формах. Как правило, язык по умолчанию — это английский. Но для «домашней» программы это вполне может быть русский.

Ещё раз сохраните всё и убедитесь, что проект компилируется.

Resource DLL Wizard/добавление нового языка

Прежде чем приступить к собственно переводу, вам нужно добавить языки в ваш проект. Делается это с помощью Resource DLL Wizard. Выберите в меню Project > Languages > Add или File > New > Other > Delphi Projects > Resource DLL Wizard.

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

Язык по умолчанию — это тот язык, на котором будет программа, если не найден более подходящий язык.

Далее вы выбираете один или несколько языков, которые хотите добавить:

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

На следующем шаге вам предложат сменить пути для проектов ресурсных DLL. По умолчанию, эти проекты размещаются в подпапках проекта. Имя подпапки = аббревиатуре языка по ISO 639x. Например, если ваш проект лежит в C:\. \Projects\My Project 1\, и вы выбрали три языка (русский, японский и итальянский), то Resource DLL Wizard создаст три новых проекта, разместив их в папках C:\. \My Project 1\RUS\, C:\. \My Project 1\JPN\ и C:\. \My Project 1\ITA\ соответственно. Достаточно разумный выбор, поэтому чаще всего вы пропускаете этот шаг.

После ещё нескольких маловажных вопросов (щёлкайте просто Next/Yes), Resource DLL Wizard создаст вам проекты:

Как видите, для одного головного проекта я добавил три языка, и Resource DLL Wizard создал мне три дополнительных проекта. В каждом проекте есть несколько файлов — по одному на каждый модуль с DFM или блоком resourcestring.

Вы можете запускать процедуру добавления нового языка в любой момент. Просто выбирайте эту же команду, щёлкайте на дополнительном языке — и Next/Next/Next. Также, язык можно удалить, если он стал не нужен — в том же меню есть команда Remove (она не удаляет файлы с диска, а просто удаляет проект из группы проектов).

Translation Editor/перевод проектов

После добавления языков в проект, вы можете использовать Translation Editor для просмотра и редактирования VCL-форм и строковых ресурсов.

Проще всего дважды щёлкнуть по нужному файлу (dfm или rc) в проекте ресурсной DLL. Откроется такое окно:

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

Также вы можете фильтровать строки таблицы (скажем, показать только не переведённые), менять статус строк, производить поиск (перейти к следующей не переведённой строке), переключать редактор в single line/multi line — всё это делается кнопками на тулбаре и из контекстного меню. Дополнительно, вы можете снабжать строки комментариями для переводчика.

Обратите внимание, что вы можете редактировать не только строки, но и любые другие свойства компонентов. Это важно, если в каком-то языке у вас не влезает какая-то надпись — в этом случае вы просто раздвигаете компоненты, чтобы она влезла. Две кнопки с рисунком форм в верхнем тулбаре позволяют вам показать исходную и транслированную версии форм. Т.е. вы можете посмотреть, как будет выглядеть окно, не запуская программу на выполнение. Более того, нажав на кнопку «Stay on top» чуть правее, вы можете зафиксировать формы, пока вы выполняете перевод. Любое изменение в Translation Editor тут же отображается на предпросмотре форм. Более того, вы можете не вводить свойства, а просто таскать компоненты по форме:

Очень удобно, надо сказать. Понятно, что если вы откроете на редактирование rc-файл, то никаких форм там не будет — просто строки и инструменты для строк.

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

Translation Repository/использование хранилища

Translation Repository позволяет вам хранить базу данных переводов, которая разделяется между всеми проектами (и может разделяться несколькими разработчиками). Работая в Translation Editor, вы можете извлекать уже переведённые строки из хранилища Translation Repository и сохранять в него новые переводы.

По умолчанию, каждый раз, когда вы создаёте/обновляете ресурсный модуль, все значения в нём извлекаются из словаря Translation Repository. Если же перевода в нём нет, то используется базовый вариант (строка из главного проекта). Вы также можете редактировать переводы прямо в Translation Repository через его собственный интерфейс:

Translation Repository хранит свои данные в XML-файле с расширением .tmx .

По умолчанию, БД Translation Repository хранится в файле default.tmx в папке RAD Studio\bin . К сожалению, это не слишком удачное место, потому что часто запись в эту папку запрещена. Поэтому я рекомендую вам сразу же скопировать этот файл куда-то в более пригодное место — в Мои документы или Application Data. Сделать это можно командой «Save as» в окне Translation Repository. Кроме того, этот файл указывается в диалоге настроек Translation Repository Options (Tools > Options > Translation Tools Options > Repository).

External Translation Manager/делегация перевода другому человеку

ETM доступен только в новых Delphi (начиная с D2009 — скажите спасибо введению поддержки Unicode). Вы можете использовать ETM, если вам недоступна Delphi. Например, для выполнения перевода переводчиком, а не программистом ;)

Подготовка ETM

Чтобы использовать ETM как автономное приложение, вам надо просто скопировать необходимые файлы на другую машину и зарегистрировать *.bpl в ETM:
1. Создайте в любом месте папку для файлов ETM.
2. Скопируйте следующие обязательные файлы из вашей папки RAD Studio\n.n\Bin в папку, созданную на шаге 1:

  • etm.exe
  • designide .bpl
  • dfm .bpl
  • itecore .bpl
  • rc .bpl
  • vclide .bpl

А также такие файлы (опционально):

  • dcl31w .bpl
  • dclact .bpl
  • dclado .bpl
  • dclbcbsmp .bpl
  • dclbde .bpl
  • dclDataSnapIndy10ServerTransport .bpl
  • dclDataSnapProviderClient .bpl
  • dclDataSnapServer .bpl
  • dcldb .bpl
  • dcldbx .bpl
  • dcldbxcds .bpl
  • dclib .bpl
  • dclIe .bpl
  • dclIndyCore .bpl
  • dclIndyProtocols .bpl
  • dclmcn .bpl
  • dclmid .bpl
  • dclnet .bpl
  • dclribbon .bpl
  • dclsmp .bpl
  • dclstd .bpl
  • dclTee8 .bpl
  • dcltouch .bpl
  • dclwbm .bpl

Из папки Windows\System32 (SysWOW64 для 64-х битной Windows) также нужно взять такие обязательные файлы:

  • rtl .bpl
  • vcl .bpl
  • vclactnband .bpl
  • vclimg .bpl
  • vclx .bpl
  • xmlrtl .bpl

и следующие опциональные файлы:

  • * .bpl

Где nnn — это версия вашей Delphi. Например, RAD Studio 2009 имеет версию 120, а 2010 — 140. Т.е., designide .bpl становится designide120.bpl или designide140.bpl.
3. Упакуйте папку с ETM в архив и передайте человеку, который будет выполнять перевод.

P.S. Не спрашивайте меня, зачем нужны опциональные файлы — я понятия не имею, а справка молчит. Но есть подозрение, что это надо для приложений с пакетами. Хотя зачем — непонятно.

Установка ETM

1. Распакуйте архив с ETM в любую папку. Предпочтительно — в C:\Program Files\.
2. Запустите ETM, дважды щёлкнув по etm.exe.
3. Выполните команду Tools > Options > Packages.
4. Нажмите кнопку «Add».
5. В открывшемся диалоге перейдите в папку с ETM и выберите все design-time пакеты (dcl*.bpl).

Подготовка проекта для перевода в ETM

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

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

  • Папку с ресурсной DLL для конкретного языка
  • Файл проекта dproj/cbproj
  • Хранилище переводов (*.tmx)

Использование ETM для перевода проектов

Собственно, вы запускаете ETM, открываете в нём файл проекта или группу проектов (как обычно: File/Open) и начинаете редактировать:

Вкладка Project содержит настройки проекта. Вкладка Workspace — рабочие данные. Выбрав корневой узел, вы получите статистику, а выбрав конкретный файл — увидите обычный Translation Editor:

Вы должны выполнить перевод, сохранить его и отправить изменённые файлы (папку с ресурсной DLL) разработчику. Разработчик перезапишет свои файлы вашей версией и скомпилирует ресурсную DLL с локализованной версией программы.

Deploy проекта

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

В результате вы получите главный файл (exe или DLL) и по файлу на каждый язык. Эти файлы являются DLL, но имеют расширения, обозначающие язык. Например, Project1.exe и Project1.RUS, Project1.JPN и Project1.ITA (в некоторых случаях расширение может иметь вид en-US). Вы можете распространять все файлы вместе или же распространять только exe, а файлы языков выложить для отдельного скачивания — ваш выбор.

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

К сожалению, выделить отдельную папку для хранения языковых файлов (типа подпапки Languages) нельзя (ну, не используя хаки, конечно же).

Прочее

Обновление переводов при изменениях проекта

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

Чтобы обновить ресурсные DLL сохраните и скомпилируйте проект (если вы используете ETM — откройте проект заново), затем выполните команду: Project > Languages > Update localized projects (Project > Run updates в ETM). После этого ваши изменения будут отражены и в ресурсных DLL. Вы сможете дополнить перевод и пересобрать все проекты.

Файлы, создаваемые утилитами перевода

.dfm
Утилиты перевода хранят для каждого целевого языка отдельный файл формы .dfm для каждой формы в вашем приложении. Эти файлы включают в себя данные (включая переводы строк), которые вы видите в Translation Editor.
.rc Resource DLL Wizard использует созданный компилятором .drc файл для создания .rc файла для каждого целевого языка. Эти .rc файлы содержат строковые ресурсы, которые были объявлены в блоках resourcestring в вашем коде.
.tmx Translation Repository хранит свою базу переводов в файле .tmx file. Вы можете завести больше одного словаря в нескольких .tmx файлах.
.proj Translation Manager хранит проекты ресурсных DLL в разных папках (указываются при создании языка), а ссылки на эти проекты хранятся в файле проекта .dproj , .cbproj или .bdsproj .

Примечание: вам не следует редактировать эти файлы вручную.

Активный язык проекта

При запуске через F9 (Run/Run) загружается язык базового модуля. Но вы можете указать, что хотите загружать конкретный язык (ресурсную DLL). Для этого выполните команду Project > Languages > Set active. Укажите язык и при следующем запуске программы будет использоваться именно он. Для отмены этой настройки выполните эту же команду, но из списка доступных языков выберите базовый модуль.

Заметьте, что эта настройка не влияет на язык, используемый при реальном выполнении программы вне отладчика на клиентских машинах. В свободном прогоне загружается ресурсная DLL, определяемая языком пользовательского интерфейса. Т.е., грубо говоря, если кнопки в MessageBox написаны на японском — будет выбран японский язык. На русском — загружаем русскую DLL. И т.д. Это не то же самое, что язык в региональных настройках, клавиатурные раскладки или язык для не-unicode программ — это всё другие, не связанные вещи. В младших редакциях Windows язык UI жёстко зашит в систему и сменить его нельзя. Хотите сменить язык — ставьте другую версию ОС. В старших — вы можете устанавливать языковые пакеты и менять язык интерфейса по требованию (MUI) — для смены языка особых прав не надо (в отличие от его установки), нужно только сделать re-logon (выйти/зайти). Более того, каждый пользователь в системе может иметь свою настройку языка интерфейса:

В большинстве случае такое поведение — это то, что вы хотите. Если пользователь работает в немецкой Windows, ему нет смысла запускать вашу программу на русском или английском. Иначе он давно бы поставил себе русскую/английскую Windows (или сменил бы язык UI, если его редакция Windows это позволяет).

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

Тем не менее, если вы хотите это сделать, то вы можете это сделать. Для задания override на текущий язык вам нужно отредактировать ключ реестра Software\CodeGear\Locales (для старых версий Delphi — Software\Borland\Delphi\Locales или Software\Borland\Locales) в HKCU или HKLM (смотря на кого меняете настройку): добавив строковый (REG_SZ) параметр, имя которого равно полному пути к вашему exe или DLL библиотеке, а значение равно имени языка, например, ru-RU или en-US. В справке Delphi даже есть подходящая процедура для этого:

Вы можете посмотреть демонстрационную программу в комплекте демок Delphi: это проект RichEdit, в котором есть три языка (английский, французский и японский) и реализовано переключение между ними в run-time. Вы можете посмотреть, как это делается. Демку можно найти в папке демок. Это либо папка Demos в папке самой Delphi для старых Delphi, либо папка Demos в Моих документах (All users). В меню пуск на неё может быть создан ярлык. Или же вы можете её просто скачать c SVN.

Программирование на языке Delphi. Глава 2. Основы языка Delphi. Часть 1

Оглавление

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

Алфавит


Буквы

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

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

Буквы — это прописные и строчные символы латинского алфавита и символ подчеркивания:

Цифры представлены стандартной арабской формой записи:

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

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

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

Числа

Одно и то же число можно записать самыми разными способами, например:

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

Целые числа состоят только из цифр и знака + или -. Если знак опущен и число не равно 0, то оно рассматривается как положительное, например:

Вещественные числа содержат целую и дробную части, разделенные точкой:

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

Форма с фиксированной точкой совпадает с обычной записью чисел, например:

Форма с плавающей точкой используется при работе с очень большими или очень малыми числами. В этой форме число, стоящее перед буквой E, умножается на 10 в степени, указанной после буквы E:

Число, стоящее перед буквой E, называется мантиссой , а число после буквы E — порядком .

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

Слова-идентификаторы

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

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

Правильно


Неправильно


RightName Wrong Name
E_mail E-mail
_5inches 5inches

Все идентификаторы подразделяются на зарезервированные слова, стандартные директивы, стандартные идентификаторы и идентификаторы программиста.

Зарезервированные (ключевые) слова составляют основу языка Delphi, любое их искажение вызовет ошибку компиляции. Вот полный перечень зарезервированных слов:

Стандартные директивы интерпретируются либо как зарезервированные слова, либо как идентификаторы программиста в зависимости от контекста, в котором используются. Вот они:


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

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

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

Комментарии

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

Данные


Понятие типа данных

Программа в процессе выполнения всегда обрабатывает какие-либо данные. Данные могут представлять собой целые и дробные числа, символы, строки, массивы, множества и др. Так как компьютер всего лишь машина, для которой данные — это последовательность нулей и единиц, он должен абсолютно точно «знать», как их интерпретировать. По этой причине все данные в языке Delphi подразделены на типы. Для описания каждого типа данных существует свой стандартный идентификатор: для целых — Integer, для дробных — Real, для строк — string и т.д. Программист может образовывать собственные типы данных и давать им произвольные имена (о том, как это делается, мы поговорим чуть позже).

Тип данных показывает, какие значения принимают данные и какие операции можно с ними выполнять. Каждому типу данных соответствует определенный объем памяти, который требуется для размещения данных. Например, в языке Delphi существует тип данных Byte. Данные этого типа принимают значения в целочисленном диапазоне от 0 до 255, могут участвовать в операциях сложения, вычитания, умножения, деления, и занимают 1 байт памяти.

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

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

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

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

Константы

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

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

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

Очевидно, что, изменив базовую константу SecondsInMinute, можно изменить значение константы SecondsInDay.

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

Такие константы называются типизированными; их основное назначение — объявление константных значений составных типов данных.

Переменные

Переменные в отличие от констант могут неограниченное число раз менять свое значение в процессе работы программы. Если в начале программы некоторая переменная X имела значение 0, то в конце программы X может принять значение 10000. Так бывает, например, при суммировании введенных с клавиатуры чисел.

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

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

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

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

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

Простые типы данных


Целочисленные типы данных

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

Национальная библиотека им. Н. Э. Баумана
Bauman National Library

Персональные инструменты

Delphi (язык программирования)

Спроектировано Никлаус Вирт
Печать дисциплины Статическая, Строгая
OS Кроссплатформенное
Портал: embarcadero.com
Влияние
C#, Java

Delphi — (Де́лфи, произносится ˈdɛlˌfi:) — императивный, структурированный, объектно-ориентированный язык программирования со строгой статической типизацией переменных. Основная область использования — написание прикладного программного обеспечения. Первоначально носил название Object Pascal и исторически восходит к одноимённому диалекту языка, разработанному в фирме Apple в 1986 году группой Ларри Теслера. Однако в настоящее время термин Object Pascal чаще всего употребляется в значении языка среды программирования Delphi. Начиная с Delphi 7, в официальных документах Borland стала использовать название Delphi для обозначения языка Object Pascal.

Содержание

История развития языка

Основой языка Delphi послужил язык Паскаль, разработанный профессором Н.Виртом в конце 60-х годов специально для обучения студентов программированию. Паскаль был полностью процедурным языком, объектно-ориентированная парадигма была добавлена в Turbo Pascal. Object Pascal (диалектом которого является Delphi), является функциональным расширением языка Turbo Pascal.

Синтаксис

Операторы

Первый приоритет: -, not Второй приоритет: *, /, div, mod, and Третий приоритет: +, -, or, xor Четвертый приоритет: =, <>, , =

Типы данных

Types Ranges

Строки Строкой называется последовательность символов, заключённая в одиночные кавычки: ‘это текстовая строка’. Логический тип Тип Boolean обеспечивает перечисление логических True и False значений.

Структура программы

Каждая написанная на языке Delphi программа состоит из заголовка программы, поля используемых модулей Uses (к примеру, Uses Windows, Messages, SysUtils и т.д.), который может не входить в саму структуру, а также блоков описания и исполнения (начинаются составным оператором begin и заканчиваются end). Пример программы:

Компиляторы

Embarcadero Delphi (ранее наз. CodeGear Delphi и Borland Delphi) — самый известный компилятор, который является последователем Borland Pascal и Turbo Pascal. Используется Win16 (Delphi 1), Win32 (Delphi 2 и позже), Win64 (Delphi 16 (XE2) и позже), а также .NET 1.x, 2.0 (Delphi 8, Delphi 2005-Delphi 2007). Поддержка .NET впоследствии выделена в отдельный продукт, известный как Oxygen.

Free Pascal (FPC) — бесплатный компилятор Оbject Pascal, который поддерживает различные диалекты Паскаля, включая Turbo Pascal, Delphi и собственные диалекты. На текущий момент, FPC может генерировать код для x86, x86-64, PowerPC, SPARC и процессоров ARM, а также для различных операционных систем, в том числе для Microsoft Windows, Linux, FreeBSD, Mac OS. Существует несколько сред разработки программного обеспечения для FPC (один из самых известных представителей — Lazarus).

Oxygene (ранее известен как Chrome) — компилятор Object Pascal, интегрированный в Microsoft Visual Studio. Также доступен в виде компилятора с командной строкой CLI. Использует .NET и моно платформы. В настоящий момент продаётся под маркой Embarcadero Delphi Prism.

MIDletPascal — компилятор, преобразующий исходный код в компактный и быстрый байт-код Java.

Virtual Pascal — Бесплатный компилятор для Win32, OS/2 и Linux. На тот момент очень быстрый и весьма совместимый (частично поддерживаются конструкции Delphi 5). Разработка окончилась в 2004 году, исходники открыты не были. С тех пор FPC ушёл намного вперед и в целом для программирования лучше он.

Инструменты разработки

Delphi 1. Вышедший незадолго до появления Windows 95, Delphi 1.0 был первым инструментом разработки приложений Windows (3.1), объединившим в себе оптимизирующий компилятор, визуальную среду разработки и мощные средства для работы с базами данных. Для языка Pascal это стало настоящим перевоплощением — он стал Object Pascal.

Delphi 2. Вышедшая через год 2-я версия Delphi предлагала все то же, но уже для 32-разряных версий Windows (95/NT), опять-таки став первым средством, сочетающим 32-битный компилятор, средства для работы с БД и визуальную среду разработки, поддерживающую OLE (а после выхода обновленной Delphi 2.01 — и ActiveX). Язык так же изменился, став ориентированным на 32-разрядное применение.

Delphi 3. Дальнейшее совершенствование Delphi по всем направлениям привело к выходу 3-й версии, имевшей расширенный набор инструментов для создания приложений благодаря поддержке COM и ActiveX. В этой версии также впервые был сделан акцент на возможности создания приложений для Интернета, а так же появился нетипизированный тип данных — variant.

Delphi 4. Еще одна ключевая веха развития. В этой версии было введено много нового и полезного для упрощения разработки приложений, включая новую среду с динамическими подсказками и т.д. Была усовершенствована модель работы с компонентами (VCL), появилась возможность быстрого использования таких технологий, как MIDAS, DCOM и CORBA. В этой версии так же был усовершенствован язык Object Pascal: появились новые черты, свойственные современному ООП, были введены новые типы данных, включая 64-битные.

Delphi 5. Изменений в Delphi 4 было так много, что, к сожалению, не обошлось без досадных накладок и ошибок. Результатом был выпуск 3-х пакетов обновлений (наши пираты продавали их под вывесками Delphi 4.1, 4.2 и 4.3). Но самым полным и правильным пакетом обновлений следует считать Delphi 5 — в этой версии было доведено до ума все то, что было начато в Delphi 4.

Delphi 6. С выходом шестой версии Borland провозгласила новую, кросс-платформенную эпоху в Delphi, параллельно выпустив версию Delphi для ОС Linux (Kylix 1.0). Теперь при создании приложения можно было выбирать его тип — для Windows, или же универсальное. Соответственно, к библиотеке VCL добавилась библиотека CLX, совместимая как с Windows, так и с Linux. Кроме того, в 6-й версии наконец-то появились «родные», а не чужеродные ActiveX, компоненты для работы с Интернетом, причем сразу в обоих вариантах — и для VCL и для CLX. Начиная с этой версии, сам язык программирования Object Pascal официально называется Delphi.

Delphi 7. Дальнейшее развитие Delphi 6, улучшенная библиотека CLX и новая корреспондирующая версия среды разработки под ОС Linux — Kylix 3. Вместе с тем, начиная с Delphi 7, Borland озаботилась вопросом совместимости с еще одной платформой — Microsoft .NET, для чего некоторые изменения были внесены как в VCL, так и в язык (и, соответственно, в компилятор). Delphi 8. Первая версия Delphi, ориентированная на работу с платформой Microsoft.NET. В этой версии разработчики изменили интерфейс среды, сделав его похожим на продукцию Microsoft — нового крупного акционера Borland. Поддержка, соответственно, была Kylix прекращена.

Delphi 2005. Менее чем через год после выхода Delphi 8, появилась новая версия, в которой вернули возможность работать в классическом стиле IDE при разработке приложений для Windows. Вместе с тем, Delphi 2005, в случае разработки приложений специально для платформы NET, позволяет работать не только с языком Delphi, но и с C#. При этом в сам язык Delphi были введены такие новшества, как оператор for…in и встраиваемые процедуры и функции.

Delphi 2006. Последняя версия Делфи, выпущенная фирмой Borland. Так же была выпущена облегченная версия — Turbo Delphi.

Delphi 2007. Версия, выпущенная CodeGear. Добавлена поддержка интерфейса Aero для Windows Vista.

Delphi 2009. Версия, выпущенная Embarcodero. Реализована поддержка Unicode в VCL и RTL, заменены обращения к о всем функциям Windows API на аналоги в Unicode, добавлены обобщенные типы и анонимные методы.

Delphi 2010. Поддержка Windows 7, компоненты для работы с касаниями и жестами, компоненты dbExpress теперь официально поддерживает Firebird.

Delphi XE (Delphi 2011). Добавлена поддержка для облачных вычислений.

Особенности языка

Изначально, язык ставил во главу стройность и высокую читаемость, поскольку был предназначен для обучения дисциплине программирования. Эта изначальная стройность, в дальнейшем, как по мере роста аппаратных мощностей, так и в результате появления новых парадигм, упростила расширение языка новыми конструкциями. Так, сложность объектного C++, по сравнению с C, выросла весьма существенно и затруднила его изучение в качестве первого языка программирования, чего нельзя сказать об Object Pascal относительно Pascal.

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

В Delphi идентификаторы типов, переменных, а равно и ключевые слова читаются независимо от регистра: например идентификатор SomeVar полностью эквивалентен somevar.

В исходных файлах pas (которые, как правило, и содержат основное тело программы) на уровне языковых средств введено строгое разделение на интерфейсный раздел и раздел реализации. В интерфейсной части содержатся лишь объявления типов и методов, тогда как код реализации в интерфейсной части не допускается на уровне компиляции. Подобное разделение свойственно также языкам C/C++, где вводится разделение на заголовочные и собственно файлы реализации, но подобное разделение не обеспечивается на уровне языка или компилятора.

В Delphi метод или функция четко определяются зарезервированными для этого ключевыми словами procedure или function, тогда как в C-подобных языках различие обуславливается ключевым словом, определяющим тип возвращаемого значения.

Начало и конец программного блока выделяются ключевыми словами begin и end, тогда как в C-подобных языках программирования для этих целей используются фигурные скобки: <>. Таким образом, в Delphi достигается лучшая читаемость кода.

Зарезервированные слова Delphi

var A, B : Integer; begin A:=3; B:=4; A:=A*A+B*B; end;

if (условие) then (действие) else (альтернатива) ;

Слова if (если), then (тогда), else (иначе) — зарезервированные. Действие и else альтернатива — это любые операторы Delphi, или несколько операторов, заключённых в логические скобки begin/end, или вызов подпрограммы. Если условие истинно, то выполняется действие, если ложно, то выполняется альтернатива.

(применяется, когда известно количество повторений цикла)

for счётчик := выражение-1 to выражение-2 do действие ;

Возможна работа оператора цикла, при котором переменная-счётчик будет не увеличиваться, а уменьшаться. В этом случае ключевое слово to заменяется на downto:

for счётчик := выражение-1 downto выражение-2 do действие ;

Цикл с предусловием (применяется, когда неизвестно количество повторений цикла)

while условие do тело цикла ;

Этот цикл будет выполняться до тех пор, пока истинно условие (логическое выражение, возвращающее значение типа Boolean). При этом если это выражение сразу равно false, тело цикла не будет выполнено ни разу. Нужно очень внимательно следить за написанием условия и контролем завершения цикла, так как в результате ошибки цикл while будет повторяться бесконечное количество раз, что приведёт к «зацикливанию» и «зависанию» программы.

Цикл с постусловием

(применяется, когда неизвестно количество повторений цикла)

repeat тело цикла until условие ;

Повторения сначала выполняет тело цикла, а затем уже проверяет выполнение условия: Таким образом, этот вариант цикла гарантирует, что тело цикла будет выполнен по крайней мере один раз. И будет выполняться до тех пор, пока условие не станет истинным (т.е. true). Стоит отметить, что это единственный оператор Delphi, в котором тело цикла не требуется заключать в логические скобки begin/end. Начало и конец тела цикла определяются по ключевым словам repeat и until.

Позволяет изменить последовательность выполнения программы. В качестве метки может использоваться любой допустимый идентификатор или число в диапазоне от 0 до 9999. Метку предварительно необходимо объявить в разделе описания переменных, но с помощью не ключевого слова var, а ключевого слова label:

Программы в Delphi 7 в консольном виде

Прошу помощи в создании программ в Delphi 7 (консольный вид).
Сортировка массивов
Упорядочить столбцы двумерного массива элементов типа Char по возрастанию их ординальных номеров методом прямого включения.
Процедуры и функции. Рекурсия.
1. Используя процедуру пустого цикла, вывести на печать слово «информатика» с задержкой после каждого слога.
2. Составить программу для решения задачи, используя вначале комбинированные процедуры (с параметрами-значениями и с параметрами-переменными), а затем функции пользователя:
Для чисел a,b,c найти значение выражения min(a+b,a+c,b+c)/min(a,c,1+5) с использованием процедуры нахождения минимального из трех чисел.
Строковые величины.
1. Определить, является ли данный текст десятичной записью целого числа.
2. 1. Напечатать заглавными буквами текст строчных букв.
2. Для текста, состоящего из слов, разделенных пробелами, выполнить поиск слов, у которых первая и последняя буквы одинаковые и вывести их.
Множества
Дана непустая последовательность слов из строчных латинских букв. Слова разделены запятой, за последним словом — точка. Напечатать в алфавитном порядке все гласные, которые входят только в одно слово. Гласные буквы: a,e,o,u,i,y.
Записи
Опишите заданный тип, осуществите ввод данных, произведите определенные операции и выведите на печать значение полей (где возможно). Во всех случаях используйте массив из записей.
Данные о животном в зоопарке: название, средний вес (женской, мужской особи), продолжительность жизни, размножение в неволе, количество (женских, мужских особей). Рассчитать отношение общего веса женских особей к общему весу мужских особей.
Файлы
Составить программу, реализующую конкретную схему действий. В содержимое программы должна входить процедура формирования исходного файла нужного типа и формата.
Дан файл F1, компонентами которого являются целые числа. Найти среднее арифметическое неотрицательных компонент файла, а из отрицательных составить новый файл F2.

Добавлено через 12 часов 23 минуты

Program — Ключевое слово Delphi

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

Многоязычные приложения. Создание библиотек ресурсов

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

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

Точный смысл термина локализация (locale) вовсе не идентичен понятию «страна». Он складывается из двух частей: настроек на особенности конкретной страны и на используемые в ней языки. Для некоторых стран при локализации Windows используются по два языка или разновидности, например, в Сербии и Норвегии. Также верно и обратное — один язык (в частности, английский, испанский, арабский) применяется во многих странах. При этом национальные особенности (система мер, терминология, способ сортировки, форматы представления денежных единиц и даты/времени) в этих странах отличаются. Поэтому название локализации состоит из трех букв: две обозначают язык и одна — страну. В программах для Windows вы можете встретить разновидности английского: ENLJ (США), ENG (Великобритания) и еще с десяток. Для России (локализация RUS) эта двойственность отсутствует.

Традиционный способ разделить программный код и элементы пользовательского интерфейса — это использование ресурсов. Со средствами разработки от Inprise, начиная еще с Borland Pascal for Windows, поставляются инструменты для работы с ресурсами, такие, как Resource Workshop. В Delphi сама форма, по сути дела, является ресурсом, с которым можно работать прямо в визуальной среде; для специализированных графических ресурсов предназначена утилита Image Editor.

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

В Delphi 5 специально для решения задач локализации появился целый комплекс средств под общим названием Integrated Translation Environment (ITE). Он состоит из трех составных частей: Мастера создания динамических библиотек ресурсов (Resource DLL Wizard), Менеджера переводов (Translation Manager) и Репозитория переводов (Translation Repository). Им, в основном, и посвящена данная глава.

Мастер создания динамических библиотек ресурсов

В Delphi процесс интернационализации легче всего автоматизировать путем создания так называемых динамических библиотек ресурсов. На это есть специальный мастер, вызываемый через пункт New. меню File (рис. 10.1). Можно вызвать его и другим путем — через пункт меню Project\Languages\Add.

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

Первым выводимым Мастером окном будет приветствие и краткое описание возможностей. Далее мастер показывает диалоговое окно, в котором следует выбрать проекты, подлежащие интернационализации (рис. 10.2). Термин базовый язык (Base Language, третий столбец) означает код языка, который будет присвоен основным файлам проекта; по умолчанию базовый язык берется из текущих настроек операционной системы.

Рис. 10.1. Вызов мастера создания библиотек ресурсов

Рис. 10.2. Мастер создания библиотек ресурсов. Диалоговое окно выбора проектов

Рис. 10.3. Выбор языков, на которые будет осуществлен перевод

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

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

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

  • в папке проекта создается файл с именем проекта и расширением drc, который представляет собой совокупность всех используемых строковых ресурсов. Формат этого файла — обычный исходный текстовый формат хранения ресурсов (rc);
  • проект с тем же именем, что и исходный; он будет лежать во вложенной папке с именем, соответствующим выбранной стране локализации. В него входят все файлы, которые обычно встречаются в проектах, плюс специальные файлы ite. Первая разновидность файлов носит название имя формы, dfn, вторая — имя проекта_орс.рс. Это наши «старые знакомые» — два вида ресурсов, дополненных специальными комментариями для работы ite. Хотя они имеют текстовый формат, но редактировать их вручную не следует — методика работы с ними описана ниже, в описании утилиты Translation Manager.
  • файл группы проектов с расширением bpg. Действительно, наш проект дополнился еще одним, и теперь они составляют группу. Единственный недостаток мастера — он предлагает сохранить файл bpg в той же папке, где и созданная локализация. Целесообразнее сделать это в корневом каталоге исходного проекта.

Результатом компиляции станет динамическая библиотека с именем имя проекта имя локализации, в данном случае PROJECT 1 . UKR. Эту библиотеку

нужно поместить и распространять вместе с ЕХЕ-файлом проекта. При запуске приложения, написанного на Delphi 5, библиотека времени выполнения производит попытку настройки. Если на целевом компьютере установлен тот национальный интерфейс, который соответствует расширению динамической библиотеки ресурсов (в данном случае ukr), то все локализованные вами ресурсы будут загружены из нее.

После создания проекта библиотеки (*.dpr) перед глазами открывается такой весьма скупой код, содержащийся в нем:

// Do not edit. This file is machine generated by the Resource DLL Wizard.

($R ‘Unitl.dfm’ Forml:TForm)

Две директивы $r указывают на те ресурсы, ради которых все и «затевалось». Директива $е указывает на расширение файла, которое будет присвоено динамической библиотеке после компиляции.


Для ресурсов-текстовых строк в язык Object Pascal введено новое ключевое слово — resourcestring. Строки-константы, описанные с его помощью, будут собраны вместе в таблицу ресурсов. Если вы хотите упростить проблему локализации вашего приложения, замените везде выражения вида

ShowMessage( ‘ Ошибка открытия файла’ );

resourcestring sOpenError = ‘ Ошибка открытия файла ‘;

Целесообразно собрать все ресурсные строки вашей программы в одном месте; лучше всего для этого выделить отдельный модуль. Так поступили и разработчики VCL — найдите модули consts.pas, dbconsts.pas, BDECONST.PAS, OLECONST.PAS, MIDCONST.PAS, MXCONSTS.РА S , WEBCONST.РА S в прилагаемых к Delphi исходных текстах. Кроме строковых констант, описанных через ключевое слово resourcestring, там ничего нет. Для того чтобы перевести все сообщения среды выполнения Delphi на русский, вам достаточно перевести эти модули с помощью ite и затем включить их национальную версию в состав вашего проекта.

Использование Менеджера переводов

В версии 5 среды Delphi значительно усовершенствованы инструменты для автоматизации подготовки многоязычных версий. После выполнения мастеpa создания динамических библиотек ресурсов управление автоматически передается Менеджеру переводов (рис. 10.4). Специально для его вызова предназначен также пункт Translation manager меню View.

Рис. 10.4. Внешний вид Менеджера переводов (Translation Manager)

Окно Менеджера переводов состоит из двух частей. В левой части приводится список всех проектов на разных языках и сосредоточены административные функции. Для каждого проекта предусмотрены две папки, соответствующие разновидностям локализуемых ресурсов: Формы (Forms) и Скрипты ресурсов (Resource scripts).

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

Если в левой части выделен конкретный ресурс, в правой появляется таблица с теми свойствами и значениями, которые подлежат интернационализации. Такая таблица показана на рисунке 10.4.

В эту таблицу Менеджера переводов попадают не все свойства визуальных компонентов, а только те, которые собственно и поддаются локализации. Что это за свойства? Их легко увидеть в Инспекторе объектов, если переключить его в режим отображения свойств по категориям. Нужные нам свойства находятся в категории LocalizabIe (рис. 10.5).

На рисунке видно, что помимо шрифта и надписей, в состав свойств, меняющихся в зависимости от языка, входят также размеры, значки, файл справки и т. п. У многих компонентов в’Delphi 5 есть свойства RiniModp и ParentBiDiMode, описывающие начертание текста. Они позволяют располагать его справа налево, как это принято в ряде ближневосточных языков.

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

При разработке пользовательского интерфейса имейте в виду, что длина надписей (в буквах) на национальных языках может сильно отличаться от их длины на английском, вплоть до двукратного удлинения. Учтите это при расположении компонентов типа TLabel, TEdit и т. п. Где возможно, позвольте компонентам автоматически масштабироваться.

Рис. 10.5. Локализуемые свойства компонента TForm

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

В столбце ID указывается идентификатор ресурса. Для строковых констант в этой колонке отображается имя константы. Например, если вы увидели идентификатор sysConst_szeroDivide, то в файле с расширением drc можно найти соответствующую этой константе строку «Floating point division by zero». Это имя образуется из имени модуля, где описана константа, и имени самой константы, разделенных символом подчеркивания. Для компонентов на формах ID образуется по другому правилу. Если вы видите > начинающийся с о — это свойство объекта (см. рис. 10.4). Буква i будет означать, что объект унаследован с другой формы, a l — с кадра (Frame). Таким образом, идентификатор o:Formi.Font.Name соответствует имени шрифта формы Formi.

Следующая колонка показывает значения всех свойств для базового языка проекта. В проекте RichEdit этот язык — английский, а если вы создаете новый проект в русскоязычной версии Windows, то этот язык будет русским. Новые (переведенные на тот или иной язык) значения содержатся в столбце с именем этого языка.

Столбец Status показывает состояние свойства; значение Translated означает, что перевод осуществлен. У него есть три возможных значения: Translated, Untranslated и Auto Translated. Любое изменение свойства устанавливает этот флаг в Translated. Если вы не хотите реально изменять строку, можно просто переустановить свойство щелчком в данной колонке. Значение Auto Translated устанавливается, если перевод осуществлен при помощи Репозитория переводов (см. следующий раздел).

Столбцы Created и Modifie d создаются и автоматически поддерживаются системой. Наконец, если вы хотите прокомментировать значение свойства, в вашем распоряжении столбец Comment.

В таблице Менеджера переводов достаточно удобно редактировать текстовые строки, тем более что для этого есть специальный двухоконный редактор (он вызывается из панели инструментов Менеджера переводов, рис. 10.6). Но вот другие виды свойств — перечислимые (как например Font.charset), числовые — редактировать не очень удобно. А свойство icon (значки) редактировать практически невозможно — значок представлен в двоичном виде. В этом случае редактировать формы нужно при помощи стандартных возможностей среды Delphi и Инспектора объектов, а затем сохранить изменения и вернуться в Менеджер переводов. При этом свойство получит флаг Translated.

Рис. 10.6. Такой редактор встроен в Менеджер переводов

Что делать, если вы отлаживаете ресурсы сразу для нескольких стран, а требуемая локализация не установлена у вас на компьютере? В пятой версии Delphi упрощен процесс переключения между языками при отладке. Теперь для этого предусмотрен пункт главного меню Delphi Project\ Languages\SetActive. Если все библиотеки DLL скомпилированы, то простым переключением в этом пункте меню вы можете просмотреть работу каждой из них. Если выбрано значение none, то приложение запускается с тем видом ресурсов, который соответствует текущим настройкам Windows. Разработчиками Inprise предусмотрен и другой выход из этой ситуации. Вы должны внести в ключ системного реестра hkey_current_user\

Software\Borland\Locales элемент данных вида «имя_приложения»=»имя_локализации». Например, если вы хотите испытать интерфейс описываемого приложения на украинском языке, элемент данных должен выглядеть так:

[HKEY_CURRENT_USER\Software\Borland\Locales] «d:\\Program Files\\Borland\\Delphi5\\Project5

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

Можно переключать национальные интерфейсы и «на ходу», во время работы приложения. Пример этого приведен в приложении RICHEDIT, поставляемом среди примеров с Delphi (папка d emo s\richedit). В нем при помощи меню вы можете выбрать один из трех языков, и тут же подгрузится необходимая динамическая библиотека ресурсов. Если вы всерьез занимаетесь проблемами интернационализации, советуем обратить на этот пример самое пристальное внимание. Функции, которые осуществляют это (модуль reinit.pas). можно без изменений позаимствовать и внести в свой проект.

Использование Репозитория переводов

Для централизованного хранения переведенных на другие языки ресурсов в Delphi 5 есть специальное средство — Репозиторий переводов (Translation Repository, рис. 10.7). Эта утилита позволяет собирать переведенные строковые ресурсы из проектов и в дальнейшем использовать их во вновь создаваемых проектах.

Репозиторий создает специальный файл с расширением drs, который хранится в папке исполняемых файлов Delphi (Delphi \Bin). Вы можете создавать и редактировать свои собственные DRS-файлы, использовать и распространять их, а также пользоваться файлами, созданными другими разработчиками.

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

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

ется в ваш проект, напротив этой строки в Менеджере переводов в поле Status поднимается флажок AutoTranslated.

Рис. 10.7. Внешний вид Репозитория переводов

Вы можете один раз перевести константы из часто используемых файлов констант (consts.pas, sysconst.раз, DBCONSTs.раз и др.) или найти уже готовые файлы переводов в Интернете.

Строки в Репозиторий попадают из проекта так: в Менеджере переводов вы выделяете одну или несколько строк (со строковыми ресурсами!), нажимаете правую кнопку мыши и во всплывающем меню выбираете пункт «Repository\Add strings to Repository». В ряде случаев пункт Repository недоступен. Это может быть по двум причинам: среди выбранных вами ресурсов есть не только строки, и в случае совпадения исходного и целевого языков. Если вы хотите иметь англоязычную и русскую версии вашего приложения, нужно в Мастере создания библиотек ресурсов выбрать в качестве базового языка английский, а потом добавить к нему русскую DLL. В противном случае при работе в русской версии Windows строки на английском будут трактоваться как русские.

В проекте Richedit есть строки из модулей SysConst, Consts, ComStrs, уже переведенные на французский и немецкий. Если загрузить их в Репозиторий переводов, то это может послужить первым вкладом в вашу коллекцию ресурсов.

Импорт и экспорт данных предусмотрен в формате xml. Этот быстро набирающий популярность формат имеет хорошую перспективу стать стандартом де-факто для обмена данными.

Информация о версии вашего продукта

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

Вставить в ваш проект информацию о версии поможет сама Delphi. Вызвав пункт Options меню Project, на странице Version Info вы увидите структуру, которая и будет ее содержать (рис. 10.8). Для того чтобы в ваш проект попала эта структура, нужно поднять флажок Include version information in project.

Рис. 10.8. На странице Version Info вы можете задать информацию о текущей версии продукта

Что это за структура? Информация о версии помещается в особый вид ресурсов и компилируется в исполняемый файл или динамическую библиотеку проекта. Если вы запустите любой редактор ресурсов и загрузите в него какое-то приложение, помимо ресурсов Bitmap, Icon, Cursor, вы можете увидеть и тип Version. Такой тип ресурсов представляет из себя структуру двоичных данных, состоящую из поля фиксированной длины (fixeddfileinfo), поля данных локализации (translation) и набора строк переменной длины. То, что вы видите на рисунке, соответствует полям этой структуры.

Но что необходимо указать в этих полях? Чем FileVersion отличается от ProductVersion? Некоторые поля структуры являются обязательными, некоторые — нет. Обязательные поля приведены в табл. 10.1.

Таблица 10.1. Обязательные поля для информации о версии

Delphi — это просто. Создаем полезные программы

Виктор Карпинский, Владимир Молочков (В. Новгород)

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

Шуточная программа «Чувствительная кнопка»

Что значит «чувствительная»? Кнопка будет как-то реагировать на все, что мы с ней будем делать. Ну, например, если нажать на нее курсором мыши, то она будет возмущаться: «Ой! Меня нажали». А если потом отпустить, то удовлетворенно сообщит: «Уф, меня отпустили».

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

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

1. Запустите Delphi (как ее установить на своем компьютере, мы рассказали в предыдущей статье). Запустить ее можно так, как показано на рисунке.

2. После загрузки появится интерфейс Delphi (он описан в предыдущей статье). При этом стартовая форма Form1 и ее программный модуль Unit1 будут созданы автоматически. Для того чтобы сохранить ваш первый проект, воспользуйтесь меню Файл (File) > Сохранить проект как… (Save Project as…).

3. Открывается окно сохранения программного модуля Unit1. С помощью кнопки «Создание новой папки» создайте папку «Пример 1».

4. Откройте созданную папку и два раза нажмите кнопку «Сохранить». Первое нажатие кнопки сохранит файл Unit1.pas, содержащий текст программы, а второе — файл Project1.dpr, содержащий общие сведения о проекте. На самом деле сохраняется больше, чем два файла: файл Unit1.dfm содержит сведения о связанной с программным модулем Unit1 форме Form1. Файл Project1.cfg содержит параметры конфигурации проекта, а файл Project1.dof — используемые настройки системы программирования Delphi. Впрочем, начинающему программисту это знать не обязательно.

Если вам показалось, что сохранять написанную в Delphi программу сложно, можем вас успокоить: так, как описано выше, надо сохранять только один раз, при начале работы над новым проектом. Все дальнейшие изменения сохраняются очень просто — одним нажатием кнопки «Сохранить» (Save) главного окна Delphi.

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

5. В инспекторе объектов (Object Inspector) найдите свойство Caption (заголовок). Щелкните против него в графе значений свойств мышью, сотрите имевшееся там слово «Form1» и впишите вместо него «Чувствительная кнопка».

Заголовок формы сразу изменится.

6. Аналогичным способом изменим размеры формы. В инспекторе объектов найдите свойство Height (высота) и замените его значение на 200, а потом значение свойства Width (ширина) — на 300. Опять-таки вы сразу увидите изменение параметров формы. Это визуальное программирование в действии.

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

На этот раз никаких видимых изменений в положении формы не произошло. Свойство Position влияет на форму при работе программы, а не в режиме редактирования. Проверки ради вы можете нажать в главном окне Delphi кнопку «Выполнить» (Run). На этой кнопке нарисована зеленая стрелка. После ее нажатия окна просмотра списка объектов Object TreeView и инспектора объектов исчезнут, а окно созданной вами программы появится в центре экрана.

Для возвращения в режим редактирования надо закрыть программу «Чувствительная кнопка» обычным для приложений Windows способом — нажав в ее правом верхнем углу на кнопочку с крестиком. Написанная программа пока еще ничего не делает, но уже является настоящим полноценным приложением Windows. У нее появляется даже своя кнопка на панели запуска программ внизу экрана, ее можно свернуть или развернуть во весь экран.

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

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

8. Для этого наверху в главном окне Delphi в палитре компонентов стандартной (Standard) выберите компонент «Кнопка» (Button). Вставьте его на форму, просто щелкнув по ней мышкой.

Теперь у нас есть два объекта: форма Form1 и кнопка Button1. Их можно выбирать для редактирования либо щелчком мыши (выделенный объект, кроме самой формы, обозначается маленькими черными квадратиками по краям). А можно выбирать их и в инспекторе объектов.

9. Так же, как вы это делали с формой (см. пункты 5 и 6), измените заголовок (Caption) и размеры (Width и Height) кнопки. Заголовок сделайте «Здравствуйте, я — кнопка», ширину 200, высоту 40. Сохраните и запустите программу. Теперь она выглядит так:

Убедитесь, что кнопка нажимается (хотя пока еще при этом ничего не происходит, ведь мы пока еще не написали в тексте программы ни одного программного кода). Текст в окне редактора кода уже довольно велик, но весь он написан автоматически. Вот этот текст:

Листинг 1. Автоматически созданный программный код

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

В разделе uses указаны те библиотеки, которые нужны для компиляции программы. Например, библиотека StdCtrls добавилась в момент внедрения на форму кнопки, потому что именно в этой библиотеке содержатся необходимые для работы кнопки части программного кода. Раздел кода программы type описывает форму (ее класс как программного объекта TForm1) и перечисляет все объекты, размещенные на ней. Например, в момент внедрения на форму кнопки сюда добавилась строка Button1: TButton. Далее в разделе var перечисляются все глобальные для данного модуля переменные. Пока такая переменная только одна — сама форма Form1. После слова implementation будут появляться процедуры обработки событий, но об этом — чуть ниже.

Итак, кнопка у нас есть. Однако название программы обещает, что кнопка будет чувствительная. Как это сделать?

У объектов программы помимо обычных свойств (например, размеров) есть и свойства, связанные с реакцией этих объектов на какие-то события. Эти свойства называются методами, или обработчиками событий, и помещаются в окне инспектора объектов на вкладке Events.

10. Убедитесь, что на форме в режиме редактирования выбран компонент Button1. На вкладке Events окна инспектора объектов (прокрутив вписок вниз) выберите свойство OnMouseDown. Это означает «При нажатии мышью». Щелкните возле названия этого свойства мышью, чтобы место для его значения выделилось белым цветом, а потом по этому белому пустому месту сделайте двойной щелчок мышью.

В результате появится следующий текст в окне редактирования кода:

Листинг 2. Автоматически созданный шаблон процедуры Button1MouseDown

procedure TForm1.Button1MouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

Такой фрагмент текста называется описанием процедуры. После ключевого слова procedure находится название (имя) процедуры. В данном случае его можно расшифровать так: на форме Form1 для объекта Button1 при возникновении события Mouse Down. Далее в круглых скобках помещены описания формальных параметров процедуры. О таких параметрах речь пойдет при изучении более сложных и интересных примеров программирования. Следующее ключевое слово begin (начало) открывает тело процедуры. Все команды, написанные между begin и end, будут выполнены при наступлении указанного события (в данном случае при нажатии мышью). Описание процедуры, у которого между begin и end ничего нет, называется заглушкой процедуры. Ту часть кода, которую программист вписал вручную, можно вручную стереть или изменить. Однако автоматически появившуюся часть кода удалять или изменять не следует. Если появилась ненужная заглушка процедуры (например, случайно сделали двойной щелчок мышью по объекту), то ее не надо удалять самому. Пустые, не измененные программистом заглушки автоматически исчезают при сохранении программы.

Щелкните мышью по тексту так, чтобы между словами begin и end появился текстовый курсор (мигающая вертикальная черточка). Принято все, что мы добавляем между begin и end писать с некоторым отступом, то есть не прямо от левого края, а немного правее. Впишите туда команду, означающую, что значение свойства Caption объекта Button1 надо заменить на «Ой! Меня нажали». Вот как это должно выглядеть:

Листинг 3. Работающий текст процедуры Button1MouseDown для программы «Чувствительная кнопка»

procedure TForm1.Button1MouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

Button1.Caption := «Ой! Меня нажали»;

Обратите внимание на две особенности языка Паскаль. Во-первых, название свойства и объекта пишутся в обратном порядке: мы говорим «свойство Caption объекта Button1», а пишем «Button1.Caption». Перед точкой стоит имя объекта, а после точки имя свойства. Во-вторых, вместо кавычек в языке Паскаль для текстов используются апострофы. Это то же, что кавычки, но одинарные (‘). Апострофы, как и кавычки, используются парами: один перед текстом, а второй после него. Внутри пары апострофов можно писать что угодно, в том числе и русскими буквами.

12. Сохраните и запустите программу. Убедитесь, что на нажатие кнопка уже реагирует, а на отпускание пока нет.

Домашнее задание

Хоть мы и не в школе, однако, как говорили древние, «практика — учительница жизни».

  • Найдите в окне инспектора объектов обработчик события «Мышь отпущена» (OnMouseUp) и заставьте Delphi создать шаблон соответствующей процедуры.
  • Аналогично выполненному выше пункту 11 напишите между begin и end команду, меняющую заголовок кнопки на текст «Уф, меня отпустили».
  • Сохраните, запустите программу и убедитесь, что кнопка «чувствует» не только нажатия мышью, но и отпускание.

Программа «Вычисления по формуле»

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

Напишем несложную программу, автоматизирующую такие вычисления, например, для вычисления объема конуса. Из геометрии известно, что, если конус имеет высоту h и радиус основания R, то его объем вычисляется по формуле:

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

1. Если вы продолжаете работу с Delphi, то закройте старый проект (меню Файл (File) > Закрыть все (Close all)), а потом создайте новый (меню Файл (File) > Создать новый (New) > Приложение (Applicatoin)). Сохраните новый проект в папке «Пример 2» (как это сделать — описано в начале примера 1).

2. Внедрите на форму следующие компоненты. Три объекта типа надпись (Label), два поля ввода (Edit) и кнопку (Button). Они все имеются в палитре стандартной (Standard) главного окна Delphi. Указанные шесть компонентов разместите на форме примерно так, как показано на рисунке.

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

3. Измените размеры и заголовки формы и других объектов, а также свойство Text объектов Edit1 и Edit2 так, чтобы получился следующий интерфейс

4. Для кнопки Button1 создайте обработчик события OnClick (если по ней щелкнули мышью). Напишите перед begin и между begin и end несколько строк так, чтобы в результате получилось следующее:

Листинг 4. Работающий текст процедуры Button1Click для вычисления по формуле

procedure TForm1.Button1Click(Sender: TObject);

h := StrToFloat ( Edit1.Text );

R := StrToFloat ( Edit2.Text );

V := h * pi * R*R / 3;

Label3.Caption := «Объем конуса V=» + FloatToStr ( V );

Что мы написали? Во-первых, мы указали, что процедура будет работать с числовыми величинами, обозначенными h, R и V. Далее мы написали, что значение переменной h берется из свойства Text объекта Edit1 (помните, что обозначение Edit1.Text читается справа налево?). Аналогично мы взяли значение для переменной R из объекта Edit2.

После этого стоит команда вычисления значения переменной V. Как вы видите, это та самая формула объема конуса, которую мы знаем из геометрии, только написанная в одну строку. В ней написано: h умножить на пи, потом умножить на квадрат R, а потом поделить на 3. Умножение обозначается звездочкой (обратите внимание: в программировании, в отличие от обычной математики, нельзя не ставить знак умножения).

Последняя написанная строка изменяет заголовок (Caption) объекта Label3 (третьей надписи). В этот заголовок помещается пояснительный текст «Объем конуса V=», к которому сзади добавлено значение переменной V.

В программе используется функция StrToFloat, превращающая строку текста (написанное цифрами число) в вещественное число (то есть в число, у которого может быть дробная часть). Это нужно потому, что свойство Text объектов Edit, равно как и свойство Caption любых объектов — строковое (String). А для вычисления нужны числовые значения (слова real в разделе var и Float в названии функции StrToFloat означают вещественное число). Таким образом, название функции StrToFloat означает: преобразовать значение из текстового формата (String) в числовой (Float) формат. Обратное действие — функция FloatToStr. Для целочисленных величин, описанных в разделе var как integer, есть функции StrToInt и IntToStr.

5. Сохраните и запустите программу. Убедитесь, что после нажатия кнопки (при h=15,25 и R=8,4) получается объем конуса V=1126,82645298959. Вводите (только правильно, не используя букв и прочих невозможных в записи числа символов) новые значения h и R и, нажимая кнопку, получайте новый ответ.

Домашнее задание

  • Напишите в Delphi программу, вычисляющую объем параллелепипеда со сторонами A, B и C (его объем есть произведение этих трех чисел).
  • Напишите в Delphi программу, вычисляющую заработную плату и подоходный налог работника, отработавшего N часов при почасовой ставке S. Его заработная плата Z=N*S, а подоходный налог (13%) составляет P=13/100*Z.

Неизменяемый «Read Me»

Компьютер может не только вычислять, но и работать с текстами. Самый простой пример программы, работающей с текстами, — это программа ReadMe, что значит «Прочти меня». Обычно такой файл есть на диске, с которого устанавливается на компьютер какая-нибудь новая игра или полезная программа. В файле ReadMe содержатся все необходимые пояснения, например, как именно установить программу.

Часто сам ReadMe представляет собой обычный текстовый файл, который открывается с помощью какого-нибудь текстового редактора, например, «Блокнота» Windows. Но это не всегда удобно: текстовый редактор позволяет не только читать текст, но и редактировать, то есть изменять его. И может получиться, что кто-то нечаянно или по злому умыслу изменит содержащиеся в ReadMe сведения. Поэтому может оказаться удобной программа вроде той, которую мы сейчас напишем.

Ну, а использовать ее вы сможете и в качестве прикола. Например, можно написать кому-нибудь в таком виде электронное письмо или оставить на рабочем столе файл с названием «Прочитать в случае аварии», а внутри содержащий текст: «Зачем же ты читаешь этот файл? Ведь аварии никакой нет! Что за невоспитанность?». Интересная особенность таких текстов в том, что только тот, кто написал программу, может изменить появляющийся текст, а тот, кто читает, — не может.

Итак, напишем программу ReadMe, выполняя по порядку следующие шаги:

1. Создайте новый проект Delphi (меню Файл (File)4Создать новый (New)4Приложение (Applicatoin)). Сохраните его в папке «Пример 3».

2. Разместите на форме компонент Memo.

3. Измените заголовок формы и ее размеры примерно так, как показано на рисунке (не забудьте свойству Position придать значение poScreenCenter).

4. Теперь мы сделаем так, чтобы объект Memo1 всегда охватывал собою всю форму. Для этого в инспекторе объектов измените его свойство Align (что значит «выравнивание») на alClient. Результат будет такой, как показано на следующем рисунке.

5. Теперь в инспекторе объектов (по-прежнему для компонента Memo1) найдите свойство Lines (что значит «строки»). Оно имеет тип TStrings. Когда вы его выделите, справа от слова TStrings появится кнопочка с троеточием.

6. Нажмите эту кнопочку, и откроется встроенный текстовый редактор. Сотрите имеющийся в нем текст «Memo1» и напишите все, что сочтете нужным. Вас не должно смущать, что текст, который вы пишете, образует длинную строчку, длиннее, чем само окно текстового редактора. Не надо искусственно делить его на более короткие строки — компьютер сделает это за вас. Клавишу Enter следует нажимать только в конце абзаца. По окончании ввода текста нажмите кнопку ОК.

Текст показывается с автоматическим переносом слов на новую строку благодаря тому, что установлено свойство Word Wrap (перенос по словам). Если значение этого свойства true (истина), то текст будет автоматически переноситься, если false (ложь) — не будет.

7. Сохраните проект и запустите программу. Убедитесь, что введенный вами текст появляется. Правда, его можно изменять, но если программу закрыть, а потом запустить снова, то изменения исчезают и восстанавливается первоначальный текст. Впрочем, если вы хотите, чтобы ваш ReadMe вообще нельзя было изменить, даже временно, это тоже можно сделать. Остановите программу (то есть вернитесь в режим редактирования проекта, когда видно окно инспектора объектов). Измените у объекта Memo1 свойство Read Only (только читать) на true (истина). Для этого выделите это свойство в инспекторе объектов, нажмите появившуюся справа кнопочку со стрелкой и выберите из открывшегося списка слово true. Снова сохраните и запустите программу. Убедитесь, что теперь текст редактировать не получается.

Напомним, что результатом работы программы является файл Project1.exe, который находится в папке «Пример 3». Скопируйте или перенесите этот файл туда, куда вам нужно (на рабочий стол, на дискету и т. п.). Файл можно переименовать в ReadMe.exe или еще как-нибудь, на ваш вкус. Для этого надо найти файл в «Проводнике» Windows или с помощью какого-то другого средства работы с файлами, щелкнуть по его ярлыку правой клавишей мыши и в появившемся контекстном меню выбрать пункт «Переименовать».

Домашнее задание

  • Напишите указанным выше способом программу, допустим, с поздравлением кому-то из ваших друзей или родных с днем рождения (или с 23 февраля, или с 8 марта). В следующих статьях цикла мы покажем, как использовать в таких поздравлениях рисунки, звуки и видео.
Илон Маск рекомендует:  Asp краткий справочник по объектам asp
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL
Types Ranges