PRAKTISKO DARBU UZDEVUMU...используется для хранения информации о формах и модулях. В нем содержатся операторы

"Mācību centra Riman sākotnējās profesionālās izglītības programmu

īstenošanas kvalitātes uzlabošana un īstenošana"

Līgums Nr. 2010/0104/1DP/1.2.1.1.3/09/APIA/VIAA/021

IEGULDĪJUMS TAVĀ NAKOTNĒ!

PRAKTISKO DARBU UZDEVUMU

KRĀJUMS PROGRAMMĒŠANĀ

DELPHI programmēšanas vides apgūvei

Rīga 2012

Praktisko darbu uzdevumu krājums programmēšanā 2

ESF projekts Nr. 2010/0104/1DP/1.2.1.1.3/09/APIA/VIAA/021

Anotācija

Metodiskā izstrādne "Praktisko darbu uzdevumu krājums programmēšanā"

Metodiskais materiāls paredzēts izmantošanai praktiskajās nodarbībās programmējot DELPHI vidē. Metodiskās izstrādnes saturs veidots saskaņā ar mācību programmu priekšmetam "Programmēšanas pamati" profesionālās vidējās izglītības programmā "Datorsistēmas".

Darbā iekļautas 14 uzdevumu tēmas, kas aptver pamata un visbiežāk izmantojamās programmēšanas DELPHI iespējas.

Darbs veidots ar mērķi:

nostiprināt teorētiskās zināšanas praktiskajā darbā lai tās varētu tikt

izmantotas kā instruments patstāvīgai programmēšanas DELPHI vidē

iespēju apgūšanai.

veicināt izdomu dažādu lietišķu programmu veidošanā, kā arī loģiskās

domāšanas attīstību, kas var tikt izmantots kā papildrīks savas komerciālās

darbības attīstībai..

Darbā katras noteiktas tēmas apgūvei ir dots uzdevums, kurā ir norādīta detalizēta darba izpildes secība, nepieciešamie programmrīki un funkcijas.

Metodiskā materiālā ir iekļauti izmantojamo programmas elementu jēdzieni un teorētiskie apskati, programmbloku veidošanas apraksti un pieejas uzdevumu risinājumi, praktiskie paņēmieni, t.sk. matemātisko aprēķiņu izpildes piemēri, vairāku atzarojumu lietošanas algoritmi, teksta un grafikas apstrādes piemēri, kā arī daudz citu komponenšu izmantošanas varianti un programmēšanas iespējas.

Katrā tēmā ir iekļauti papilduzdevumi paškontrolei un katra darba sadaļas nobeigumā pievienota veidlapa ar kontroljautājumiem.

Izstrādāja: Inessa Prokofjeva — profesionālās vidusskolas "RIMAN" nodaļas vadītāja.



ОГЛАВЛЕНИЕ

Вступление ............................................................................................................................. 7

Основные сведения ................................................................................................................... 8

Структура и описание элементов окна Delphi ...................................................... 8

Файлы проекта Delphi ...................................................................................................... 10

Структура главного файла программы и модулей .......................................... 13

Структура файла проекта ......................................................................................... 13

Структура файла модуля ........................................................................................... 13

Компиляция и анализ ошибок .................................................................................... 14

Понятие алгоритма ........................................................................................................... 16

Элементарная грамматика языка Object Pascal ................................................. 17

Алфавит языка ................................................................................................................ 17

Идентификаторы ........................................................................................................... 18

Комментарии ................................................................................................................... 18

Переменные ........................................................................................................................... 19

Основные элементы языка программирования Object Pascal................... 20

События ................................................................................................................................... 21

Свойства компонентов .................................................................................................... 23

Первая программа .............................................................................................................. 24

Типы данных ......................................................................................................................... 27

Целочисленные типы .................................................................................................. 28

Вещественные типы .................................................................................................... 28

Символьные типы ......................................................................................................... 29

Логический тип ............................................................................................................... 31

Функции преобразования данных ............................................................................ 31

Контрольные вопросы по теме "Основные сведения" .................................. 32



Практические задания .......................................................................................................... 35

Тема 1. Поиграем с цветом ......................................................................................... 36

Тема 2. Crazy Button, или Игра в "Кошки-мышки"......................................... 42

Cамостоятельная работа к заданию "Crazy Button, или Игра в "Кошки-мышки"" ............................................................................................ 48

Тема 3. Удивительные приключения букв и слов ........................................ 53

Тема 4. Секреты от всей планеты ........................................................................... 64

Cамостоятельная работа к заданию "Секреты от всей планеты" ..... 71

Тема 5. Калейдоскоп огней......................................................................................... 75

Тема 6. Что за чудо эти циклы! ................................................................................ 79

Cамостоятельная работа к заданию "Что за чудо эти циклы!" .......... 87

Тема 7. Конвертер Dec Hex .................................................................................... 99

Cамостоятельная работа к заданию "Конвертер Dec Hex" ............ 106

Тема 8. Надежное программирование .............................................................. 110

Тема 9. Самодельный калькулятор .................................................................... 116

Cамостоятельная работа к заданию "Самодельный калькулятор" ............................................................................... 128

Тема 10. Вызываю на диалог! ................................................................................... 129

Тема 11. Текстовый редактор своими руками!............................................... 141

Cамостоятельная работа к заданию "Текстовый редактор своими руками!" ......................................................... 163

Тема 12. Графические приемы Delphi .................................................................. 168

Cамостоятельная работа к заданию "Графические приемы Delphi" ............................................................................. 184

Тема 13. Веселые шутки, или Почему "замер" Desktop? ............................ 189

Тема 14. Великий Хранитель, или как "рождается" ScreenSaver .......... 192

Вопросы и задачи по теме "Практические задания" ................................... 195

Тестовые вопросы ........................................................................................................... 199

Использованные источники........................................................................................... 204

Основные элементы схем алгоритма ..................................... 205 Приложение 1.



Значения свойства Kind компонента TBitBtn ..................... 207 Приложение 2.

Кодировка символов в Windows ................................................ 208 Приложение 3.

Таблица виртуальных кодов клавиш Windows Приложение 4.(VirtualKeyCodes) ................................................................................ 210

Часто используемые классы Приложение 5.исключительных ситуаций .......................................................... 212

Параметры свойства Options компонентов Приложение 6.палитры Dialogs ................................................................................... 214

Горячие клавиши Delphi ................................................................. 217 Приложение 7.



Целью данной работы является рассмотрение основ и приемов программирования в среде Delphi.

"Новичкам" лучше всего начинать изучение основ программирования именно с Delphi, т.к. он достаточно прост в изучении, кроме того, отлично развивает логическое мышление.

Навыки программирования мы будем осваивать на базе версии Delphi 7, которая является наиболее стабильной версий языка и предназначена для создания программ под Win32, – т.е. 32-разрядных версий Windows. Существуют более новые версии Delphi, но они ориентированны на технологию .NET, за которую на начальном этапе изучения браться не стоит.



ВСТУПЛЕНИЕ

Большинство программ Windows при их активации "рисуют" свое окно, меню, панели управления, могут открыть и показать логотип или текст, хранящийся в заданном файле, а дальше, как правило, они ожидают команд или действий пользователя (например, нажатия какой-либо кнопки, выбора пункта меню, щелчка мышкой), т.е. для дальнейшей работы программе необходимо возникновение какого-либо события.

Совместно с понятием "событийное программирование" используется термин визуальное программирование1 или технология RAD (Rapid Application Development – быстрая разработка приложений).

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

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

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

Процедуру разработки интерфейса средствами RAD можно описать последовательностью следующих операций:

выбор и размещение компонентов интерфейса;

определение времени их появления на экране;

задание свойств и событий.

1 Визуальное программирование – способ создания приложений без написания

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



ОСНОВНЫЕ СВЕДЕНИЯ

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

Благодаря визуальному программированию, а также достаточно большой библиотеке визуальных компонентов (Visual Component Library1 – VCL), Delphi позволяет создавать программы быстро и эффек-тивно, принимая на себя основную работу и оставляя программисту творческий процесс.

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

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

Форма (Form) – это объект, который представляет собой окно программы.

СТРУКТУРА И ОПИСАНИЕ ЭЛЕМЕНТОВ ОКНА DELPHI

Итак, после запуска Delphi мы видим:

1 – Главное окно среды Delphi. Здесь находится основное меню, различные панели инструментов и палитра компонентов, состоящая из множества закладок.

2 – Окно Object TreeView (Дерево объектов), в котором отображается список используемых объектов и какой именно объект в данный момент является текущим. Ценность этого окна вы оцените, когда на форме появится множество компонентов.

1 Библиотека визуальных компонентов — объектно-ориентированная библиотека для

разработки программного обеспечения, разработанная компанией Borland. VCL включает огромное количество готовых к использованию компонентов для работы в самых разных областях программирования. VCL входит в комплект поставки Delphi, C++ Builder и Borland Developer Studio и является частью среды разработки, хотя разработка приложений возможна и без использования VCL.



3 – Окно Object Inspector (Инспектор Объектов), предназначенное для управления объектами проекта и состоящее из двух закладок: Properties (Свойства) и Events (События).

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



5 – Редактор кода. В окне отображается исходный код программы, который создан самой Delphi. Здесь же мы будем писать наш собственный код.

Для быстрого и более удобного переключения между окнами Конструктора формы и Редактора кода используется клавиша F12.

ФАЙЛЫ ПРОЕКТА DELPHI

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

При первом сохранении проекта в меню File надо обязательно выбрать команду Save Project As.

Сохранение проекта с помощью Save Project As происходит следующим образом:

Сначала на экран выводится окно диалога Save Unit As…; при этом

Delphi предлагает сохранить модуль формы под именем Unit1.pas в

системной папке Program Files/Borland/Delphi7/Projects. Изменять

предлагаемое имя модуля необязательно, но желательно, т.к. гораздо

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

формы будет указывать на назначение этой формы. Кроме того,



сохранять файлы проекта настоятельно рекомендуется в

специально отведенной для этого проекта папке.

После нажатия кнопки Save выдается очередное окно Save Project As…,

в котором предлагается сохранить проект под именем Project1.dpr в

выбранной для проекта папке. По завершении сохранения главное

окно изменит своё название на то, под которым был сохранен проект,

а окно редактора кода и заголовок модуля – на то, под которым был

сохранен модуль.

Внимание!

Самой распространенной ошибкой "новичков" является использование команд File Save или Save As… для первого сохранения проекта. При выборе одной из этих команд все файлы сохраняются, но не в качестве проекта. Команду Save можно использовать для очередного сохранения уже существующего проекта.

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

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

Имя файла не должно начинаться с цифры.

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



Итак, проект Delphi состоит из следующего набора файлов:

Файл проекта (*.dpr, Delphi PRoject) – текстовый файл, который

используется для хранения информации о формах и модулях. В нем

содержатся операторы инициализации и запуска программы на

выполнение.

Файл модуля (*.pas, PAScal) – текстовый файл, хранящий код

программы.

Файл формы (*.dfm, Delphi Form File) – двоичный файл, который

создается для хранения информации о форме. Содержимое файла

можно увидеть в виде текста, открыв его в Notepad.

Файл скомпилированного кода (*.dcu, Delphi Compiled Unit)

является результатом компиляции кода (файла ".pas").

Файл опций (настроек) проекта (*.dof, Delphi Options File) –

текстовый файл, содержащий текущие параметры компиляции и

сборки проекта.

Файл конфигурации проекта (*.cfg, ConFiGuration), который

содержит параметры проекта, аналог файлов ".dof".

Файл ресурсов (*.res, RESource) – двоичный файл ресурсов

программы, таких как картинки, иконки и прочее.

Резервные копии файлов (*.~dpr, *.~dfm, *.~pas) содержат

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

процессе работы над проектом.



СТРУКТУРА ГЛАВНОГО ФАЙЛА ПРОГРАММЫ И МОДУЛЕЙ

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

Структура файла проекта

Структура файла проекта (*.dpr) имеет следующий вид:

Program <имя>; // Заголовок программы

Uses ... // Объявления подключаемых модулей

{объявления локальных для головного файла типов, классов, констант, переменных, описания локальных функций и переменных}

begin

... {операторы тела программы}

end.

Структура файла модуля

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

unit <имя модуля>;

interface // Открытый интерфейс модуля

uses // Раздел, куда помещаются списки подключаемых модулей

type // Раздел объявления типов, констант, переменных, функций и процедур

private // Раздел, в котором описываются "закрытые" данные, доступ-ные только в рамках данного модуля

public // Раздел, описывающий данные, к которым разрешен доступ из других модулей.

end;

var // Раздел объявления глобальных переменных модуля (подробнее о переменных см. в главе "Error! Reference source not found.").



implementation

{$R *.dfm} { директива компилятору о подключение визуальных объектов }

{Реализация модуля, т.е. собственно код программы, определяющий выполнение каких-либо действий}

end.

КОМПИЛЯЦИЯ И АНАЛИЗ ОШИБОК

Компиляция – это процесс преобразования исходного текста программы в исполняемый файл. Процесс компиляции состоит из двух этапов. На первом этапе выполняется проверка текста программы на отсутствие ошибок в коде, на втором – генерируется файл "*.exe". Программа, которая "переводит" команды непосредственно в машинные коды назвается компилятором.

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

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

1 Построчное выполнение программы необходимо для отладки ПО и при выявлении

ошибок.



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

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

Внимание!

Самой распространенной ошибкой является отсутствие символа ";" в конце команды. При обнаружении такой ошибки компилятор выдает следующее сообщение:

Missing operator or semicolon

(Отсутствует оператор или точка с запятой)

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

Запустить процесс компиляции можно, выбрав в меню Project команду Compile … (Ctrl+F9); либо выполнив пробный запуск программы непосредственно из Delphi с помощью команды Run (F9) из меню Run или кнопки Run на панели инструментов Debug.



ПОНЯТИЕ АЛГОРИТМА

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

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

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

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

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

Основные элементы блок-схем алгоритма приведены в Приложении 1.

Звонит будильник

Человек просыпается

Встает с постели

Умывается Одевается Готовит завтрак

Завтракает Выходит из дома

Едет на работу



Ниже схематично показаны примеры блок-схем алгоритма:

ЭЛЕМЕНТАРНАЯ ГРАММАТИКА ЯЗЫКА OBJECT PASCAL

Алфавит языка

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

a b c d e f g h i j k l m n o p q r s t u v w x y z

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z _

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

0 1 2 3 4 5 6 7 8 9

Специальные символы:

+ – * / = < > [ ] , . : ; ' ( ) { } @ # $ & ^

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

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

< > < = > = . . (. .) (* *) // :=

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



Программный код на языке Object Pascal записывается с помощью символов латинского алфавита, цифр и некоторых символов. Строчные и ПРОПИСНЫЕ буквы различаются только в строковых выражениях, но не в отношении имен классов, переменных, функций и т.д.

Идентификаторы

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

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

Примеры:

Xi, D3, _23, A_code; //допустимые имена

2W, 34, @E; //недопустимые имена

Комментарии

Комментарии отделяются от текста программы тремя способами:

1) символами "//", как в приведенном примере (таким образом обычно определяется короткий комментарий, находящийся на одной строке с программным кодом);

2) заключаются в фигурные скобки – { комментарий }; в фигурные скобки могут заключаться необязательные для исполнения фрагменты программного кода или многострочные комментарии;

3) большой текстовой фрагмент комментария также можно помещать между сочетаниями символов "(*" и "*)".

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

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

Но существует единственное исключение: если сразу после фигурной скобки стоит символ "$", то это – директива компилятора, например, {$I+}.



Директивы компилятора – это указания компилятору на выполнение тех или иных операций. Записываются в формате:

{$<директива>}

По области действия различаются:

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

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

ПЕРЕМЕННЫЕ

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

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

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

объявление переменной, т.е. указание её имени и типа в специальном разделе VAR2 (более подробно рассмотрим далее);

присвоение переменной какого-то значения.

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

1 В языках программирования вещественным называют число, у которого есть запятая,

после которой имеются цифры, хотя бы нули, например, "125,00" или "348,24". 2 VAR – сокрашение от слова variable (переменная).



переменным в Delphi даются по определенным правилам (см. Идентификаторы).

В Delphi нет разницы, какими буквами записывается имя переменной, – большими или маленькими, т.е. "myparam", "MyParam", "MYPARAM" –воспринимаются как одна и та же переменная.

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

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

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

имя переменной := значение переменной;

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

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

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

ОСНОВНЫЕ ЭЛЕМЕНТЫ ЯЗЫКА ПРОГРАММИРОВАНИЯ OBJECT PASCAL

Основными элементами любого языка программирования высокого уровня являются список служебных (зарезервированных) слов и определенные правила записи операторов и операндов.

Зарезервированные слова – это, в основном, операторы, инструкции и элементы структурирования программы.

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



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

ПРАВИЛА:

1) Зарезервированные слова не могут быть использованы в качестве имен переменных, процедур, функций.

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

2) Каждая логически завершенная строка программного кода (она не обязательно должна располагаться физически в одну строку, –разрешен и перенос) завершается символом ";".

3) Если требуется логически выделить несколько операторов в единую структуру (группу), то используются специальные операторные скобки – begin <группа операторов> end.

СОБЫТИЯ

Событие – это реакция компонента на определённое воздействие. "Событийное" программирование – неотъемлемая черта Windows.

Объекты из библиотеки визуальных компонент (VCL) Delphi имеют свой набор свойств и характерное для них поведение, т.е. набор откликов на события, происходящие с ними. Список событий для каждого компонента можно посмотреть в окне Object Inspector (Инспекторе Объектов) на странице Events (События). Например, OnDblClick соответствует двойному щелчку мыши, а OnKeyUp - событию, когда нажатая клавиша была отпущена, и т.д. Поведение компонента определяется тем, какие обработчики и для каких событий он имеет. Создание приложения в Delphi состоит из настройки свойств используемых компонентов и создания обработчиков событий.

Предположим, что мы хотим перехватить щелчок левой кнопки мыши на форме. Создадим новый проект, в окне Object Inspector выберем страницу Events и сделаем двойной щелчок в правой части строки OnClick. В результате мы получим заготовку для обработчика данного события:



В общем случае это выглядит следующим образом:

Предположим, что по щелчку мыши в любой точке формы на экран должно выводиться сообщение пользователю со следующим текстом: "You have clicked on the form!", тогда в заготовке обработчика события OnClick между строк begin и end запишем такую команду:

Пользователь нажал на кнопку мыши

Windows генерирует событие щелчка – Click

Приложение обрабатывает это событие



После этого нажмем клавишу F9 (Run) и в запущенном приложении на форме сделаем щелчок левой кнопки мыши. В результате на экране возникнет окно:

СВОЙСТВА КОМПОНЕНТОВ

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

Существует несколько типов свойств в зависимости от их "внутреннего" устройства:

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

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

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

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



ПЕРВАЯ ПРОГРАММА

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

Предлагаемая последовательность действий:

1 – Открыть новое приложение и на форме расположить следующие компоненты: Button1, Label1 (палитра Standard) и BitBtn1 (палитра Additional).

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



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

BitBtn1 – это пиктографическая кнопка, один из вариантов стандартной кнопки, на поверхности которой может отображаться не только надпись, но и изображение, – задаётся свойством Glyph. Расположение изображения и надписи на кнопке определяется свойствами Margin, Layout и Spacing. Готовые изображения, которые можно размещать на кнопках BitBtn, по умолчанию располагаются:

C:\Program Files\Common Files\Borland Shared\Images\Buttons.

Свойство Kind определяет тип кнопки. По умолчанию значение этого свойства равно bkCustom, но можно выбрать и другой вид из множества предопределенных типов: bkOK, bkCancel, bkYes, bkNo, bkAll, bkAbort, bkRetry, bkIgnore, bkHelp, bkClose. Подробное описание типов кнопки BitBtn приведено в таблице Значения свойства Kind компонента TBitBtn (см. Приложение 2).

2 – Для каждого из этих компонентов задать значения следующих свойств на страничке Properties окна Object Inspector:

Компонент Свойство Значение

Label1 AutoSize False

Height 20

Width 250

Font : – Name MS Sans Serif

– Style Regular

– Size 10

Button1 Name BtnColor

Caption Change Color

BitBtn1 Name BtnClose

Kind bkClose

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



В результате получим:

3 – На событие OnClick кнопки BtnColor создать заготовку процедуры обработчика и прописать следующую команду:

1.

– clBlack

2.

– clMaroon

3.

– clGreen

4.

– clOlive

5.

– clNavy

6.

– clPurple

7.

– clTeal

8.

– clGray

9.

– clSilver

10.

– clRed

11.

– clLime

12.

– clYellow

13.

– clBlue

14.

– clFuchsia

15.

– clAqua

16.

– clWhite

17.

– clMoneyGreen

18.

– clSkyBlue

19.

– clCream

20.

– clMedGray

4 – Сохранить проект в отдельную папку My1stProject и нажать F9 (Run). При щелчке по кнопке Change Color у компонента Label1 изменится цвет на Lime.



5 – В процедуру TForm1.BtnColorClick добавить еще одну команду для вывода на Label1 информации о названии цвета:

Label1.Caption:= 'Color name is ' +

ColorToString(Label1.Color);

где

Label1.Caption – свойство, на которое выводится текстовая строка 'Color name is clLime';

'Color name is ' – строковая константа;

ColorToString() – функция, преобразовывающая в текстовую строку значение цвета, установленного для Label1.

ТИПЫ ДАННЫХ

Для ввода и вывода данных в среде Delphi предусмотрены различные компоненты, например: Edit, LabeledEdit, Memo, RichEdit, ListBox, ComboBox, StringGrid, CheckBox, RadioGroup, RadioButton и др.

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

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



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

Целочисленные типы

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

Вещественные типы

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

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

Тип Диапазон Формат

Shortint –128 … 127 1 byte (8 битов)

Byte 0 … 255 1 byte (8 битов), беззнаковый

Smallint –32 768 … 32 767 2 bytes (16 битов)

Word 0 … 65 535 2 bytes (16 битов), беззнаковый

Integer или Longint

–2 147 483 648 … 2 147 483 647 4 bytes (32 бита)

Cardinal или Longword

0 … 4294967295 4 bytes (32 бита), беззнаковый

Int64 –263 … 263 –1 8 bytes (64 бита)



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

Внимание!

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

Символьные типы

Символьные типы предназначены для работы либо с отдельными символами, либо текстовыми строками, представляющими собой цепочку из отдельных символов. Символ – это один знак. Это может быть буква, цифра, пробел, знак препинания или знак арифметической операции, а также специальные символы: знак $ или %, переход на новую строку, Enter, Backspace, Esc и др. Тип "Символ" в Delphi обозначается зарезервированным словом Char.

Тип Диапазон Количество

значащих цифр Формат

Real48 2,9 x 10–39 ... 1,7 x 1038 11-12 6 bytes (48 бита)

Single 1,5 x 10–45 ... 3,4 x 1038 7-8 4 bytes (32 бита)

Real или Double

5,0 x 10–324 … 1,7 x 10308 15-16 8 bytes (64 бита)

Extended 3,6 x 10–4951 ... 1,1 x 104932 19-20 10 bytes (80 битов)

Comp –263+1 ... 263 –1 19-20 8 bytes (64 бита)

Currency –922337203685477,5808 … 922337203685477,5807

19-20 8 bytes (64 бита)



Всем символам соответствуют коды из таблицы символов ANSI1 или UNICODE2. Причем, большая буква "А" и маленькая "а" – разные символы, а значит, имеют различные коды! То же относится к латинской и русской "с", хотя они и выглядятодинаково.

Таблица кодировки символов в Windows приведена в Приложении 3.

Delphi поддерживает следующие символьные типы:

Внимание!

Строки в Delphi заключаются в одинарные кавычки (апострофы). Например,

ShowMessage('Unicode – это стандарт кодирования символов,

где каждому символу присваивается свой уникальный код');

Т.к. строка – это набор символов, то доступ к отдельному символу строки можно получить, указав после имени переменной порядковый номер нужного символа в квадратных скобках [ ]. Буквы в строках нумеруются, начиная c 1. Например, переменная S хранит текстовую строку 'Unicode – это стандарт'. Тогда запись S[9] будет соответствовать символу '–'.

1 ANSI (англ. аббревиатура "American National Standards Institute") – это 8-битовая таблица,

определяющая кодировку символов операционной системы Windows. В настоящее время используется ASCII.

2 Для того, чтобы удовлетворить всем национальным потребностям, ввели поддержку UNICODE (16-битная таблица). В ней первые 256 символов совпадают с ANSI, а остальные являются специфичными.

Тип Максимальная длина строки

Формат Примечание

ShortString или String

255 символов От 2 до 256 байтов

AnsiString ∼ 231 символов От 4 байтов до 2 Гбайт

8-битовые

WideString ∼ 230 символов От 4 байтов до 2 Гбайт

UNICODE



Логический тип

В Delphi логические переменные относят к типу Boolean. Логическая переменная может принимать одно из двух значений True (Истина) или False (Ложь). Переменная этого типа занимает в памяти 1 байт.

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

ФУНКЦИИ ПРЕОБРАЗОВАНИЯ ДАННЫХ

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

Функции преобразования наиболее часто используются при вводе и выводе информации. С одной из таких функций мы уже познакомились в главе Error! Reference source not found., – ColorToStr(…).

1 Тип TDateTime содержит значение даты и времени; сохраняется как переменная Double,

где дата (date) – целая часть, а время (time) – дробная.

Функция Назначение

StrToInt(S) Преобразует значение переменной S (строка) в целое число (тип Integer)

IntToStr(N) Преобразует целое число N в строку

StrToFloat(S) Преобразует значение переменной S (строка) в вещественное число

FloatToStr(N) Преобразует вещественное число N в строку

StrToCurr(S) Преобразует значение переменной S (строка) в денежное выражение

CurrToStr(C) Преобразует значение переменной С (тип Currency) в строку

StrToDate(S) Преобразует значение переменной S (строка) в дату (значение даты – тип TDateTime1)

DateToStr(D) Преобразует значение переменной D (дата) в строку

StrToTime(S) Преобразует значение переменной S (строка) в значение времени (тип TDateTime)

TimeToStr(T) Преобразует значение переменной T (время) в строку



КОНТРОЛЬНЫЕ ВОПРОСЫ ПО ТЕМЕ "ОСНОВНЫЕ СВЕДЕНИЯ"

1. Что собой представляет визуальная среда программирования Delphi?

2. Что такое компилятор?

3. Какие файлы создает среда Delphi в процессе проектирования приложения?

4. Какое расширение (type) соответствует:

a. файлу проекта приложения

b. файлу формы

c. файлу кода программы

5. Какая команда используется при первом сохранении файлов проекта? Что произойдёт, если главный файл проекта Project1.dpr сохранить под другим именем?

6. Можно ли переименовывать файлы модулей, входящие в проект, средствами операционной системы?

7. Для чего используется Object TreeView? Для чего предназначен Object Inspector и как им пользоваться?

8. Для каких целей в программе используются переменные. Чем отличаются глобальные и локальные переменные.

9. Укажите способы добавления комментариев в код программы.

10. Как добавить на форму нужный компонент, если Вы не знаете, на какой палитре (странице) компонентов он расположен?

11. Напишите операторы математических действий в порядке убывания приоритета их выполнения.

12. Перечислите известные Вам целочисленные типы.

13. Чем отличаются вещественные числа от целых?

14. Что такое визуальные и невизуальные компоненты? Приведите примеры свойств, общих для всех визуальных компонентов.

15. Чем отличается компонент BitBtn от Button?



16. К какому типу данных относится свойство:

a. Form1.Caption

b. Label1.Width

c. Button1.Visible

17. Где применяется логический (Булевый) тип данных? Сколько места в памяти отводится под переменные булевого типа? Какие значения она может принимать?

18. Какое из перечисленных имен нельзя использовать в качестве имени переменной?

a. AZ

b. A1

c. 1A

d. constant

19. Какой тип подходит для данных диапазона:

a. –45 .. 40

b. 10 .. 65000

c. 6 .. 90

d. –300 .. 1000

20. Какие из следующих утверждений правильны:

a. для диапазона 1 .. 260 лучше всего подходит тип Byte;

b. для диапазона 'a' .. 'z' лучше всего подходит тип Char;

c. для диапазона 0 .. 75000 лучше всего подходит тип Word;

d. для вещественных переменных обычно применяется тип Real;

21. Какое свойство делает компонент невидимым? Как можно изменить значение этого свойства программно?



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

23. Какие из следующих выражений неправильны:

a. для объявления переменных используется ключевое слово var

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

c. приоритет операции * выше, чем у ^

24. Что такое зарезервированные слова языка программирования? Перечислите определенные правила записи операторов в программном коде.

25. Как в Delphi можно задать оттенок цвета для свойства Color? Какого типа значения могут присвоены этому свойству?

26. Как "превратить" цифры-символы в числовую переменную? Напишите примеры преобразования символьной строки в целое или вещественное число.

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



ПРАКТИЧЕСКИЕ ЗАДАНИЯ



Тема 1. ПОИГРАЕМ С ЦВЕТОМ

Откроем новый проект. На форме расположим компоненты Button1, Memo1 (палитра Standard) и Shape1 (палитра Additional).

Компонент Memo используется для ввода и редактирования многострочного текста. На его основе можно создать текстовый редактор, аналогичный Notepad. При работе с Memo можно использовать типичные для приложений Windows комбинации "горячих" клавиш.

Shape условно можно отнести к средствам отображения графики, т.к. он представляет собой геометрическую фигуру, форма которой определяется свойством Shape: stRectangle (прямоугольник), stRoundRect (прямоугольник со скругленными углами), stEllipse (эллипс), stCircle (круг), stSquare (квадрат), stRoundSquare (квадрат со скругленными углами).


1 – Программно, на событие формы OnActivate, задать новые значения свойств для компонентов:

Button1: Caption = 'Change Color'; Font.Style = [fsBold]. Form1: Caption – в заголовок вывести текущую дату. Memo1 очистить от стандартного текста.

2 – При нажатии кнопки цвет заполнения компонента Shape1 должен меняться произвольным образом в рамках цветовой модели RGB



(количество оттенков – 224 = 16 777 216). При этом обозначение оттенка в шестнадцатеричном виде выводится на отдельную строку в Memo1.

Для получения случайных значений в заданном диапазоне предназначена функция random(). Пример использования и пояснения см. в приведенном коде ниже.

3 – Сохраним проект в отдельной папке ChangingColor: файл проекта как Pro_ChangeColor.dpr, файл кода – ChangeColor.pas.

Запустим программу (F9) и понажимаем на кнопку Change Color. В результате этого цвет компонента Shape1 будет меняться случайным образом, а в Memo1 после каждого нажатия будет добавляться новая строка с шестнадцатеричным представлением имени "выпавшего" цвета.



4 – Теперь усложним задачу: сделаем так, чтобы цвет заполнения компонента Shape1 изменялся произвольным образом без нажатия на Button1.

Для этого добавим компонент Timer1 (палитра System) и изменим "роль" кнопки. Теперь при нажатии на Button1 мы будет либо включать, либо останавливать выполнение процедуры изменения цвета Shape1.

Timer (Таймер) – невизуальный компонент, который можно размещать в любом месте формы. Он имеет два свойства, позволяющие им управлять:

Interval – интервал времени в миллисекундах (1000 ms = 1 s),

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

Enabled – доступность.

Если задать Interval = 0 или Enabled = false, то таймер перестает работать.

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

5 – Создадим для Timer1 заготовку процедуры обработчика события OnTimer и перенесем в нее команды из процедуры на Button1Click.

6 – В процедуре на Form1Activate тоже будут изменения:



Надпись на кнопке (Change Color) теперь будет меняться в зависимости от того, остановлено выполнение процедуры – "Play" или нет, –"Stop".

Глобальной переменной yn (сокр. от YesNo), предварительно объявленной как Boolean, на момент активизации окна формы будет присвоено значение False, что означает приостановку выполнения команд, изменяющих цвет Shape1 и добавляющих строку с именем цвета в Memo1.

Начальное состояние компонента Timer1 – недоступен (свойство Enabled = False).

7 – Процедура обработки события Button1Click будет выполнять роль переключателя:

если значение переменной yn = True, то надпись на Button1 меняется на 'Play', значение самой переменной yn – на False, а Timer1 недоступен (Enabled = False);

если значение переменной yn = False, то надпись на Button1 меняется 'Stop', значение переменная yn = True, а Timer1 доступен (Enabled = True).

Для реализации этого алгоритма используем условный оператор IF.



Условный оператор IF позволяет проверить заданное условие и, в зависимости от результатов проверки, выполнить ту или иную последовательность действий. С помощью условного оператора реализуется ветвление алгоритма. Именно он явялется основной конструкцией, на которой строится логика программы.

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

if <условие> then <оператор(-ы)1> else <оператор(-ы)2>;

где if (если), then (то), else (иначе) - зарезервированные слова;

<условие> – произвольное выражение логического типа;

<оператор1>, <оператор2> – выполняемые действия.

Условный оператор работает по следующему алгоритму:

вычисляется условное выражение <условие>;

если результат True (истина), то выполняется <оператор1>,

а <оператор2> пропускается;

если результат False (ложь), то <оператор1> пропускается,

а выполняется <оператор2>.

Например, …

if x <> 0 then y := 1 else y :=2;

или if a > 5 then

begin

b := 10;

c := 20;

end;

Если требуется предусмотреть большее количество ветвлений, используют вложенные друг в друга операторы IF. Например, если требуется выполнить один вариант, когда переменная x меньше нуля, другой – если x равна 0, и третий, – если x больше нуля, то операторы IF можно записать следующим образом:

…

if x < 0 then <операторы для x<0>

else

if x = 0 then < операторы для x=0>

else < операторы для x>0>;



Сохраним изменения в проекте командой Save All (Ctrl+S) и запустим программу. В результате на экране возникнет окно приложения (1), в котором кнопка будет иметь надпись Play, но ничего происходить не будет до тех пор, пока пользователь не нажмет на кнопку. После этого надпись на кнопке измениться на Stop, а процесс изменения цвета компонента Shape будет запущен (2).

2

1



Тема 2. CRAZY BUTTON, ИЛИ ИГРА В "КОШКИ-МЫШКИ"

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

Для большинства компонентов их положение на форме задается с помощью свойств Left и Top.

Свойство Left указывает (в пикселях) положение компонента от левой границы формы. Если изменять это значение, то компонент будет перемещаться по горизонтали. Значение "0" соответствует положению у левой кромки формы.

Top определяет положение кнопки от верхней границы формы. Если его поменять, то компонент переместится по вертикали. Значение "0" соответствует положению у верхнего края формы (сразу под заголовком).

Свойство Name определяет имя компонента. Рекомендуется изменять его у всех компонентов, особенно если форма содержит множеством различных компонентов. Например, очень сложно определить в редакторе кода, для чего предназначена кнопка Button1 или Button9. Поэтому лучше давать кнопкам осмысленные названия, – btnSave или btnClose, где первые буквы btn говорят о том, что это – кнопка, а продолжение после btn, – для чего она предназначена.

Отдельно рассмотрим некоторые СВОЙСТВА ФОРМЫ.

BorderStyle – определяет общий вид формы. Может принимать следующие значения:

BsSizeable (установлено по умолчанию) – стандартное окно, которое может менять свои размеры.

BsSingle – стандартное окно, у котрого нельзя менять размеры.

BsDialog – окно в форме диалога, т.е. вместо стандартных

кнопок имеет только кнопку .

BsNone – окно вообще без кромки и без заголовка.

BsSizeToolWin – окно с тонкой кромкой (особенно это заметно в области заголовка окна).

BsToolWindow – такое же, как BsSizeToolWin, но без возможности менять размеры.



BorderWidth – ширина кромки окна (по умолчанию = 0). Color – цвет рабочей области окна. Поэкспериментировать с

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

Cursor – вид курсора мыши; определяет, как будет выглядеть курсор при наведении на форму.

Font – выбор шрифта по умолчанию; если заранее изменить параметры шрифта, то все компоненты, распологаемые на форме, по умолчанию будут иметь такие же параметры.

Height – высота окна (в пикселях), включая высоту области заголовка.

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

Width – ширина окна (в пикселях). ClientWidth – задает ширину рабочей (клиентской) области

формы за вычетом вертикальной линейки прокрутки (если таковая используется) и ширины кромки окна.

Icon – иконка в заголовке окна. По умолчанию установлена стандартная иконка Delphi 7, но можно использовать и свою собственную. Чаще всего берется иконка из коллекций, выложенных в Интернете, но можно создать иконку для проекта самостоятельно с помощью встроенной утилиты Image Editor (находится там же, где Delphi).

Name – имя формы; имя главной формы желательно всегда указывать одинаково, например, fmMain.

Position – расположение окна; может принимать одно из следующих значений:

PoDefault – Windows самостоятельно определяет место окна приложения на экране и его размеры.

PoDefaultPosOnly – Windows задает только расположение окна, размеры останутся такими, какие были при разработке.

PoDefaultSizeOnly – позиция окна сохранится такой, как указано разработчиком, но размеры окна устанавливает Windows.

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



PoDesktopCenter – окно будет всегда располагаться в центре рабочего стола; следует учесть, что при подключении двух мониторов в режиме расширения рабочего стола окно приложения окажется ровно на стыке двух мониторов.

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

PoMainFormCenter (используют для дочерних окон) – окно всегда будет появляться по центру главной формы.

PoOwnerFormCenter (для дочерних окон) – окно будет располагаться по центру того окна, из которого оно вызвано.

WindowState – определяет, как отображается форма после запуска (в обычном, свернутом или развернутом виде) –wsNormal, wsMaximized, wsMinimized.


1 – Открыть новый проект. На форме расположить только один компонент – Button1.

2 – С помощью Object Inspector задать новые значения свойств для компонентов:

Button1: Name = BtnClick; Left = 200; Top = 200; Height = 25; Width = 100; Caption = 'Click Me!'; Font: Style = [fsBold], Font.Size = 10.

Form1: BorderStyle = bsSingle; Position = PoScreenCenter;

ClientWidth = 500; ClientHeight = 450; Icon misterwong.ico или любой другой файл *.ico (щелкнуть в строке по , в окне Picture Editor нажать кнопку Load и выбрать файл).

3 – Выбрать для Button1 событие OnMouseMove, которое происходит каждый раз, когда курсор мыши оказывается над кнопкой. Двойным щелчком (в поле справа от названия события) создать заготовку процедуры и вписать следующие команды:

BtnClick.Left := BtnClick.Left + BtnClick.Width;

BtnClick.Top := BtnClick.Top + BtnClick.Height;

4 – Сохранить в отдельной папке файлы проекта: Pro_RunningButton.dpr и RunningButton.pas .



Запустив нашу крохотную программу, увидим, что при попытке навести курсор мыши на кнопку, кнопка "убегает" от курсора. Правда, в определенный момент свойства Left и Top кнопки принимают такие значения, что Button1 оказывается за границами окна формы.

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

BtnClick.Left:=random(Form1.ClientWidth - BtnClick.Width);

BtnClick.Top:=random(Form1.ClientHeight - BtnClick.Height);

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

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

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

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

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

OnKeyDown и OnKeyUp не "видят" различия между верхним и нижним регистром.

1 Фокус – способность получать пользовательский ввод через мышь или клавиатуру.

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



Есть еще одно отличие OnKeyDown и OnKeyUp от OnKeyPress: тип используемого параметра – Key. Это видно из заголовков процедур обработки каждого из событий:

procedure TForm1.FormKeyPress(Sender:TObject; var Key:Char);

…

procedure TForm1.FormKeyDown(Sender:TObject; var Key:Word;

Shift: TShiftState);

…

procedure TForm1.FormKeyUp(Sender:TObject; var Key:Word;

Shift: TShiftState);

В обработчике OnKeyPress параметр Key имеет тип Char и соответствует символу нажатой клавиши, а в обработчике OnKeyDown/OnKeyUp этот параметр имеет тип Word, т.е. это – число.

Кроме того, в обработчике процедур OnKeyDown/OnKeyUp есть дополнительный параметр – Shift, с помощью которого можно проверить, были ли нажаты клавиши Shift, Alt или Ctrl. Значения параметра Shift: ssShift, ssAlt, ssCtrl.

5 – Создать для Button1 обработчик события OnKeyUp и прописать в нем следующие команды:



С помощью оператора IF отслеживаем нажатие клавиши Enter, используя функцию ORD. Если Enter была нажата, то выводится сообщение пользователю с заданным текстом, а затем выполняется выход из процедуры – Exit.

Функция ORD() используется для получения кода ASCII для символа, указанного в скобках в качестве аргумента функции. Т.к. нас интересует клавиша Enter, то в качестве аргумента указываем ее ASCII-эквивалент – "#13" (код Enter в таблице ASCII = 13).

EXIT – одна из процедур управления ходом выполнения программы. Она прерывает выполнение текущей процедуры (функции) и передает управление на верхний уровень.



Cамостоятельная работа к заданию "Crazy Button, или Игра в "Кошки-мышки""

Эта работа предназначена для закрепления навыков работы со свойствами Left и Top различных компонентов. Для выполнения задания потребуется новый компонент– Image.

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

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

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

Метафайлы (Metafiles) хранят не последовательность битов, из которых состоит изображение, а информацию о способе создания картинки. Они хранят последовательности команд рисования, которые могут быть повторены при воссоздании изображения. Эти файлы более компактны по сравнению битовыми матрицами.

Компонент Image позволяет отображать информацию, содержащуюся в графических файлах всех указанных типов. Для этого служит его свойство Picture. Если установить свойство AutoSize = True, то размер компонента Image автоматически будет подгоняться под размер помещенной в него картинки.

Свойство Stretch позволяет подгонять не компонент под размер рисунка, а рисунок под размер компонента. Чтобы размеры рисунка изменялись пропорционально при Stretch = True, и изображение не искажалось, используйте свойство Proportional. Свойство Stretch не действует на изображения пиктограмм, которые не могут изменять своих размеров.

Свойство Center = True центрирует изображение, если размер компонента Image больше размера рисунка.




1 – Открыть новый проект и сохранить его в отдельную папку ShiftyEyes1: имя файла проекта – Pro_ShiftyEyes.dpr, имя файла модуля – ShiftyEyes.pas.

2 – На форме расположить следующие компоненты:

Shape – 5 шт. Timer – 1 шт. Image – 1 шт.

3 – Установить значения свойств для компонентов:

Form1: ClientHeight = 615, ClientWidth = 415. Image1: Height = 600, Width = 400, Picture = Load Kazak.jpg,

Proportional = True, Stretch = True.

Shape2: Shape = stCircle, Brush.Color = clBlue, Height = 33, Width = 33, Top = 168, Left = 168.

Shape3: Shape = stCircle, Height = 17, Width = 17, Top = 160, Left = 160.

Shape4: Shape = stCircle, Brush.Color = clBlue, Height = 33, Width = 33, Top = 168, Left = 224.

Shape5: Shape = stCircle, Height = 17, Width = 17, Top = 160, Left = 224.

1 ShiftyEyes (англ.) – бегающие глаза.



Shape1: Align = alClient. Чтобы изменить расположение компонента относительно предыдущих, в контекстном меню формы выбрать Control Send To Back.



4 – Сделать так, чтобы зрачки глаз (Shape3 и Shape5) этого казака "бегали" влево-вправо, а при щелчке по картинке – открывались или закрывались глаза; при этом цвет компонента Shape1 должен меняться произвольным образом.

Обязательно делаем установку начальных значений глобальных переменных на событие FormActivate (см. скиншот окна модуля кода).

На событие OnTimer прописываем команды перемещения компонентов Shape3 и Shape5.



В приведенном выше коде для целочисленного деления (при котором остаток от деления отбрасывается) использован оператор DIV.

Для того, чтобы "привязать" определенные действия к щелчку по картинке, для компонента Image1 выберем событие OnClick:



Тема 3. УДИВИТЕЛЬНЫЕ ПРИКЛЮЧЕНИЯ БУКВ И СЛОВ

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

Основные сведения о символьных и строковых типах данных изложены в главе Error! Reference source not found. на стр. Error! Bookmark not defined.. Для работы с отдельными символами в Delphi предусмотрен тип Char. Строка – это последовательность символов. Зарезервированное слово String используется как общий идентификатор строкового типа. При объявлении строк можно использовать такие инструкции:

var

Name1: String;

Name2: String [lenght]

{где:

Name1,Name2 – имя переменной;

string – ключевое слово обозначения строкового типа;

lenght – константа целого типа, которая задает

максимально допустимую длину строки}

Пример объявления переменных строкового типа:

var

student: string[30];

notes: string;

Если при объявлении переменной длина строки не указана, то в зависимости от директив компилятора тип String может интерпретироваться как ShortString или AnsiString:

{$H+} или {$LongStrings On}: String = AnsiString (default). {$H-} или {$LongStrings Off}: String = ShortString.

Если при определении типа String указана длина строки, напри-мер, String[x], то, вне зависимости от установок компилятора, это означает объявленная строка относится к типу ShortString длиной "x" символов.

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



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

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

s1 = 'Borland';

s2 = 'Delphi 7';

s3: = s1 + ' ' + s2;

{последняя команда выполняет операцию сложения строк

s1 и s2, добавляя между ними пробел,– в результате

чего образуется строка 'Borland Delphi 7'}

ФУНКЦИИ РАБОТЫ СО СТРОКАМИ

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

CONCAT ( S1, S2, S3 )

Описание: Возвращает последовательное соединение строк. Эквивалентна оператору S1 + S2 + S3

Пример: s1 := 'Студент:'; // s1, s2, s3, stud string

s2 := ' Громов Роман ';

s3 := '(1-й курс)';

stud := s1 + s2 + s3;

// результат – 'Студент: Громов Роман (1-й курс)'

LENGTH ( S )

Описание: Возвращает длину строки (количество символов)

Пример: s := 'Громов Роман'; // s string

s_len := Length (s ); // p byte или integer

// результат – 12 (все символы, включая пробелы)

POS ( S1, S )

Описание: Возвращает позицию первого вхождения подстроки S1 в строку S.

Пример: s := 'Громов Роман'; s1 := 'ом'; // s, s1 string



p := Pos ( s1, s ); // p byte или integer

// результат – 3 (позиция первого найденного 'ом')

COPY ( S, P, N )

Описание: Возвращает подстроку длиной N символов, начинающуюся в строке S с позиции P

Пример: s := 'Громов Роман'; // s, st_name string

st_name := Copy ( s, 8, 5 );

// результат – 'Роман' (c 8-ой позиции в строке S скопировано 5 символов)

DELETE ( S, P, N )

Описание: Удаляет N символов из строки S, начиная с позиции P

Пример: s := 'Borland Delphi'; // s string

Delete ( s, 1, 7 );

// результат – s = 'Delphi' (c 1-ой позиции в строке S удалено 7 символов)

INSERT ( S2, S1, P)

Описание: Вставляет строку S2 в строковую переменную S1, начиная с позиции P

Пример: s1 := 'Студент Громов'; // s1, s2 string

s2 := ' Роман';

Insert (s2, s1, 15);

// результат – s1 = 'Студент Громов Роман'

ФУНКЦИИ ОБРАБОТКИ СИМВОЛЬНОЙ ИНФОРМАЦИИ

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

CHR ( код)

Описание: Возвращает символ, код которого указан в качестве параметра

Пример: symb := chr ( 64 ); // symb char

// коду 64 соответствует символ '@'

ORD ( символ)

Описание: Возвращает код символа, указанного в скобках



Пример: code1 := ord ( '*' ); // code1 byte или integer

// символу '*' соответствует код 42

Символы или их коды чаще всего используются для распознавания нажатых пользователем клавиш. Существует даже такое понятие – "перехват нажатия клавиш". На клавиатуре есть также клавиши, коды которых не имеют символьного ASCII-эквивалента, – это управляющие и функциональные клавиши (см. Приложение 3). В случае, когда нужно указать в коде одну из таких клавиш, записывают "#код", например: клавише Tab соответствует #8, Esc – #27 и т.д.

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

Виртуальные коды, описанные в модуле Windows, приведены в Приложении 4.


1 – Открыть новый проект и сохранить его в отдельную папку StringOperations: имя файла проекта – Pro_StringOperations.dpr, имя файла модуля – StringOperations.pas.

2 – На форме расположить следующие компоненты:

5 компонентов Button; 2 компонента LabeledEdit; по одному компоненту: Edit, Label и Timer.

Расположение и их имена компонентов см. на скриншотах ниже:



3 – Задать свойству Caption следующие значения:

для BtnInsert Insert Text1 to Text2; для BtnPosition Position of Text1 in Text2; для BtnDelete Delete N symbols in Text2; для BtnCopy Copy N symbols of Text1; для BtnScrollText Scrolling Text; для LabeledEdit1 Text1 (свойство EditLabel.Caption); для LabeledEdit2 Text2 (свойство EditLabel.Caption).



4 – Для компонента Timer1 изменить значения свойств:

Enabled = False; Interval = 100.

5 – Объявить глобальные переменные: s, s1: string;

n, p: byte;

6 – Для кнопок BtnInsert, BtnPosition, BtnDelete и BtnCopy написать обработчики события OnCLick, демонстрирующие работу функций, соответствующих названиям кнопок: Insert, Pos, Delete и Copy.

Для ввода исходных текстовых строк, которые будут задействованы в обработке, использовать компоненты LabeledEdit1 и LabeledEdit2. Результат выполнения функции (возвращаемое ею значение) выводить в поле компонента Edit1.

7 – Для кнопки BtnScrollText написать обработчик события OnCLick, в котором производится запуск таймера и задается начальное значение для текстовой строки.



Команды, имитирующие эффект бегущей строки, расместить в обработчике события OnTimer компонента Timer1. Для вывода текста бегущей строки использовать Label1.

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

Например, имеем строку 'Это – эффект Бегущей строки!'. Нам необходимо задать движение "справа налево". Рассмотрим, что с ней будет происходить в каждый следующий момент времени (отслеживается компонетом Timer):

Для реализации алгоритма посимвольной перестановки в строке используются функции Copy и Length. Более подробно см. в приведенном ниже примере программного модуля.

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

или по алгоритму предполагается ввод целого числа, а в поле – данные совсем другого типа. Разные способы предотвращения подобных ситуаций будут описаны далее.

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

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



Поиск вхождений заданного фрагмента текста в строку и реакция

программы в разных ситуациях "найдено / не найдено":

результат



Удаление заданного фрагмента текста из строки:

фрагмент найден

фрагмент не найден



Копирование фрагмента строки:

Эффект бегущей строки:

результат

результат



результат



Тема 4. СЕКРЕТЫ ОТ ВСЕЙ ПЛАНЕТЫ

Потренируемся использовать параметр Key события OnKeyPress для написания процедуры ввода пароля.

Поскольку параметр Key, содержащий ASCII-код нажатой клавиши, передается в обработчик как переменная величина (var), следовательно, его значение можно проанализировать и, при необходимости, изменить, передавая для дальнейшей обработки совсем другой символ.

Если параметру Key присвоить значение ноль (#0), то это будет соответствовать отмене нажатия клавиши.

Обычно при вводе пароля вместо символа нажатой клавиши выводится символ '*'. Для достижения этого эффекта выполним такие действия:

Откроем новый проект. Изменим размеры формы так, чтобы она выглядела небольшой, – только для ввода пароля, и расположим на форме только 2 компонента: Label1 и Edit1.

В Object Inspector для Label1 зададим Caption = 'Введите пароль', а поле свойства Text компонента Edit1 очистим.

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

…

var

Form1: TForm1;

pass: string='';

Сформируем заготовку процедуры на событие OnKeyPress для Edit1. Чтобы "не потерять" информацию о каждой нажимаемой клавише, сначала значение переменной Key добавим к строке, хранящейся в pass, а затем заменим его на звёздочку для дальнейшей "передачи" в поле ввода Edit1.



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

…

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key:

Char);

begin

if Key <> #13 then

// если нажатая клавиша – не Enter, накапливаем символы

// пароля в pass, заменяя их на *

begin

pass:=pass+Key;

Key:='*';

end

else

// если нажата клавиша Enter, то выводим пароль

// в заголовок формы и очищаем Edit1

begin

Form1.Caption:=Pass;

Edit1.Clear;

Edit1.SetFocus

end;

end;

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

После нажатия на клавишу Enter – немного иначе.

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




1 – Открыть уже существующий проект: папка ChangingColor файл проекта Pro_ChangeColor.dpr.

2 – Добавить в проект шаблон окна диалога PasswordDlg для ввода пароля: File New Other Dialogs Password Dialog.

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

Чтобы не путаться, установить следующие значения свойств:

для Form1: Name = fmMain, Caption = ʹMain Formʹ; для PasswordDlg: Name = fmPass; для fmPass.Label1: Caption = ʹEnter your passwordʹ; для fmPass.Password (компонент TEdit): Name = PassEdit.

3 – Сохранить проект командой Save All, задав для Unit1.pas имя PassModule.pas.



4 – Для формы окна диалога fmPass в Object Inspector найти событие OnCloseQuery, которое генерируется системой при попытке закрыть форму любым доступным способом (более подробно см. ниже) и сформировать заготовку процедуры обработки этого события, куда вписать:

…

procedure TfmPass.FormCloseQuery(Sender: TObject;

var CanClose: Boolean);

const pass = 'qwerty!';

{Задаем значение для константы pass,

это и будет пароль для программы}

begin

if PassEdit.Text = pass then CanClose:=True

else Application.Terminate;

{Если введенный в PassEdit пароль совпадет с константой

pass, окно fmPass будет закрыто, и появится главная

форма, если нет, - программа закончит работу}

end;

В Windows основной элемент пользовательского интерфейса – форма. В Delphi каждый проект, как правило, имеет хотя бы одно окно – главное окно приложения. Все окна в Delphi основаны на объекте TForm.

Рассмотрим основные события, связанные с "жизнью" формы.

При создании формы (если свойство Visible = True), события происходят в следующем порядке: OnCreate, OnShow, OnActivate, OnPaint.

При уничтожении формы события генерируются в следующем порядке: OnCloseQuery, OnClose, OnDeactivate, OnHide, OnDestroy.

Событие Описание

OnCreate Возникает при создании TForm (только один раз). В обработчике события можно настроить форму и ее компоненты.

OnShow

Генерируется сразу перед тем, как форма станет видимой. OnShow вызывается, если установить свойство формы Visible в True, либо при вызове методов Show и ShowModal.

OnActivate OnDeactivate

OnActivate генерируется, когда форма становится активной, т.е. когда форма получает фокус ввода. OnDeactivate – когда форма теряет фокус



Событие Описание

OnPaint

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

OnResize Вызывается при изменении размеров окна. В обработчике можно изменить размеры объектов в окне пропорционально изменениям окна.

OnCloseQuery

Генерируется, если попытаться закрыть форму при помощи метода Close или любым другим способом (Alt+F4, через системное меню). Наиболее часто OnCloseQuery используют для того, чтобы спросить пользователя, "действительно ли он уверен… " (возможно остались несохранённые данные).

Обработчик события содержит переменную CanClose, значение которой определяет, будет ли форма закрыта. По умолчанию CanClose = True. Задав в обработчике OnCloseQuery возвращаемое значение CanClose в False, можно прервать выполнение метода Close.

OnClose

Генерируется, если обработчик OnCloseQuery вернул CanClose=True (форма должна быть закрыта). OnClose – это последний шанс не допустить закры-тие формы. Обработчик OnClose имеет параметр Action с четырьмя возможными значениями:

caNone – форму закрывать не разрешается.

caFree – форма будет закрыта, и занятые ей ресурсы будут освобождены.

caHide – вместо закрытия форма будет скрыта.

caMinimize – вместо закрытия форма будет миними-зирована (значение устанавливается по умолчанию для дочерних форм MDI).

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

OnDestroy

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



В таблице приведены наиболее важные события форм, общий их список можно видеть на закладке Events окна Object Inspector.

Довольно редко программы содержат лишь одну форму. В Delphi дополнительные формы создаются легко и просто: File New Form (или Other). С помощью формы можно организовать диалог с пользователем, вводить и/или выводить необходимую информацию.

Вызов для формы метода ShowModal или Show определяет тип окна: модальное и немодальное.

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

Модальная форма (метод ShowModal) требует обязательного закрытия перед обращением к любой другой форме приложения. Модальная форма полностью берет на себя дальнейшее управление программой, поэтому оператор, следующий за вызовом ShowModal, получает управление только после её закрытия. Для удаления формы с экрана используются методы Hide (спрятать) и Close (закрыть).

5 – Для главной формы проекта fmMain в обработчике события OnShow пропишем следующее:

procedure TfmMain.FormShow(Sender: TObject);

begin

fmPass.ShowModal;

{метод ShowModal позволяет вызвать окно формы fmPass

в таком режиме, что, пока не будет закрыто окно fmPass,

приложение в других окнах выполнятся не будет}

end;

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



Т.к. в модуле главной формы fmMain есть команда вызова формы fmPass, объявленной в модуле PassModule.pas, Delphi запрашивает разрешение на его добавление в список используемых модулей. Если выбрать "Yes", то в тексте главного модуля перед директивой {$R *.dfm} будет добавлена строка с соответсвующей командой.

Можно выполнить подключение и вручную: командой Use Unit (Использовать модуль) из меню File, выбрав в появившемся окне имя подключаемого модуля.

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

Только если введенный пароль совпадет с заданным, появится окно главной формы. В противном случае приложение аварийно завершается (Application.Terminate).



Cамостоятельная работа к заданию "Секреты от всей планеты"

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

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


1 – Откройте существующий проект, например, Pro_RunningButton.dpr.

2 – Добавьте в этот проект еще одну форму (File New Form). Добавленная форма Form2 является подчиненной, Form1 – главной формой проекта. Чтобы не путаться, установите следующие значения свойств:

для Form1: Name = fmMain, Caption = ʹMain Formʹ; для Form2: Name = fmPass, Caption = ʹEnter your passwordʹ.

3 – Сохраните проект командой Save All, задав для Unit2.pas имя PassModule.pas.

4 – Для fmPass повторите все действия, описанные в начале данного задания: расположите на форме компоненты Label1 и Edit1, а затем пропишите в редакторе кода команды на событие Edit1KeyPress.

5 – С помощью команды Use Unit (меню File) поочередно1 выполните подключение модулей обоих форм.

6 – В тексте модуля PassModule объявите 2 глобальные переменные: pass, которая будет хранить символы вводимого пароля, и passOK,

1 Переключаться между имеющимися в проекте формами можно с помощью командной

кнопки View Form (Отобразить форму) или комбинацией Shift+F12.



чтобы зафиксировать соответствие введенного пароля заданному (True/False):

…

pass: string='';

passOK: Boolean;

7 – Для события fmPass.FormCreate пропишите следующие команды:

установить начальное значение passOK = False; установить свойство формы KeyPreview = True; очистить поле ввода Edit1; задать положение окна формы fmPass – по центру главной

формы приложения.

8 – Для события fmPass.FormClose запишите команду

9 – Реализуйте алгоритм перехвата и анализа нажатой клавиши для Edit1, используя событие OnKeyPress, так, чтобы при нажатии



Backspace (как и положено) стирался последний введенный символ, а при нажатии Enter выполнялась проверка правильности пароль. Если введенный пароль соответствует заданному, то окно формы fmPass закрывается, и управление передается fmMain. Если же пароль введен неверно, то выдавать сообщение и очищать Edit1.

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



используя команду Units (Ctrl+F12) из меню View, откройте для редактирования файл Pro_RunningButton.dpr. В резуль-тате в окне редактора кода откроется страница с текстом файла проекта:

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

begin

Application.Initialize;

Application.CreateForm(TfmMain, fmMain);

Application.CreateForm(TfmPass, fmPass);

PassModule.fmPass.show;

repeat

Application.ProcessMessages;

Until PassModule.passOK;

PassModule.fmPass.close;

Application.Run;

end.



Тема 5. КАЛЕЙДОСКОП ОГНЕЙ

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

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

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

Name : array [нижний_индекс. .верхний_индекс] of Type

где:

Name – имя массива;

array – зарезервированное слово языка Delphi, обозначающее, что объявляемое имя является именем массива;

нижний_индекс и верхний_ индекс – константы целого типа, определяющие диапазон изменения индекса элементов массива и, неявно, количество элементов массива;

Type – тип элементов массива.

Примеры объявления массивов:

num: array[1..31] of Real;

коef: array[0. .2] of Integer;

name: array[1..30] of String[25];

// массив name будет состоять из строк

длиной не более 25 символов

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

team[1] := 'Dinamo';

ShowMessage(name[n+1]);

num[i] := StrToFloat(Edit1.text);



Массив – один из основных типов данных в Delphi. Более детально работа с ними будет рассмотрена чуть позже.


1 – Открыть новый проект и для Form1 задать следующий размер: ClientHeight и ClientWidth – 390 px.

Использование свойств ClientHeight/ClientWidth обусловлено тем, что они позволяют, в отличие от Height/Width, задать точные размеры внутренней области окна, не включая толщину границ окна (Borders) и высоту его заголовка.

2 – На форме расположить 36 одинаковых компонентов Shape квадратной формы:

Height и Width = 57 px,

Brush.Color = clBtnFace,

Pen.Style = psClear.

Принцип размещения компонентов Shape приведен ниже.



3 – Добавить на форму Timer1 и установить значение свойства Interval равным 50 (ms).

4 – В процедуре обработки события OnTimer компонента Timer1 объявить локальную переменную i (тип Byte).

Для достижения поставленной цели представим 36 компонентов Shape как некий массив объектов на форме с унифицированным именем Form1.Controls, к которым можно обратиться, указав их порядковый номер – Form1.Controls[i].

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



В операторе IF в качестве условия использована конструкция (Form1.Controls[i] is TShape), которая читается следующим образом: "если объект управления на форме с порядковым номером i является компонентом типа Shape". Если это условие будет выполнено, то тогда (Form1.Controls[i] as TShape).Brush.Color … – "для объекта управления на форме с порядковым номером i, являющегося компонентом типа Shape, присвоить свойству Brush.Color …".

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



Тема 6. ЧТО ЗА ЧУДО ЭТИ ЦИКЛЫ!

Начнем это задание с анекдота про программистов, давно "гуляющего" по просторам Интернета:

Однажды не пришел программист на работу. Начальник забеспо-коился и послал к нему домой коллегу. Тот заходит и видит такую картину: вконец замученный программист сидит в ванне, моет шампунем голову и бормочет: "Да когда-же это кончится!". Ничего не понимающий коллега берет флакончик с шампунем в руки и читает инструкцию по применению: "Выдавить небольшое количество шампуня на руку, нанести на мокрые волосы, промыть. Затем повторить…"

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

Для таких случаев предусмотрены операторы цикла.

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

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

оператор FOR (с известным числом повторений);

оператор WHILE (с предусловием);

оператор REPEAT (с постусловием).

Если число повторений заранее неизвестно, но задано условие его повторения/окончания, используются операторы While, Repeat.

Разберем ОСНОВНЫЕ ПОНЯТИЯ:

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

Итерация – однократное выполнение тела цикла. Условие выхода или условие окончания цикла –

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



Счётчик цикла – переменная, хранящая текущий номер итерации.

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

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

Break, – реализует немедленный выход из цикла, управление передается оператору, стоящему сразу после тела цикла;

Continue, – обеспечивает досрочное прохождение цикла, что равносильно передаче управления в конец оператора цикла.

Сравнительная характеристика операторов цикла.

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

В зависимости от условий задания, нужно использовать один из циклов.

Цикл Принцип записи Условие выхода

FOR

For n:= 1 to 50 do begin

отживается; // 50раз

end;

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

WHILE

While Силы есть? do

begin

отживается;

end;

Прежде проверяем, есть ли силы у спортсмена; если есть, – тогда делай! Если нет, то и начинать нечего…

REPEAT

Repeat

отживается;

Until Устал? end;

Сначала сделай упражнение, потом выясним, может, спортсмен устал; если да, – пора заканчивать!



Общая структура записи операторов цикла:

for i:=1 to n do

(* переменная i должны быть объявлена как Integer, n –

указывает, сколько раз должен выполниться цикл*)

begin

операторы (тело цикла)

end;

------------------------------------------------------

while условие do

begin


end;

(* Оператор цикла действует следующим образом:

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

Затем если оно истинно, то выполняются операторы

тела цикла. Если условие ложно, то происходит

выход из цикла *)

------------------------------------------------------

repeat


until условие

(* Оператор цикла с постусловием действует следующим

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

пор, пока условие ложно. Как только условие

становиться истинным, цикл завершается *)

Воспользуемся оператором цикла FOR для перевода заданного диапазона температур по шкале Цельсия в температуру по шкале Фаренгейта. Формула пресчета: Тфарингейт = Tцельсий х 9 / 5 + 32.


1 – Открыть новый проект и сохранить его в отдельную папку Temperatura_CF: имя файла проекта – Pro_Temperatura_CF.dpr, имя файла модуля – Temperatura_CF.pas.

2 – На форме расположить компоненты Memo1, Button1, Button2, LabeledEdit1 и LabeledEdit2.

3 – Установить значений свойств для компонентов:

Button1: Name = BtnCalcTemp, Caption = 'Convert C ==> F'.



Button2: Name = BtnMinus, Caption = ' Click to input negative value '.

Memo1: Lines – очистить от текста, ScrollBars = ssVertical. LabeledEdit1: Name = LE_Start, EditLabel.Caption = 'Start-range

lue'. LabeledEdit2: Name = LE_Stop, EditLabel.Caption = 'End-range

value'. Form1: Name = fmConvertTemp, Caption = 'Температура по

шкале Цельсия и Фаренгейта', ClientHeight = 450, ClientWidth = 425.

4 – При вводе начального и конечного значений диапазона температур по шкале Цельсия выполнять проверку корректности вводимых символов. т.е. в LabeledEdit1 и LabeledEdit2 допускается вводить цифры, а также использовать клавишу Backspace и Enter.

5 – При нажатии на клавишу Enter и при щелчке мышкой по кнопке "Convert C ==> F" в поле компонента Memo1 вывести отдельными строками соответствие значений температуры по Цельсию температурам по Фаренгейту, используя для этого оператор FOR.



6 – Текст в заголовке формы оформить как бегущую строку.

Скриншоты кода с пояснениями приведены ниже.

Отслеживание правильности вводимых в LabeledEdit (как и в Edit)

данных выполняется в обработчике события OnKeyPress. В операторе

IF использовано ключевые слова NOT и OR (тип Boolean).

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

то их обязательно заключать в скобки! Так как символы клавиш 0-9

имеют коды, расположенные в таблице ASCII подряд, то разумнее

записать их как диапазон значений: ['0' . . '9'].

При нажатии клавиши Enter приложение вызывает обработчик

события BtnCalcTempClick.

Если необходимо задать отрицательные значения температур по

Цельсию, то для используется кнопка BtnMinus, которая добавит в

строку LabeledEdit, имеющего фокус, знак минуса перед числом.



Так как команды обработчика события LE_StopKeyPress полностью

идентичны командам обработчика LE_StartKeyPress, достаточно для

компонента LE_Stop в окне Object Inspector (закладка Events) в

строчке OnKeyPress выбрать ссылку на уже описанное в коде событие.

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

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

по шкале Цельсия ограничен только целыми числами, тогда как

результат является числом вещественным (т.к. в формуле

выполняется операция деления). Для вывода на Memo1 результата

используется функция преобразования из вещественного числа в

строку символов – FloatToStr(…).

Для обеспечения корректности ввода перед началом цикла

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

диапазона было не больше конечного, иначе выполнение процедуры

прерывается.



Эффект бегущей строки в заголовке формы выполняется по уже

отработанному алгоритму (см. предыдущие задания).

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

очистку строк Memo1 от ранее введенного текста; посимвольный вывод текста заголовка формы на отдельные

строки Memo1.



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

Начальное значение счетчика цикла i должно быть задано до вхождения в цикл. Наращивание значения i производится после выполнения команд тела цикла либо с помощью процедуры INC(i)1, либо обычным прибавлением i:= i + 1.

В результате в Memo1 отобразится строка из fmConvertTemp.Caption в вертикальном виде:

1 Процедура INC(…) увеличивает значение переменной порядкового типа, указанной в

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



Cамостоятельная работа к заданию "Что за чудо эти циклы!"

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

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

Основная функция компонента Panel (палитра Standard) – объединение компонетов, функционально связанные друг с другом. Это – своебразный "контейнер" для их размещения.

Внешний вид панели определяется следующими свойствами:

BevelInner — стиль внутренней части панели, BevelOuter — стиль внешней части панели, BevelWidth — ширина внешней части панели, BorderStyle — стиль бордюра, BorderWidth — ширина бордюра.

Если не определен ни один из перечисленных стилей, т.е. их значения равны None, то в этом случае панель никак не выделяется на форме. Будут видны только размещенные на панели компоненты, и надпись, если она определена в свойстве Caption.

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

сначала на форму устанавливается сам компонент Panel, а уже затем расставляются компоненты, которые должны размещаться на панели; все происходит как бы само собой, т.к. компонент Panel в этом случае остается "активным" (в окне Object TreeView соответствующая Panel строка будет подсвечена);

если же какие-либо компоненты были размещены на форме приложения перед добавлением Panel, то достаточно мышкой выделить один или несколько компонентов в окне Object TreeView и перетащить их на строку Panel.



Компонет MainMenu (палитра Standard) представляет собой главное меню программы. Он является невизуальным, место его размещения на форме в процессе проектирования не имеет значения, т.к. при выполнении приложения пользователь будет видеть лишь сгенерированное этим компонентом меню. После установки компонента на форму необходимо "прописать" пункты меню. Для чего нужно сделать двойной щелчок мышкой по компоненту или в окне Object Inspector в строке свойства Items нажать кнопку . Можно также воспользоваться командой контекстного меню – Menu Designer.

Надпись в очередном пункте (элементе) меню определяется свойством Caption. Если в свойстве Caption ввести символ "–", то в меню появится разделительная линия. С помощью команды Create Submenu из контекстного меню редактора также можно добавить и подчиненные меню.

В среде Windows пункты меню, как правило, можно выбрать при помощи сочетания клавиш Alt+<Key>, где Key – подчеркнутая буква в названии (Caption) этого пункта меню. Чтобы добавить подчеркивание, перед нужной буквой ставится символ &.

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



При работе с MainMenu основным является событие OnClick, возникающее при щелчке мышкой на выбранном пункте меню или при нажатии "горячих" клавиш.


1 – На форме расположить компоненты: MainMenu1, Panel1 и Panel2.

2 – Для Form1 создать обработчик события OnActivate, вписав следующие команды:

Panel1.Visible:= False;

Panel2.Visible:= False;

3 – Для компонента MainMenu1 сгенерировать следующие пункты меню:

Name = miActions, Caption = 'Дейстия'; Name = miTask1, Caption = 'Задача No.1'; Name = miTask2, Caption = 'Задача No.2'; Name = miSeparator, Caption = '–'; Name = miExit, Caption = 'Выход', ShortCut = Ctrl+X.

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

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



4 – ЗАДАЧА №1: Путем подбора найти таких 2 числа, сумма квадратов которых будет равна целому числу, заданному пользователем в ходе работы приложения. Результат (полученную пару чисел) вывести в виде строк на Memo1.

Установить значения свойств компонента Panel1:

Caption – пусто; Align = alClient (чтобы по размерам панели совпадали с

размерами внутренней области формы).

Добавить на Panel1 компоненты Edit1, Memo1 и UpDown1 (палитра Win32).

Компонент UpDown чаще всего используется в приложениях как счетчик. С его помощью можно уменьшать или увеличивать числовое поле на заданную целую величину. Диапазон допустимых значений от –32 768 до 32 767.

Основным свойством UpDown является Associate, связывающее кнопки со стрелками с одним из компонентов, как правило, с компонентом Edit. Свойства Min и Мах определяют минималь-ное и максимальное значения чисел. Свойство Increment задает приращение числа (т.е. шаг) при каждом нажатии на кнопку.

Свойство Position определяет текущее значение числа в поле UpDown. Значение этого свойства можно считать, когда требуется узнать заданное пользователем число. Кроме того, его можно задать во время проектирования в окне Object Inspector как значение по умолчанию, отображаемое в поле UpDown в начале выполнения приложения.



Если в компоненте Edit, связанном с UpDown, не задать ReadOnly равным True, то можно будет редактировать число, не пользуясь кнопками со стрелками.

Свойство Wrap определяет, как ведет себя компонент при достижении максимального или минимального значений. Если Wrap = False, то при увеличении или уменьшении числа до максимального или минимального значения это число фиксируется на предельном значении и дальнейшее нажатие на кнопки ни к чему не приводит. При Wrap = True попытка превысить Max приводит к сбросу значения до минимального. Аналогично, попытка уменьшить значение ниже Min приводит к его сбросу до максимального значения.

Для UpDown1 задать следующие значения свойств:

Min = 1, Max = 1000; Increment = 1; Associate = Edit1; Thousands = False, чтобы в числах большой разрядности

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

Поле Memo1 очистить от текста.

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

Полученный результат выводиться в поле Memo1 одной или несколькими строками (если вариантов пар чисел оказалось несколько).



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

Ниже приведен фрагмент кода.

В расчетах использованы 2 математические функции: SQRT(…) и TRUNC(…). Так как необходимо было рассчитать сумму квадратов двух чисел, то, следовательно, каждое из них не должно быть больше числа, являющегося результатом извлечения квадратного кореня из числа N (заданного пользователем в Edit1 кнопками со стрелками).

SQRT(…) – функция, которая возвращает квадратный корень числа, указанного в скобках. Результат вычисления относится к типу Extended, т.е. является вещественным числом.

Например,

N2:= sqrt (N1);

{если N1 = 21,

то N2 будет равно 4.58257569495584}

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

TRUNC(…) – функция, которая возвращает целочисленную часть вещественного числа, указанного в скобках.



Например,

N2:= Trunc(sqrt (N1));

{если sqrt (N1)= 4.58257569495584,

то N2 будет равно 4, т.е. функция "отбросит"

всѐ, что расположено после запятой}

Сохранить проект в папке Pro_MultiActions: файл проекта – Pro_MultiActions.dpr, файл модуля – MultiActions.pas.

5 – ЗАДАЧА №2: Для введенного с клавиатуры в Edit2 целого числа рассчитать факториал. Результат вывести на Memo2 в виде строки следующего вида: 'х! = y', где "х" – введенное число, а "y" – рассчитанный результат.

Установить значения свойств компонента Panel2:

Caption – пусто; Align = alClient.

Для удобства работы Panel1 следует расположить на заднем плане. (см. контекстное меню редактора формы Control Send To Back).

Добавить на Panel2 компоненты Edit2, Memo2, Button и Button2.

Установить значения свойств для этих компонентов:

поля Edit2 и Memo2 очистить от текста. Button1: Name = BtnFactorial, Caption = 'Факториал'. Button2: Name = BtnClear, Caption = 'Очистить'.

Для BtnClear на событие OnClick выполнять команды:



В процедуры TForm1.miTask1Click и TForm1.miTask2Click доба-вить соответственно команды:

Edit1.SetFocus; // в TForm1.miTask1Click

Edit2.SetFocus; // в TForm1.miTask2Click

Для BtnFactorial сформировать обработчик события OnClick и вписать команды по расчету факториала1 числа:

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

Поэтому переменная F объявлена в процедуре как вещественное число типа Extended (сравнить диапазоны значений для Int64 и Extended можно в главе "Типы данных").

1 Факториал числа n — это произведение всех натуральных чисел до этого числа

включительно. Обозначается с восклицательным знаком в конце, например, факториал числа 7 записывается как 7!. Рассчитывается по формуле: n! = 1 · 2 · 3 · … · (n-2) · (n-1) · n. По определению принимается, что 0! = 1. Факториал определён только для целых неотрицательных чисел.



Чтобы полученный результат отображался в строке Memo2 более компактно, использована функция преобразования вещественного числа в строку с указанием конкретного формата FloatToStrF(…).

FloatToStrF(…) возвращает вещественное значение в виде форматированной строки. Форматированная строка поможет содержать разделители DecimalSeparator и ThousandSeparator.

В общем виде функция FloatToStrF(…) записывается так:

FloatToStrF (Value, Format, Precision, Digits: Integer) : String;

где

Value – вещественное число типа Extended (т.н. число с плавающей запятой);

Format – аргумент типа TFloatFormat, определяет, как форматируется число;

Precision – аргумент типа Integer, определяет количество значащих цифр;

Digits – аргумент типа Integer, определяет количество цифр после десятичной точки.

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

Тип Описание

ffGeneral Основной формат, при котором, по возможности, применяется вариант ffFixed, в остальных случаях - ffExponent. Для чисел менее 0, 00001 всегда используется экспоненциальный формат.

ffCurrency Число форматируется с использованием значений CurrencyFormat или NegCurrFomat (напр., $31 415,00). Если Digits = 0, то десятичный разделитель (DecimalSeparator) не выводится.

ffExponent "Научный" или экспоненциальный формат (напр., -3,14Е+01). Всегда присутствует минимум одна цифра перед десятичным разделителем, Precision определяет общее число форматируе-мых символов. Digits определяет количество цифр в экспоненте, которое может быть в диапазоне от 1 до 4. Экспонента всегда начина-ется со знака "плюс" или "минус".



Например, в соответствии с командой вывода на Memo2 рассчитанного факториала для числа N (предположим, N = 68) в окне Memo2 появится следующая строка:

где

68 – это исходное число N;

2,480036 Е +96 – рассчитанное значение факториала, хранящееся в переменной F, равно числу 2,4800355424368305996009904185692E+96

Согласно заданному формату FloatToStrF(F,ffExponent,7,2) вещественное число F преобразовано в строку, причем так, что количество цифр в экспоненте = 2 (в примере – "96"), общее число цифр в мантиссе = 7 (в примере – "2,480036" за вычетом десятичного разделителя).

6 – В завершерние работы обеспечить ввод в поле Edit2 только целых положительных чисел с возможностью использования клавиш Enter, Backspace и Esc, используя процедуру обработки события OnKeyPress.

Чтобы избежать многократного вложения операторов IF, в процедуре в качестве условного оператора применяется оператор CASE … of.

ffFixed Формат фиксированной с десятичной точкой (например, -3141.59). Как минимум одна цифра всегда присутствует перед десятичным раздели-телем. Если слева от десятичного разделителя требуется более чем Precision цифр, формат автоматически меняется на ffExponent.

ffNumber Форматирует строку в фиксированном формате, но использует символ TnousanclSeparator для разделения тысяч, миллионов и т. д. (например, -314 159,26535).



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

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

…

CASE селектор OF

значение селектора 1 :

begin

Операторы 1;

end;

значение селектора 2 :

begin

Операторы 2;

end;

значение селектора N :

begin

Операторы N;

end

ELSE Операторы Иначе;

END;

…

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



Блок ELSE не является обязательным. В случае, когда внутри программных скобок begin ... end находится только один оператор, их использовать необязательно.

Примеры применения CASE: …

case Ans of

'Y','y','Д','д' : ShowMessage('Ответ – ДА (Yes)!');

'N','n','Н','н' : ShowMessage(' Ответ – НЕТ (No)!');

else ShowMessage ('Некорректный ответ');

// если была нажата какая-либо другая клавиша

end;

…

procedure TForm1.Button1Click(Sender: TObject);

var

D: Integer;

// D – порядковый номер дня недели

W: String;

// W –название дня недели

begin

D:= DayOfWeek(Date)-1; // см. сноску1 внизу

case D of

1: W:= 'Monday';

2: W:= 'Tuesday';

3: W:= 'Wednesday';

4: W:= 'Thursday';

5: W:= 'Friday';

6: W:= 'Saturday';

7: W:= 'Sunday';

end;

Label1.Caption:= DateToStr(Date) + ' – ' + W;

end;

…

Следует обратить вниманием, что оператор CASE должен заканчиваться своим "персональным" END;

1 Функция DayOfWeek(…) возвращает порядковый день недели, причем отсчет начинается

(т.е. результат =1) с Sunday (Воскресенье), поэтому в формуле вычитается «1».

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



Тема 7. КОНВЕРТЕР DEC HEX

Целью данного задания является создание программы по конверти-рованию чисел из одной системы счисления в другую. За основу возьмем десятичную (Decimal) и шестнадцатеричную (Hexdecimal) системы счисления. Помимо чисто практического интереса решение этой задачи позволяет глубже понять внутреннее представление чисел и научиться использовать для расчетов различные операции.


1 – В новом проекте на Form1 расположить следующие компоненты: LabeledEdit1 и LabeledEdit2.

2 – При активизации окна Form1:

свойству EditLabel.Caption компонента LabeledEdit1 присвоить значение "Decimal";

свойству EditLabel.Caption компонента LabeledEdit2 присвоить значение "Hexdecimal";

компонент LabeledEdit1 очистить от текста, затем на него установить курсор;

компонент LabeledEdit2 очистить от текста; в заголовке окна Form1 прописать следующий текст:

"Converter by …", где вместо многоточия указать свои имя и фамилию.



3 – При вводе десятичного числа в поле Edit1 и нажатии на клавишу Enter программа должна конвертировать его в шестнадцатеричное число и результат вывести в Edit2.

Введенное в Edit2 шестнадцатеричное число при нажатии Enter конвертировать в десятичное, а результат отобразить в Edit1.

4 – Чтобы отслеживать нажатие какой-либо клавиши, для компонента LabeledEdit1 (LabeledEdit2) необходимо использовать особенность события OnKeyPress. В заголовке процедуры обработки данного события объявляется переменная Key (тип Char), которая хранит информацию о последней нажатой клавише.

Чтобы "связать" какие-либо действия с нажатием клавиши Enter, вспомним, что к ней можно обращаться по коду #13.

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

В десятичной системе счисления алфавитом являются цифры: 0 1 2 3 4 5 6 7 8 9, в шестнадцатеричной – 0 1 2 3 4 5 6 7 8 9 A B C D E F.

Основанием десятичной системы счисления является 10, а шестнадцатеричной – 16.

Чтобы выполнить конвертирование из десятичной системы в шестнадцатеричную, заданное число делят на основание системы счисления (в нашем случае – на число 16) до тех пор, пока результат от деления не окажется меньше основания.



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

Рассмотрим пример конвертирования десятичного числа 345.

В результате первого деления числа 345 на 16 получаем 21 и в остатке – 9.

Т.к. 21 > 16, то продолжаем делить, – теперь уже 21 на 16, в результате чего получаем 1 и в остатке 5.

Из полученных остатков и конечного результата складывается шестнадцатеричное число 159. Причем, обратите внимание, что записываем мы его справа налево, как бы «наоборот»: сначала «первый» остаток – 9, затем перед ним добавляем «второй» остаток – 5, и только потом вперед добавляем последний результат деления – 1 .

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



В обработчике события OnActivate компонета Form1 делаются начальные установки для основных компонентов LabeledEdit1 и LabeledEdit2.

После этого в обработчике события OnKeyPress компонента LabeledEdit1 выполняется перевод десятичного целого числа в шестнадцатеричное (при условии, что была нажата клавиша Enter).

Объявить глобально константу S_hex, которая будет хранить символы шестнадцатеричного алфавита:

…

const

S_hex = '0123456789ABCDEF';

Алгоритм перевода десятичного целого числа в шестнадцатеричное реализован с помощью оператора цикла с предусловием – WHILE.



Для того, чтобы в поле LabeledEdit1 можно было вводить лишь целые положительные числа, перед строкой

if Key = #13 then

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



Теперь необходимо выполнить обратное преобразование –шестнадцатеричное число в десятичное. Математическое правило гласит: "… шестнадцатеричное число нужно представить в виде суммы произведений степеней основания шестнадцатеричной системы счисления на соответствующие цифры в разрядах шестнадцатеричного числа." Рассмотрим на примере числа 23С:

23C16 = (2·162) + (3·161) + (12·160) = 57210

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

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



Поэтому выполняется проверка корректности ввода и, если введенные буквенные символы 'a'…'f' не относятся к верхнему регистру, то применяется функция UpCase(…), позволяющая изменить регистр указанного в качестве аргумента символа.

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

7 – Сохранить проект в папку Pro_Converter: файл модуля MyConverter.pas и файл проекта Pro_MyConverter.dpr.



Cамостоятельная работа к заданию "Конвертер Dec Hex"

Эта работа предназначена для закрепления пройденного материала. Продолжим работу над проектом Pro_MyConverter.dpr и реализуем алгоритм, который обеспечит при нажатии на клавишу Enter выполне-ние конвертирования по следующей схеме:

Следует помнить, что символами алфавита для восьмеричной и двоичной систем счисления являются:

для двоичной: '0', '1'. для восьмеричной: '0', '1', '2', '3', '4', '5', '6', '7'.


1 – Добавить на форму следующие компоненты: TLabeledEdit (для конвертирования в двоичную и восьмеричную системы счисления и обратно) – 2 шт., TButton – 2 шт., TTimer и TLabel – по 1 шт.


Form1: ClientHeight = 370, ClientWidth = 230. LabeledEdit1: Left = 30, Width =175, Text = 'Decimal'. LabeledEdit2: Left = 30, Width =175, Text = 'Hexdecimal'. LabeledEdit3: Left = 30, Width =175, Text = 'Octal'. LabeledEdit4: Left = 30, Width =175, Text = 'Binary'.



Button1: Name = BtnClear, Caption = Clear, Width = 65. Button2: Name = BtnExit, Caption = Exit, Width = 65. Timer1: Interval = 100. Label1: AutoSize = False; Alignment = taCenter, Caption= ' To

clear all fields press Clear or Esc! ', Color = $006F6F6F; Left = 0; Width = 230.

3 – Выровнить компоненты относительно друг друга по левому краю, а затем равномерно распределить их по вертикали (Edit Align Left sides, затем Vertical: Space equally).

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

При необходимости компоненты на форме можно выравнивать относительно окна формы или друг друга. Для этого их нужно выделить и выбрать команду Edit Align (или через контекст-ное меню Position Align). Выравнивание выполняют постепенно: сначала по горизонтали, затем – по вертикали, или одновременно.



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

4 – Приведенный вариант фрагмента программного кода добавить в процедуру LabeledEdit1:

…

// фрагмент кода преобразования в восьмеричное число

while Num8 >= 8 do

begin

Ost8:= Num8 mod 8;

Result8:= IntToStr(Ost8) + Result8;

Num8:= Num8 div 8;

end;

Result8:= IntToStr(Num8) + Result8;

LabeledEdit3.Text:= Result8;

Переменные Num8, Ost8 и Result8 должны быть объявлены локально (по аналогии с Num, Ost и Result). Для большей наглядности можно поменять имена переменным Num, Ost и Result на Num16, Ost16 и Result16 соответственно, связав имена с основанием системы счисления.

…

// фрагмент кода преобразования в двоичное число

while Num2 >= 2 do

begin

Result2:= IntToStr(Num2 mod 2) + Result2;

Num2:= Num2 div 2;

end;

Result2:= IntToStr(Num2) + Result2;

LabeledEdit4.Text:= Result2;



Переменные Num2, Ost2 и Result2 объявить локально (вместе с остальными).

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

Функция POWER(x,y) используется для возведения числа х в степень y. Но для того, чтобы она работала, необходимо прописать в разделе uses библиотеку Math.



Тема 8. НАДЕЖНОЕ ПРОГРАММИРОВАНИЕ

Никого работа программы не удивляет так часто, как ее создателя!

Когда программист в результате компиляции получает готовый к использованию файл приложения (*.exe), то он свято верит в то, что его программа всегда будет работать именно так, как он задумал. Так оно и бывает, пока она – в заботливых руках "создателя". Но стоит программе попасть к новому пользователю или на другой компьютер как с ней тут же начинает происходить что-то непонятное. А проблема лишь в том, что пользователь по незнанию или случайно вместо ожидаемых программой цифр ввел буквы или решил извлечь корень из отрицатель-ного числа, а то и вовсе "забыл" ввести требуемое значение и т.п., создав массу "критических" ситуаций своими необдуманными действиями.

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

Существует даже такое выражение "Защита от дурака" (от англ. Idiot proof или Mistake-proofing, http://en.wikipedia.org/wiki/Idiot_proof ).

Еще Ильф и Петров в книге "Одноэтажная Америка" писали: "…Высокая техника боится человека и не верит в его сообразительность. Там, где это только возможно, она старается предохранить себя от ошибок, свойственных живому существу. Название было придумано жестокое, бичующее – защита от дурака!"

В любом приложении во время работы могут возникать ошибки. Их делят на:

ошибки субъективного характера (вызваны неграмот-ными действиями);

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

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

http://en.wikipedia.org/wiki/Idiot_proof



Потенциально любой оператор программы может стать причиной исключительной ситуации.

Для обработки ошибок можно попытаться применить оператор if ошибка then Exit. Однако в этом случае программный код решения основной задачи обрастает большим количеством проверок так, что в нем невозможно не разбераться.

В Delphi cуществует более простой и элегантный механизм обработки исключительных ситуаций1, основанный на системе структурной обработки исключительных ситуаций (ошибок), внедренной во все операционные системы Microsoft, начиная c Windows NT. При каждой исключительной ситуации Delphi перехватывает управление программой. Для отмены реакции Delphi на исключительную ситуацию необходимо окне команды Tools Debugger Options на закладке Language Exceptions отключить установку Stop on Delphi Exceptions.

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

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

Например, если в качестве аргумента функции StrToInt окажется пустая строка, то функция сгенерирует исключение EConvertError (см. скриншот сообщения об ошибке).

1 Исключительная ситуация – это такая ситуация, в результате которой генерируется

ошибка, и выполнение программы прерывается. Деление на ноль – классический пример исключительной ситуации.

Модель исключительных ситуаций в Delphi является невозобновляемой (non-resumable). Это означает, что при возникновении исключительной ситуации невозможно вернуться в точку, где она возникла, для продолжения выполнения программы (в отличие от возобновляемой (resumable) модели).



Для обработки исключений введены две конструкции: try..except и try..finally.

Конструкция try..except состоит из двух блоков:

…

try

{операторы, выполнение которых может вызвать ошибку}

except

{операторы, которые выполняются только в случае

возникновения ошибки}

else

{для неучтенных ошибок, - обработчик по умолчанию}

end;

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

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

Рассмотрим пример.

На форме расположены 2 поля для ввода чисел (TEdit). При щелчке по кнопке Button1 строки из Edit1 и Edit2 конвертируют-ся в числовые значения x и y, а затем выполняется вещественное деление. Результат выводится на Label1.

В ходе выполнения этого несложного алгоритма могут возникнуть 3 исключительных ситуации (ошибки):



EConvertError – при конвертировании строки сначала из Edit1, а затем – из Edit2;

EZeroDivide – при выполнении операции вещественного деления.

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

Конструкция try..finally используется в случае, когда при возникнове-

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

ресурсы, такие как память, файлы и др. ресурсы операционной

системы.



Общий вид конструкции: …

try

{операторы, выполнение которых может вызвать ошибку}

finally

{операторы, выполняемые всегда, даже в случае ошибки}

end;

Если в любом из операторов блока try возникает исключение, то управление передается первому оператору блока finally. Если исключение не возникло, то выполняются все операторы обоих блоков.

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

Рассмотрим пример.

На форме расположены Memo1 для ввода или отображения текста и 2 кнопки, которые предназначены:

BtnRead – для считывания информации из файла и загрузки его в Memo1.

BtnWrite – для записи в файл введенного в Memo1 текста.





Тема 9. САМОДЕЛЬНЫЙ КАЛЬКУЛЯТОР

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

Для нового проекта создадим отдельную папку Pro_Calc, куда сохраним основные файлы нового проекта под именами ProMyCalc.dpr и MyCalculator.pas.

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

Caption: My Calculator Height: 300 px Width: 380 px

Нам понадобятся следующие компоненты:

Button (палитра Standard) – 24 шт. Edit (палитра Standard) – 1 шт. Bevel1 (палитра Additional) – 2 шт.

Расставим их на форме по образцу.

1 Компонент Bevel служит для выделения отдельных элементов на форме трехмерными

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



Совет: Самый простой и быстрый способ расположить 24 одинаковых кнопки на форме – использовать Clipboard. Сначала задать для одной кнопки Height = 35 px и Width = 40 px, а затем путем копирования (Ctrl+C / Ctrl+V) "размножить ее" по вертикали (столбцом). Потом, выделив имеющиеся 4 кнопки, повторить копирование уже целого столбца. Когда на форме будет 12 кнопок, разместить рамку Bevel вокруг них. Затем скопировать весь блок. Когда все компоненты будут на форме, выровнить их по горизонтали и по вертикали, выделяя как строки или столбцы в таблице, используя команду Edit Align (или через контекстное меню Position Align).

Теперь для каждой кнопки зададим Caption и Name:

Caption Name Caption Name

0 Btn0 * BtnMultiply

1 Btn1 / BtnDivide

2 Btn2 + BtnPlus

3 Btn3 - BtnMinus

4 Btn4 <= BtnBack

5 Btn5 x^2 BtnX2

6 Btn6 % BtnPercent

7 Btn7 x! BtnFactorial

8 Btn8 C BtnClear

9 Btn9 x^y BtnXY

, BtnSeparator sqrt BtnSqrt

+/- BtnSign = BtnEqual

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



1 – Для события OnActivate компонета Form1 создадим заготовку процедуру обработки и запишем команды подготовки Edit1 к работе:

procedure TForm1.FormActivate(Sender: TObject);

begin

Edit1.Clear;

Edit1.SetFocus;

end;

2 – На событие OnClick каждой кнопки, предназначенной для ввода цифр, запишем команду, добавляющую соответствующий символ в конец уже имеющейся в Edit1 строки:

…

procedure TForm1.Btn0Click(Sender: TObject);

begin

Edit1.Text:=Edit1.Text + '0';

end;


begin


end;


begin


end; // и т.д. (до Btn9 включительно).

3 – Аналогично действуем в отношении кнопки ввода десятичного разделителя для вещественных чисел:

Используем системную переменную DecimalSeparator вместо конкретного указания "," или ".", т.к. это позволит сделать наше приложение независимым от региональных настроек Control Panel. С помощью функций IF и POS производим проверку на наличие в



строки десятичного разделителя и, только если такой символ не найден, добавляем его в конец строки.

4 – В обработчике события OnClick кнопки BtnClear должна выпол-няться процедура очистки поля ввода Edit1 и передачи на него фокуса. Не стоит в программе дублировать одни и те же команды несколько раз, поэтому просто создадим ссылку на обработчик FormActivate, выбрав его из списка в поле OnClick на закладке Events окна Object Inspector.

5 – Функция кнопки BtnBack эквивалентна функции клавиши Backspace, т.е. должен удаляться последний символ, введенный в поле Edit1. Используем для этого функцию Delete:

6 – Кнопка BtnSign предназначена для того, чтобы менять знак числа (положительное / отрицательное). Выполнить эту операцию можно с помощью функций Insert, Delete и логического оператора if.



7 – Для кнопок, выполняющих вычисления сразу же после их нажатия, кроме кнопки BtnEqual ("="), создадим обработчики событий OnClick и запишем в них команды по выполнению расчетов, предварительно объявив глобальную переменную х как Real.

BtnX2 (возведение числа в квадрат):

BtnSqrt (вычисление квадратного корня из числа):

BtnFactorial (вычисление факториала числа): по аналогии с предыдущими кнопками пишем код для расчета факториала. Сам алгоритм описан на стр. 94.



8 – Теперь перейдем к описанию вычислений, выполняющихся в два этапа. Операции сложения, вычитания, умножения, деления и возведения числа в степень "n", что будут последовательно введены два числа, а затем нажата кнопка "равно". Поэтому код вычисления результата этих действий также разделим на 2 части:

ввод 1-го числа и нажатие кнопки соответствующего матема-тического действия, после чего поле Edit1 очищается, а введенное число и выбранное действие запоминаются;

ввод 2-го числа и нажатие кнопки "равно", после чего рассчитанный результат будет выведен в поле Edit1.

Добавим в раздел объявления глобальных переменных переменные y (тип: Real) и Act (тип: Byte).

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

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

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

ПРОЦЕДУРА представляет собой набор сгруппированных вместе операторов, используемых под одним именем. Процедура состоит из заголовка и тела процедуры. Заголовок начинается ключевым словом procedure, затем следуют имя процедуры и,



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

После вызова процедуры последовательно выполняются операторы, заключенные между ключевыми словами begin..end. Ключевому слову begin могут предшествовать блоки объявления типов, констант и переменных (type, const и var).

Например, в ходе выполнения программы необходимо периодически вычислять площадь прямоугольника. Для этого создается отдельная процедура SquareRect (…):

в разделе type или private записывается заголовок процедуры:

…

procedure TForm1. SquareRect(x, y : Integer);

…

затем при нажатии комбинации клавиш Shift+Ctrl+C или выборе команды контекстного меню Complete class at cursor (Закончить реализацию класса) редактор кода среды Delphi в разделе implementation автоматически добавит пустой обработчик данной процедуры

procedure TForm1.SquareRect(x, y : Integer);

begin

end;

теперь между begin..end можно прописать сами команды процедуры:

if (x > 0) and (y > 0) then

ShowMessage(IntToStr(x * y))

else ShowMessage('Исходные данные некорректны!');

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

…

procedure TForm1.Button1Click(Sender: TObject);

begin

SquareRect(100,150);

end;

…



ФУНКЦИИ. Единственное отличие функции от процедуры состоит в том, что она всегда должна возвращать вызвавшей ее программе какое-то значение (результат своих действий).

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

В каждой из функций Delphi автоматически создается идентификатор Result, которому присваивается возвращаемое функцией значение (Result относится к тому же типу).

По аналогии с процедурой создадим свою функцию SquareRect по расчету площади прямоугольника:

объявление функции в разделе private:

заголовок и тело функции:

пример вызова функции в программе:



В результате обращения к функции SquareRect в обработчике события Button1Click программа возьмет числа, введенные в поля Edit1 и Edit2, передаст их в функцию, а затем рассчитанное значение возвратит в вызывающую процедуру. Если хотя бы одно из значений х или у окажется отрицательным или равным нулю, то функция вернем значение Result = 0, и выполнение вызывающей процедуры будет прервано.

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

В обработчики события OnClick кнопок BtnPlus, BtnMinus, BtnMultiply, BtnDivide и BtnXY вставим команду вызова этой функции и присвоения возвращаемого ею значения переменной x, а также команду присвоения переменной Act порядкового номера



выбранного пользователем математического действия: 1 – сложе-ние, 2 – вычитание, 3 – умножение, 4 – деление и 5 – возведение в степень.

…

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



10 – Осталось написать код для кнопки BtnPercent , которая предназначена для вычисления заданного процента от числа. Особенность действия данной кнопки состоит в несколько иной последовательности выполнения.

Например, чтобы вычислить 22% от числа 217, нужно:

ввести в Edit1 число 217 и нажать кнопку ("умноже-ние");

ввести в Edit1 число 22 и нажать кнопку ("процент"), после чего результат расчетов будет выведен в Edit1.

Иначе говоря, кнопка BtnPercent играет ту же роль, что и BtnEqual ("равно").

11 – Чтобы наш калькулятор был совсем похож на классический (из пакета Windows), необходимо связать нажатие клавиш клавиатуры с кнопками приложения, а также (хоть от этого и не зависит работа программы) запретить ввод в Edit1 не связанных с числами символов. Для этого используем обработчик события OnKeyPress:





Cамостоятельная работа к заданию "Самодельный калькулятор"

В качестве самостоятельной работы предлагается дополнить калькулятор еще несколькими кнопками: MC (Memory Clear) – очистить память; MR (Memory Recall) – выдать значение из

памяти; MS (Memory Store) – поместить число в память со знаком минус и сложить его с содержимым памяти; M+ (Memory Plus) – поместить число в память и сложить его с содержимым памяти.

Вниманию особых "педантов": в полученном приложении мы не можем, подобно калькулятору Windows, выравнить число по правому краю компонента Edit1, т.к. данный класс компонентов

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

Для этого следует компонент Edit1 заменить на Memo1 и, следователь-но, заменить все указания на Edit1 в коде программы. Затем дополнить код обработчиком события OnCreate для Form1, в котором прописать следующие команды:

procedure TForm1.FormCreate(Sender: TObject);

begin

Memo1.Alignment:= taRightJustify;

Memo1.MaxLength:= 30;

Memo1.WantReturns:= False;

Memo1.WordWrap:= False;

end;



Тема 10. ВЫЗЫВАЮ НА ДИАЛОГ!

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

Настало время освоить азы работы с компонентами палитры Dialogs (Диалоги), позволяющими включать в проект стандартные диалоги Windows-приложений.

Delphi содержит библиотеку компонентов, реализующих исполь-зование стандартных диалоговых окон. Все 11 компонентов размещены на палитре Dialogs. Ниже приведен список этих диалогов с кратким описанием.

Компонент Назначение

OpenDialog Окно диалога для выбора открываемого файла

SaveDialog Окно диалога для указания папки и имени сохраняемого файла

OpenPictureDialog Окно диалога для выбора открываемого графического файла

SavePictureDialog Окно диалога для указания папки и имени сохраняемого графического файла

FontDialog Окно диалога для выбора параметров шрифта (вид, размер и др. параметры)

ColorDialog Окно диалога для выбора или моделирования цвета

FindDialog Окно диалога поиска фрагментов текста

ReplaceDialog Окно диалога поиска и замены фрагментов текста

PrintDialog Окно диалога печати документа

(номера страниц, число копий и пр.)



Компонент Назначение

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

PageSetupDialog

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

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

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

Основной метод, с помощью которого происходит обращение к любому диалогу, – Execute.

Именно Execute "открывает" окно диалога и, если пользователь произвел в нем какой-то выбор, возвращает значение True. При этом в свойствах компонента запоминается выбор пользователя, и его можно использовать в дальнейших операциях.

Если же пользователь в окне диалога нажал кнопку Cancel или клавишу Esc, то функция Execute возвращает значение False.

Стандартное обращение к диалогу имеет вид: …

if <имя компонента-диалога>.Execute then

<операторы, использующие выбор пользователя>;

…

Диалоговые окна Open Dialog и Save Dialog очень похожи. Они предназначены для просмотра содержимого папок (Folders) диска и выбора требуемого файла.

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

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



кнопки в Object Inspector. В его левой части – Filter Name –записывается текст, который увидит пользователь в выпадаю-щем списке Save as type. А в правой части – Filter –записываются разделенные точками с запятой шаблоны фильтра. Например:

Свойство FilterIndex определяет номер фильтра, который будет по умолчанию показан пользователю в момент открытия диалога. Значение FilterIndex = 1 задает по умолчанию фильтр, указанный в списке первым.

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

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

Свойство Title позволяет задать заголовок окна диалога. Если это свойство не определено, окно открывается со стандартным для ОС заголовком (например, Open file).

Свойство Options (TOpenOptions) представляет собой множество и определяет условия выбора файла. Значение параметров (опций) можно задавать программно или во время проектирова-ния. По умолчанию все параметры, кроме ofHideReadOnly, выключены, т.е. установлены в значение False. Описание параметров свойства Options приведено в Приложении 6.



Специализированные диалоги открытия и сохранения графичес-ких файлов OpenPictureDialog и SavePictureDialog в основном схожи с OpenDialog и SaveDialog, отличаясь от них только в нюансах:

свойство Filter уже содержит стандартные фильтры для выбора графических файлов.

окна диалога имеют панель предварительного просмотра выбираемого файла.

Диалог выбора цвета ColorDialog обеспечивает изменение свойства Сolor (тип TColor) для любого визуального компонен-та, обладающего этим свойством, например, Form или Edit.

По умолчанию все параметры свойства Options (тип TColorDialogOptions) выключены.

FontDialog позволяет выбрать название (гарнитуру) и другие параметры шрифта, обеспечивает изменение свойства Font для любого визуального компонента, обладающего этим свойством, например, Label ("метка" или "надпись").

Рассмотрим основные свойства FontDialog:

Font (TFont) определяет параметры шрифта, управление которыми выполняется через подсвойства, такие как Name, Style, Size, Color.

MaxFontSize/MinFontSize (Integer) ограничивают доступный максимальный/минимальный размер шрифта. Свойства доступны, если включен параметр fdLimitSize.

Device (TFontDialogDevice) указывает тип устройства, для которого устанавливается шрифт, и может принимать одно из трех значений: fdScreen (вывод на экран); fdPrinter (вывод на принтер); fdBoth (вывод на экран и принтер).

Options (TFontDialogOptions) содержит настройки отдельных параметров диалога (см. в Приложении 6), важнейший из которых fdEffects по умолчанию включен.

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




1 – Открыть новый проект и сохранить его в отдельную папку Pro_DialogsExamples: имя файла проекта – Pro_DialogsExamples.dpr, имя файла модуля – DialogsExamples.pas.

2 – На форме расположить следующие компо-ненты:

Panel – 1 шт. Image – 1 шт. Memo – 1 шт. Button – 8 шт. MainMenu – 1 шт. OpenDialog – 1 шт. SaveDialog – 1 шт. OpenPictureDialog – 1 шт. SavePictureDialog – 1 шт. FontDialog – 1 шт. ColorDialog – 1 шт.

Компонент Panel1 будет использоваться в качестве контейнера для Image1.

3 – Изменить значения свойств для компонентов:

Form1: Caption = 'Standard Dialogs Usage', ClientHeight = 400, ClientWidth = 520.

Panel1: BevelInner = bvLowered, BevelOuter = bvRaised, Caption = 'Image preview box', Height = 265, Width = 240.

Image1: Align = alClient, Proportional = True, Stretch = True. Memo1: Lines – очистить, Height = 265, Width = 230. Button1: Name = BtnOpen, Caption = 'Open file'. Button2: Name = BtnSave, Caption = 'Save file'. Button3: Name = BtnFont, Caption = 'Font…'. Button4: Name = BtnOpenPict, Caption = 'Open picture'. Button5: Name = BtnSavePict, Caption = 'Save picture'. Button6: Name = BtnImageClear, Caption = 'Clear'. Button7: Name = BtnFill, Caption = 'Fill color'.

4 – Расположить все перечисленные компоненты на форме в соответст-вии с приведенным ниже образцом:



5 – В окне Menu Designer создать следующие разделы главного меню приложения:

Texts:

Images:

About program.



6 – Чтобы надпись (Caption) в Panel1 можно было воспроизвести после различных манипуляций с Image1, в обработчике события OnActivate формы запишем команду:

pCapt:= Panel1.Caption;

предварительно объявив глобальную переменную:

pCapt: String;

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

Не забудьте заполнить список разрешенных форматов файлов в свойстве Filter компонента OpenDialog1.

Для работы с jpeg-изображениями в Delphi предусмотрено два класса TJpegImage и TJpegData. Класс TJpegImage описан в модуле JPEG, поэтому для правильной работы приложения модуль JPEG надо подключить в uses.

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



Не забудьте для свойства Filter компонента SaveDialog1 скопиро-вать список форматов файлов, описанный в Filter компонента OpenDialog1.

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

Для более компактной записи этого фрагмента кода использована конструкция with … do. То, что записано между with … do, автоматически добавляется к свойствам в

строчках между begin … end, т.е. данный фрагмент мог быть записан и так:

…

if FontDialog1.Execute then

begin

Memo1.Font.Name:= FontDialog1.Font.Name;

Memo1.Font.Size:= FontDialog1.Font.Size;

Memo1.Font.Color:= FontDialog1.Font.Color;

Memo1.Font.Style:= FontDialog1.Font.Style;

end;



Вместо обращения к каждому из подсвойств свойства Font можно также использовать метод Assign:

…


Memo1.Font.Assign(FontDialog1.Font);

…

Для BtnImageClear создать заготовку процедуры на OnClick и вписать команды:

…

Image1.Picture:= nil;

Panel1.Caption:= pCapt;

Для выбора цвета заполнения используется кнопка BtnFill. При нажатии на эту кнопку программа должна вызвать окно диалога Fill Color и, при успешном его завершении, освободить компонент Image1 от загруженного в него графического файла (иначе может возникнуть исключительная ситуация) и заполнить область канвы1 Image1 выбранным в режиме диалога цветом.

8 – Пункты меню приложения связать с соответствующими обработчи-ками событий нажатия кнопок. Без запрограммированных действий остались лишь два пункта меню: Texts Clear All и About program.

Пункт меню Clear All предназначен для очистки Memo1 от текста:

Memo1.Clear;

1 Canvas является основой графической подсистемы Delphi. Ее можно рассматривать как

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



Пункт меню About program должен вызывать окно, стандартное для большинства прикладных программ Windows, содержащее общие сведения о программе. Для реализации этой задачи следует добавить еще одну форму в проект: File New Form. Затем на событие нажатия AboutProgramClick прописать команду вызова окна новой формы:

Form2.ShowModal;

На форме расположить компоненты Image1 и Label1.

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

Form2: Caption = 'About program', Height = 300, Width = 325. Image1: Align = alClient, Proportional = True, Stretch = True,

Picture = Image.bmp (желательно, чтобы размеры картинки соответствовали размеру клиентской области формы или были ей пропорциональны).

Label1: Font.Name = Cambria, Font.Size = 14, Font.Style = Bold, Caption ='Created by a student', Transparent = True (чтобы сделать цвет фона прозрачным).

Чтобы окно About program легко закрывалось, используем событие OnClick для Image1:

procedure TForm2.Image1Click(Sender: TObject);

begin

Close;

end;



Если пользователь щелкнет мышкой в области расположения Label1, то должно сработать событие Image1Click. Для этого на закладке Events ( Object Inspector) в поле события OnClick нужно выбрать ссылку на Image1Click.

И, в завершении, в обработчике события Form2Activate напишем команду, которая будет к строке, заданной в Caption компонента Label1, будет добавлять текущий год.

В результате на Label1 будет выведена следующая надпись:

9 – Самостоятельно добавить в код программы обработчик события OnApply компонета FontDialog, с помощью которого можно будет устанавливать выбранные параметры шрифта компонету Memo1, не закрывая окна диалога Font.

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

10 – Перед окончательным сохранением проекта для Form1 и Form2 загрузить в свойство Icon файл favicon.ico:

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





Тема 11. ТЕКСТОВЫЙ РЕДАКТОР СВОИМИ РУКАМИ!

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

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

компоненты с палитры Win32: TRichEdit , TStatusBar , TToolBar

и TImageList .

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

Ctrl+C – копирование выделенного текста в буфер обмена Clipboard (команда Copy);

Ctrl+X – вырезание выделенного текста в Clipboard (команда Cut);

Ctrl+V – вставка текста из Clipboard в позицию курсора (команда Paste);

Ctrl+Z – отмена последней команды редактирования текста.

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

Свойство SelAttributes относится к типу TTextAttributes и имеет подсвойства: Color (цвет), Name (имя шрифта), Size (размер), Style (стиль) и др.

Весь текст хранится в свойстве Text.

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



При использовании компонента TFontDialog присвоение выбранных в диалоге параметров шрифта выделенному фрагменту текста выполняется с помощью инструкции:


RichEdit1.SelAttributes.Assign(FontDialog1.Font);

Свойство DefAttributes содержит атрибуты шрифта по умолчанию. Они действуют до того момента, когда изменяются атрибуты в свойстве SelAttributes. Но даже после этого значения атрибутов в DefAttributes сохраняются и, при необходимости, их можно присвоить атрибутам SelAttributes, чтобы вернуться к прежнему стилю. Для этого используется метод Assign.

За выравнивание, отступы и т.п. в рамках текущего абзаца отвечает свойство Paragraph типа TParaAttributes, имеющее ряд подсвойств:

Alignment - определяет вариант выравнивания текста;

FirstIndent – указывает число пикселей отступа для первой строки абзаца ("красная строка");

Numbering - управляет маркировкой списков;

LeftIndent – задает отступ в пикселях от левого поля;

RightIndent - задает отступ в пикселях от правого поля;

TabCount - определяет количество позиций табуляции;

Tab - указывает значения позиций табуляции в пикселях.

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

Например, для текущего абзаца:

оператор выравнивания по правому краю:

RichEdit1.Paragraph.Alignment:= taRightJustify;

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

RichEdit1.Paragraph.Numbering:= nsBullet;

и его отмены:

RichEdit1.Paragraph.Numbering:=nsNone;



Позиция курсора в тексте определяется свойством SelStart.

Свойства TabCount и Tab имеют смысл только при значении свойства компонента WantTabs = True, разрешающее вводить в текст символ табуляции. Если WantTabs = False, то нажатие клавиши Tab просто переведет фокус на очередной компонент, а символ табуляции в текст не будет добавлен.

Свойство MaxLength устанавливает максимальную длину вводимого текста. При значении = 0 длина текста не ограничена.

WordWrap определяет допустимость переноса длинных строк.

Свойство CaretPos указывает местонахождение курсора:, X –содержит индекс символа в строке, перед которым расположен курсор, Y – индекс строки, в которой находится курсор. Следует учесть, что индексы начинаются с 0. Это свойство используется для отображения в строке состояния StatusBar координаты позиции курсора.

Во многих приложениях Windows имеются инструментальная линейка (ToolBar) в верхней части окна и строка состояния (StatusBar) в его нижней части.

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

StatusBar можно использовать как панель, если значение свойства SimplePanel = True. В этом случае в строку состояния через SimpleText выводится заданный текст.

Если необходимо, для StatusBar можно определить несколько подпанелей с помощью редактора свойства Panels. Каждая подпанель имеет свои собственные графические атрибуты, настраиваемые с помощью редактора. Их количество хранит свойство Panels.Count.

Чтобы выводить строку свойства Hint каждого элемента меню или инструментальной панели в StatusBar, никакого дополни-тельного кода для обработки события OnHint приложения писать не надо, – достаточно для StatusBar задать значение свойства AutoHint = True. В этом случае всплывающие подсказки будут автоматически отображаться в панели StatusBar с индексом 0, обращение к которой выглядит так:

StatusBar1.Panels[0].Text …



Компонент ToolBar представляет собой специальный контейнер для создания инструментальных панелей. Элементы ToolBar можно группировать, выравнивать, располагать в несколько рядов. Добавлять на ToolBar можно разные компонен-ты, но в полной мере его возможности проявляются только со специально разработанным для него компонентом TToolButton (инструментальная кнопка).

Вставить ToolButton в инструментальную панель можно, щелчнув правой кнопкой мыши на ToolBar и выбрав New Button Компонент ToolButton не имеет свойства хранения картинки, однако "умеет" использовать контейнер TImageList, чтобы извлечь из него нужную картинку и разместить ее на инструментальной кнопке. Для этого у ToolButton есть свойство ImageIndex (тип Integer), позволяющее выбрать номер картинки из списка TImageList.

Чтобы приложение имело более современный интерфейс реко-мендуется использовать усовершенствованную разновидность TToolBar – TCoolBar.

Компонент CoolBar (палитра Win32) предназначен для создания настраиваемых инструментальных панелей.

TCoolBar – это элемент управления, который обычно содержит в себе два или более объектов класса TСoolBand (полоса), размеры и местоположение которых можно изменять во время выполнения программы.

CoolBand является областью, которая может содержать другие элементы управления, например: панели инструментов (TToolBar), окна редактирования (TSpinEdit), выпадающие списки (TСomboBox) и даже анимацию.

Чтобы добавить полосу CoolBand, нужно в окне Object Inspector на строке свойства Band компонента CoolBar нажать на кнопку

и в раскрывшемся окне редактора Bands Editor нажать кнопку Add New (или клавишу Insert на клавиатуре). Для удаления используется кнопка Delete Selected (или клавиша Delete).



Также добавлять или удалять полосы CoolBar можно в окне Object TreeView, используя для этого кнопки и или команды контекстного меню: Add Item и Edit Delete.

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

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

кнопка Add – добавить изображение в список;

кнопка Delete – удалить изображение из списка;

кнопка Clear – очистить весь список.



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

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

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

При добавлении изображения в список можно установить значения для свойств: Transparent Color и Fill Color. Но это можно делать только в том сеансе работы с редактором списка изображений, в котором загружено данное изображение, – при повторном открытии окна ImageList Editor эти свойства будут недоступны для редактирования.

Transparent Color определяет цвет, который используется в маске для прозрачного рисования изображения. По умолчанию – это цвет левого нижнего пикселя изображения. Для иконок (*.ico) данное свойство устанавливается в clNone.

Fill Color определяет цвет, используемый для заполнения пустого пространства при перемещении и центрировании изображения. Для иконок данное свойство устанавливается в clNone.

Группа Options определяет способ размещения для bitmap-изображений, размеры которых не соответствуют размерам, принятым в списке:

Crop – отображается часть изображения, помещающаяся в область, соответствующую размеру списка, начиная с левого верхнего угла;

Stretch – размеры изображения изменяются, становясь равными размерам списка; при этом возможны искажения



изображения, если соотношение ширины и высоты загружаемого изображения не совпало с соотношением ширины и высоты списка;

Center – изображение центрируется, а если его размер больше размера списка, то не помещающиеся части просто "отсекаются".

Основные свойства ImageList:

Height (Integer) – высота изображений в списке.

Width (Integer) – ширина изображений в списке.

AllocBy (Integer) – определяет количество изображений, на которое увеличивается список для добавления новых изображений.

Count (Integer) – указывает количесвто изображений в списке (ReadOnly).


1 – В новом проекте на Form1 расположить следующие компоненты:

RichEdit1 – поле для ввода и отображения текстовой информации.

MainMenu1 – главное меню приложения. ToolBar1 и ImageList1 – для создания инструментальной

панели с иконками на кнопках. StatusBar1 – строка состояния, отображающая положение

курсора в тексте. FontDialog1 – окно диалога по изменению параметров

шрифта. OpenDialog1 и SaveDialog1 – окна диалогов по открытию и

сохранению файлов. FindDialog1 – окно диалога, позволяющее реализовать поиск

заданного фрагмента по тексту.

2 – Выполнить предварительную подготовку компонентов к работе:

RichEdit1: Align = alClient, ScrollBars = ssVertical, WantTabs = True.

ImageList1: Height = 24; Width = 24; добавить в список ImageList иконки: New, Open, Save, Print, Font, Print и About. Можно воспользоваться готовым набором Delphi (см. в папке \Program Files\Common Files\Borland Shared\Images\Buttons



или …\Icons) или другими ico- и bmp-файлами с соответ-ствующими характеристиками, которые можно скачать (например, http://www.softicons.com/free-icons – бесплатные иконки).

MainMenu1: Images = ImageList1. Создать 4 раздела главного меню приложения: File, Edit, Format и About. Кроме About, все остальные разделы должны содержать следующие строки:

Каждой строке меню (кроме Select All) назначить иконку.

StatusBar1: создать 3 панели для последующего вывода на них информации: координаты положения курсора в тексте, состояние приложения, текущая дата и время.

Ширину каждой панели StatusBar1 "привязать", т.е. сделать динамически меняющейся, к изменениям размеров формы. Для этого в обработчики событий OnActivate и OnResize вписать следующие фрагменты кода:

procedure TForm1.FormActivate(Sender: TObject);

var

i: Integer;

begin

for i:= 0 to StatusBar1.Panels.Count - 1 do

StatusBar1.Panels[i].Width:= StatusBar1.Width div

StatusBar1.Panels.Count;

end;

http://www.softicons.com/free-icons



procedure TForm1.FormResize(Sender: TObject);

begin

Form1.Activate;

end;

ToolBar1: Autosize = True, Images = ImageList1. Добавить 14 элементов ToolButton и 7 элементов Separator на инстру-ментальную панель по следующей схеме:

Каждой из кнопок назначить картинку по соответствующему индексу, в результате чего получить инструментальную панель в готовом виде:

Для каждой кнопки изменить значения свойств Name и Caption:

Name Caption Name Caption

TBtnNew New

TBtnPaste Paste

TBtnOpen Open

TBtnFotn Font…

TBtnSave Save

TBtnALeft Align Left

TBtnPrint Print

TBtnACenter Align Center

TBtnUndo Undo

TBtnARight Align Right

TBtnCut Cut

TBtnBullet Bulleted

TBtnCopy Copy

TBtnСount Count Words

Разделители на инструментальной панели пронумеровать слева направо: Name = TBSeparator1 (и т.д.), Caption = Separator1 (и т.д.).

3 – Для пункта меню About добавить новую форму в проект: File New Other… . В открывшемся окне на закладке Forms выбрать About:



Delphi добавит уже готовый образец окна About в проект с классическими элементами, которые надо будет немного подредак-тировать: Panel.Color = ClWhite, в Image.Picture загрузить любую подходящую по смыслу картинку (например, файл WordPad_icon.png на http://ru.wikipedia.org/wiki/, пересохранив его в bmp- или jpg-формате с помощью стандартной программы Windows – Paint).

Для компонента Copyright установить значения свойств: Align = alBottom, AutoSize = False, Height = 20. В обработчике события AboutBoxActivate вписать команды по окончательному оформле-нию окна формы:

http://ru.wikipedia.org/wiki/



Переключиться на модуль Unit1 и в обработчике события About1Click вписать команду вызова формы About. Обратите внимание, что при добавлении этой формы в проект свойство Name по умолчанию = AboutBox.

AboutBox.ShowModal;

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

File Save: прежде всего опишем процедуру сохранения набран-ного текста в файл. Как во всех стандартных приложениях Windows (и не только), после сохранения файла в заголовке окна приложе-ния высвечивается полный путь и имя файла, открытого в окне. Кроме того, чтобы пользователь мог видеть состояние файла (сохранен или изменен он), в среднюю панель строки состояния (индекс – 1) будет выведено 'Saved'.

При открытии нового или уже записанного на диске файла нужно обязательно производить проверку на наличие в поле RichEdit1 какого-либо текста, требующего сохранения. Для этого использует-ся свойство Lines.Count, указывающее текущее количество строк в поле RichEdit1. Если RichEdit1 не пустой, то значение будет больше 0, и пользователю должно быть выдано сообщение с предложением сохранить (или нет) в файл то, что в данный момент хранит свойство Text компонента RichEdit1.

Это сообщение должно представлять собой окно диалога с кнопками выбора Yes/No/Cancel. В зависимости от выбора пользователя действия программы будут разным: Yes – происходит сохранение, после чего открывается новый или выбранный в окне диалога Open файл; No – новый или существующий файл откры-вается без сохранения предыдущих данных; Cancel – процедура открытия нового/существующего файла прерывается.



Такой диалог с пользователем позволяет реализовать функция MessageDlg(…).

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

Вызов MessageDlg выводит на экран диалоговое окно и ожидает ответа пользователя.

Общий вид функции:

MessageDlg (const Message: string; DialogType: TMsgDlgType; Buttons: TMsgDlgButtons; HelpContext: Longint): Integer;

Параметры функции:

Message – задает текст сообщения в окне диалога. DialogType – определяет вид отображаемого окна диалога.

DialogType может иметь одно из ниже перечисленных значений:

Значение DialogType

Графический символ

Назначение окна

mtWarning

Предупреждение

mtError

Сообщение об ошибке

mtInformation

Информационное окно

mtConfirmation

Запрос на подтверждение

mtCustom нет Диалог произвольного содержания

Buttons – определяет какие кнопки будут присутствовать в окне диалога. Тип TMsgDlgBtns является множеством и включает различные кнопки. Список необходимых кнопок записывается в квадратных скобки [ ] через запятую. Если внутри скобок список отсутствует, то в окне диалога не будет



ни одной кнопки и пользователю придется закрывать окно

системной кнопкой Windows .

Значение Buttons может принимать одно из ниже перечис-ленных значений:

Значение Отображает

кнопку Значение

Отображает кнопку

mbYes mbIgnore

mbNo mbAll

mbOK mbNoToAll

mbCancel mbYesToAll

mbAbort mbHelp

mbRetry

Кроме того, Delphi также обеспечивает множество предопре-деленных комбинаций кнопок:

Значение Отображает кнопки

mbYesNoCancel

mbOKCancel

mbAbortRetryCancel

mbAbortIgnore

mbYesNoAllCancel

Функция MessageDlg возвращает значение, соответствующее выбранной пользователем кнопке. Возможные возвращаемые значения: mrYes, mrNo, mrOk, mrCancel, mrAbort, mrRetry, mrIgnore, mrAll, mbYesToAll, mbNoToAll, mrNone. Это – так называемый модальный результат (modal result) нажатия на соответствующую кнопку в окне диалога. Результат mrNone означает, что модальное окно не закрывается.

HelpContext – определяет экран контекстной справки, соответствующий данному окну диалога. Экран справки будет появляться при нажатии пользователем клавиши F1. Если справку создавать не планируется, то при вызове MessageDlg этому параметру задается нулевое значение.



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

if MessageDlg('Continue the operation?',

mtConfirmation, mbOKCancel, 0) = mrOK then

< операторы, выполняющие определенную задачу >

else Exit;

File New:

File Open:

При открытии нового или уже записанного на диске файла нужно обязательно производить проверку на наличие в поле RichEdit1



какого-либо текста, требующего сохранения. Для этого использует-ся свойство Lines.Count, указывающее текущее количество строк в поле RichEdit1. Если RichEdit1 не пустой, то значение будет больше 0, и пользователю должно быть выдано сообщение с предложением сохранить (или нет) в файл то, что в данный момент хранит свойство Text компонента RichEdit1.

Так как вариантов ответа со стороны пользователя – три (Yes, No, Cancel), то для того, чтобы можно было описать последовательность действий при каждом из них,

необходимо ввести глобальную переменную res типа TModalResult. В ней будет храниться результат выполнения диалога MessageDlg.

File Exit:

Edit Undo:

CanUndo (тип Boolean) указывает, может ли в данный момент быть применен метод Undo.

Edit Cut, Copy:

Перед выполнением команд Cut и Copy проверяем, выделен в RichEdit1 какой-либо фрагмент текста или нет.



Edit Paste:

Перед выполнением операции вставки из буфера обмена Paste следует убедиться, что в нем действительно находится текст. Для этого в список используемых модулей uses нужно добавить модуль Clipbrd, а в самой процедуре проверки обратиться к методу HasFormat глобального объекта Clipboard, который создается автоматически подобно Screen или Application.

Edit Select All:

Edit Find:

Процедура поиска заданного фрагмента в тексте состоит из 2-х этапов: обработка события OnClick для пункта меню Find (раздел Edit) и события OnFind компонента FindDialog1.

Сам по себе компонент FindDialog1 обеспечивает только интерфейс с пользователем, но никакого поиска не осуществляет. Поиск нужно реализовывать программно в обработчике события OnFind, кото-рое возникает при нажатии пользователем кнопки Find Next в окне диалога Find.

Для осуществления поиска заданного фрагмента текста необходимо использовать функции:

Pos и Copy (см. "Функции работы со строками", стр. 54);



AnsiLowerCase, которая возвращает указанную в качестве параметра строку символов, переведенную в нижний регистр (Lower Case):

function AnsiLowerCase(const S: string): string; Это необходимо в случае, когда в окне Find не отмечен флаж-ком режим Match Case, что означает "при поиске фрагмента текста не обращать внимание на регистр букв".

В программе вводится глобальная переменная FF (сокращено от FirstFind) типа Boolean, которая будет фиксировать начало или продолжение поиска: значение True говорит о начале поиска, False – о том, что пользователь уже нажимал кнопку Find Next в окне диалога Find.

В процедуре Find1Click:

устанавливается значение переменной FF = True; если перед выбором команды Find в меню Edit пользователем

был выделен фрагмент текста, то он задается как искомый фрагмент в диалоге Find с помощью свойства SelText компонента RichEdit1;

вызывается диалог поиска.

Процедура FindDialog1Find обеспечивает собственно поиск задан-ного фрагмента текста.



Локально вводятся переменные:

FindIn – хранит ту часть текста в RichEdit1, в которой будет производиться поиск; как правило, в текстовых редакторах поиск ведется, начиная с текущей позиции курсора в выбранном направлении: вниз, до конца текста, или вверх, к его началу;

FTxt – хранит символьную строку искомого фрагмента; FindCurPos – хранит текущую позицию (порядковый номер)

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

В самом начале процедуры делаем стартовые установки.

После этого отдельно описываем алгоритм поиска в направлениях Down и Up.

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



диалога кнопки Find Next, поиск продолжается в оставшейся части текста. Если искомый текст не найден, об этом выводится сообщение пользователю.

SelLength (тип Integer)– хранит длину выделенного в RichEdit1 фрагмента текста, равную количеству символов.



Format Font:



Format Align Left, Align Center, Align Right:

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

Format Bulleted List:

Format Count Words:

Подсчет количества слов выполняется по принципу поиска в тексте RichEdit1 сочетания "пробел и следующий за ним символ". Если такое сочетание найдено, то значение переменной, выполняющей роль счетчика слов, увеличивается на 1. При этом заранее исключается возможность ошибки, если первым символом в тексте



оказался пробел (строка if RichEdit1.Text[1] = ' ' then c:= 0 else c:= 1;). По окончании цикла значение переменной "с" выводится на вторую панель строки состояния.

5 – В завершение работы "привязать" к кнопкам ToolBar1 на событие OnClick процедуры выполнения соответствующих команд меню.



Cамостоятельная работа к заданию "Текстовый редактор своими руками!"

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

Добавим на форму компонент Toolbar2, и затем на панели расположим ComboBox1 (палитра Standard) и SpinEdit1 (палитра Samples). C их помощью сделаем выбор шрифта и установку его размера более удобными для пользователя.

Компонент TComboBox предназначен для выбора одного из готовых значений какой-то величины или ввода нового значения. Он состоит из собственно списка (ListBox) и размещен-ного сверху поля ввода (Edit).

Основное его свойство – Items (тип TStrings) – определяет список строк компонента. Каждая строка списка является объектом Items[i], где i – номер строки, начиная от нуля. Добавление строк в компоненты выполняется методами Add и Insert, причем Add добавляет новую строку в конец, а Insert имеет дополнительный параметр, указывающий, после какой строки разместить новую:

ComboBox1.Items.Add('RimArialBalt');

ComboBox1.Items.Insert(2,'RimRoman New');

Доступ к строкам осуществляется так:

ComboBox1.Items[0]:= 'Первая строка списка';



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

Получить саму выделенную в списке строку можно следующей инструкцией:

S:=ComboBox1.Items[ComboBox1.ItemIndex];

Чтобы при нажатии клавиши Enter пользователь мог добавить введенное новое значение в список ComboBox, используется обработчик события OnKePress:

begin

if Key = #13 then

ComboBox1.Items.Add(ComboBox1.Text);

if Key = #27 then

ComboBox1.Items.Delete(ComboBox1.Items.Count-1);

end;

У ComboBox есть свойство Sorted логического типа, которое определяет, сортируются ли элементы списка. По умолчанию оно равно False, и если установить его в True, то список будет отсортирован и новые элементы будут вставляться не в конец, а в соответствующее сортировке место.

Стиль компонента определяется свойством TComboBoxStyle. Например, значение этого свойства csDropDown устанавливает стиль, при котором список открывается (выпадает) и скрывается при нажатии кнопки, расположенной справа от текста. Такой список принято называть вьпадающим. При значении csDropDownList получим выпадающий список, но вводить произвольные данные пользователь не может.

Максимальное число элементов, которые показываются при выпадении списка, определяется свойством DropDownCount.

Значение свойства DroppedDown соответствует состоянию списка, – если оно равно True, то список будет отображаться открытым, если же задано False, то – свернутым. По умолчанию значение DroppedDown установлено в False.

Компонент TSpinEdit представляет собой комбинацию обычного редактирующего элемента (TEdit) и кнопки со стрел-ками вверх-вниз (TSpinButton). Такие элементы управления практически повсеместно используются для редактирования



числовых величин. При большом изменении величины удобнее набрать ее в редакторе вручную, если изменение незначитель-ное, – скорректировать несколькими щелчками по кнопке со стрелкой.

Текущее значение компонента TSpinEdit доступно только в числовом виде и хранится в свойстве Value.

RichEdit1.SelAttributes.Size:= SpinEdit1.Value;

Свойства MinValue и MaxValue задают нижнюю и верхнюю границы диапазона допустимых значений, а свойство MaxLength отвечает за максимальное количество цифр в значении, если оно равно нулю, то ограничений нет.

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

Свойство EditorEnabled позволяет запретить ввод данных с клавиатуры:

SpinEdit1. EditorEnabled:= False;

Для ComboBox1 установим значения свойств:

Sorted = True; Hint = 'Available Fonts List'.

Для SpinEdit1 установим значение свойства Hint = 'Font size'.

Чтобы при создании окна формы приложения:

сформировать список значений ComboBox1 (все доступные для

работы шрифты),

установить стартовое значение для ComboBox1, соответствующее

установленному для RichEdit1 шрифту,

задать стартовое значение для SpinEdit1, равное установленному для

RichEdit1 размеру шрифта,

включить показ подсказок Hint во время работы приложения,

создадим обработчик события Form1Create и пропишем в нем такой фрагмент кода:



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

Чтобы при перемещении курсора по тексту изменялись значения в окнах компонентов ComboBox1 и SpinEdit1, высвечивая соответствую-щие для данного фрагмента текста название шрифта и его размер, необходимо использовать событие RichEdit1MouseDown:



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

StatusBar1.Panels[2].Text:=

' ' + DateToStr(Date) + ' ' + TimeToStr(Time);

Для отображения служебной информации в ходе работы приложения на панелях StatusBar1 воспользуемся событием RichEdit1Change:

Для самостоятельной проработки предлагается:

Реализовать доступность кнопок Undo, Cut, Copy и Paste в зависи-

мости от ситуации, т.е. если не делалось изменений, значит кнопка

Undo должна иметь более тусклое изображение (добавить в

ImageList1 файлы с соответствующими иконками), или если ничего в

тексте не выделено, значит Cut и Copy выполнить нельзя, или если

ClipBoard пуст, то вставка (Paste) недоступна.

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

кнопкой , запрашивать (если были сделаны какие-либо изменения)

подтверждение:

и только после обработки вариантов ответа Yes или No осуществлять закрытие окна приложения. При выборе Cancel приложение должно оставаться в рабочем состоянии.



Тема 12. ГРАФИЧЕСКИЕ ПРИЕМЫ DELPHI

Рассмотрим некоторые приемы работы с графикой в среде Delphi на отдельных примерах.

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

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

В Delphi для прорисовки различных элементов управления используется специальный класс TCanvas1. Canvas является основой графической подсистемы Delphi, обеспечивая простран-ство (холст, канву) для создания, хранения и модификации графических объектов.

Выделяют 4 основных направления, в которых используется класс TCanvas:

загрузка и хранение графических изображений; создание новых и изменение хранящихся изображений с

помощью пера, кисти, шрифта; рисование и/или закраска фигур, линий, текстов; комбинирование изображений.

Каждая точка Canvas (канвы) имеет свои координаты – X и Y. Система координат Canvas, как и везде в Delphi, имеет начало в левом верхнем уголу канвы. Координата X возрастает при перемещении слева направо, а координата Y — при перемещении сверху вниз. Координаты измеряются в пикселях. Пиксель – это наименьший элемент поверхности рисунка, с

1 Windows для рисования 2D графики использует интерфейс GDI (Graphics Device Interface).

Это – самый медленный способ отображения графики, но и самый простой для понимания основ. GDI обычно не используют для создания крутых графических эффектов, для этого есть DirectX, OpenGL или др. графические библиотеки (например, DelphiX, FastLib, DIBUltra, Graphics32). Однако GDI вполне подходит для создание простых эффектов с минимальными усилиями. С GDI тесно связана ещё одно понятие – контекст устройства или DC (Device Context). Идея контекста устройства заключается в том, что это – универсальное устройство вывода (то, на чем можно "рисовать"). В Delphi контекст устройства представлен как TCanvas. Все графические функции в Delphi являются надстройками над стандартными GDI функциями Windows.



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

Рассмотрим некоторые свойства и методы класса TCanvas.

Свойство Pixels представляет собой двухмерный массив, который отвечает за цвета пикселей на канве. Например, Canvas.Pixels[15,50] соответствует цвету пикселя, 15-го слева и 50-го сверху. С этим массивом можно обращаться как с любым свойством: изменять цвет, задавая пикселю новое значение, или определять его цвет по хранящемуся в нем значению:

…

// пикселю с координатами 10,20 задаем цвет Black

Canvas.Pixels[10,20]:= 0;

// пикселю с координатами 10,25 задаем цвет Red

Canvas.Pixels[10,25]:= clRed;

Свойство Pixels также используют для рисования на канве.

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

Color – цвет, которым наносится рисунок; Width – ширина линии в пикселях (по умолчанию равна 1); Style – вид линии: psSolid (Сплошная), psDash (Штриховая),

psDot (Пунктирная), psDashDot (Штрих-пунктирная), psDashDotDot (Чередующая штрих и два пунктира), psClear (Отсутствие линии), psInsideFrame (Сплошная линия, которая при ширине более 1 пикселя допускает использова-ние цвета, отличного от палитры Windows).

Mode – режим наложения: pmCopy (цвет линии соответствует заданному в Color), pmNotXor (сложение с фоном по инверсному исключающему ИЛИ), pmMerge (объе-динение цвета пера и поверхности рисования) и т.д.

PenPos (тип TPoint) определяет в координатах Canvas текущую позицию пера.

Перемещение пера без прорисовки линии, т.е. изменение PenPos, производится методом канвы MoveTo(X,Y), где (X, Y) – координаты точки, в которую перемещается перо. От этой точки методом LineTo(X,Y) можно провести линию в точку с заданными координатами. При этом текущая точка перемещает-ся в конечную точку линии, и новое обращение к LineTo будет проводить линию уже из нее до указанных в скобках координат.



Пером можно рисовать не только прямые линии, но и фигуры. Фигуры рисуются как без цвета (пустыми), так и закрашенными с помощью свойства Brush (Кисть).

Свойство Brush, также как и Pen, имеет ряд подсвойств:

Color – цвет, которым закрашивается фигура; Style – стиль (фактура) закрашивания: bsSolid (Сплошной),

bsClear (Пустой), bsCross (В клетку), bsBDiagonal и bsFDiagonal (Диагональный), bsDiagCross (Диагональный пересекающийся), bsHorizontal (Горизонтальные линии), bsVertical (Вертикальные линии).

1 – Рассмотрим, как можно обращаться к свойству Canvas – массиву Pixels[ ].

Откроем новый проект, на форму установим компонент Edit1. C помощью оператора цикла FOR закрасим каждый пиксель канвы Image1 некоторым цветом, значение которого будет вычисляться по формуле: x * y * n, где х и у – координаты конкретного пикселя, а n – произвольный множитель, значение которого будем вводить в поле Edit1. Фрагмент кода написан для события OnKeyPress компонента Edit1, чтобы закрашивание выполнялось при каждом нажатии клавиши Enter.



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

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

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



2 – Рассмотрим способы постоения графиков функций с использова-нием Canvas компонента Image1 (хотя можно было рисовать и на Canvas самой формы).

Откроем новый проект, на форму установим компоненты Image1 и BitBtn1. Для кнопки BitBtn1 зададим значение следующих свойств:

Kind = bkOK; Caption = 'Draw Sine curve' (Нарисовать синусоиду); Layout = blGlyphRight; Font.Style = fsBold.

На событие OnClick кнопки BitBtn1 создадим обработчик и запишем команды, позволяющие нарисовать синусоиду, присваивая черный цвет каждому из пикселей, координаты которых будут вычисляться по формуле y = sin (x), где х рассчитывается с учетом ширины компонента Image1.



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

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

Попробуем сделать иначе, – нарисуем график синуса пером. Для этого добавим на форму BitBtn2. Зададим значения свойств:

Caption = 'Draw Sine curve with Pen'; Font.Style = fsBold.



Создадим обработчик события OnClick и скопируем в него весь код из процедуры BitBtn1Click, а затем внесем в этот код небольшие изменения.

Теперь толщина линии графика получилась заметно толще:

Можно для разнообразия добавить на форму компонент TSpinEdit, с помощью которого можно задавать нужную толщину линии, а также компоненты TColorBox (Additional) – для выбора цвета линии и TButton – для очистки канвы Image1.

Имя компонента Button1 изменим на BtnClear, для SpinEdit1 зада-дим MinValue = 1, MaxValue = 50 и Value =1.



Далее в обработчики событий SpinEdit1Change, ColorBox1Change и BtnClearClick запишем следующий код:

Теперь можно регулировать толщину линии и выбирать цвет по своему усмотрению.

3 – Рассмотрим на примере несложного приложения, как цвет заполнения компонента TShape задается путем выбора нужного оттенка в списке TColorBox. Причем оттенок цвета можно будет выбирать из списка стандартных цветов или же моделировать оттенок в окне Color:



На форме расзместим следующие компоненты: Shape1, ColorBox1, Label1, Memo1, RadioGroup1 и Button1.

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

Caption – надпись в левом верхнем углу панели; Items (тип TStrings) определяет надписи кнопок и их

количество;



ItemIndex показывает индекс (начиная с 0) выбранной кнопки; по умолчанию ItemIndex = –1 (отсутствие выбранной кнопки);

Columns позволяет разместить набор радиокнопок в несколько столбцов.

Предлагаемый вариант кода:

В результате получим такое приложение, которое в зависимости от выбраного пункта (радиокнопки) будет формировать разные списки для выбора оттенка цвета:

при выборе Standard список цветов включает только стандартные, "именные" цвета (ClWhite, clRed и т.д.);

при Custom программа будет предлагать окно Color для моделирования оттенка;

если выбран вариант Both, то в выпадающий список попадают стандартные и системные цвета, а также строка Custom… для вызова окна Color.



После того, как выбор в ColorBox1 сделан, происходит закрашива-ние компонета Shape1 выбранным оттенком, а название цвета (или его шестнадцатиричный эквивалент) выводится на новую строку в Memo1.

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

Ellipse – рисует эллипс, вписанный в невидимый квадрат с координатами верхнего левого и правого нижнего углов.

Canvas.Ellipse(0,0,50,50);

Если координаты Х и Y этих углов будут совпадать, то получится круг.

FillRect – заполняет прямоугольник текущей цветом кисти (Brush).

Canvas.FillRect(Bounds(0,0,100,100));

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

Canvas.FloodFill(10, 10, clBlack, fsBorder);



Rectangle – рисует прямоугольник (или квадрат), заполненный цветом кисти и обрамлённый текущим цветом пера.

Canvas.Rectangle( Bounds(20, 20, 50, 50));

RoundRect – тот же Rectangle, но с загруглёнными углами.

Canvas.RoundRect( 20, 20, 50, 50, 3, 3);

На скриншоте приведен образец формы и список компонентов, расположенных на ней.

Компоненты TSpeedButton расположены на палитре Additional.



По функционалу и виду они похож на TBitBtn. На кнопке может располагаться рисунок (свойство Gliph). Большой набор рисунков для кнопок, поставляемых вместе с Delphi, хранится в каталоге \Program Files\Common Files\Borland Shared\Images\Buttons.

У TSpeedButton имеется одно дополнительное состояние (по сравнению с TBitBtn), когда кнопка нажата, соответственно рисунок на поверхности кнопки TSpeedButton может иметь четыре картинки. Четвертая картинка будет видна, когда кнопка находиться в выбранном ("утопленном") состоянии, когда значение свойства Down равно True.

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

Листинг кода программы приведен ниже.







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



Cамостоятельная работа к заданию "Графические приемы Delphi"

Эта работа предназначена для закрепления пройденного материала. Идея рассматриваемого примера основана на материале книги Мозгового М.В. "Занимательное программирование".

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


1 – Создать новый проект. Сохранить в папку Pro_FlyingMolecule файл проекта Pro_ FlyingMolecule.dpr и файл модуля FlyingMolecule.pas.

2 – Добавить на форму компоненты Button1 и PaintBox1 (палитра System), который будет выполнять роль закрытого сосуда.


Form1: ClientHeight = 400, ClientWidth = 400. PaintBox1: Align = alClient. Button1: Name = StartStopBtn, Caption = 'Start / Stop', Left = 300,

Top = 350.



4 – Объявить глобальную переменную IfFlying, которая будет фиксиро-вать состояние молекулы: движется или нет. На момент запуска программы молекула неподвижна.

5 – Создать обработчик события нажатия кнопки StartStopBtnClick и объявить необходимые переменные и константы:

6 – Далее произвести проверку состояния молекулы (движется или нет) и, в зависимости от этого, изменять надпись на кнопке, значение переменной IfFlying, а также выполнять необходимые "манипуляции" с молекулой.

if IfFlying = True then

begin

IfFlying:= False;

StartStopBtn.Caption:= 'Start';

Exit;

end

else

begin

IfFlying:= True;

StartStopBtn.Caption:= 'Stop';

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

end;

7 – Блок операторов, описывающих движение молекулы, должен содержать команды, выполняющие следующие действия:

нарисовать молекулу, т.е. вывести на канву PainBox1 окружность заданного цвета;

разместить молекулу в случайной точке канвы;



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

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

новые координаты не "вышли" за пределы "сосуда", т.е. за границы PaintBox1; при достижении границ изменять направление движения

перед перемещением молекулы в новую позицию "стирать" ее в текущих координатах, а затем прорисовывать – в новых;

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

Функция RandomRange (RangeFrom, RangeTo) возвращает случайное целое число в диапазоне от RangeFrom до RangeTo включительно, где RangeFrom и RangeTo – произвольно

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

Функции Sin() и Cos() в качестве аргумента используют угол в радианах, поэтому пременная angle, задающая угол направления движения, вычисляется путем генерирования случайного числа в диапазоне от 0 до 360 градусов, которое затем переводится в радианы по формуле:

угол в радианах = угол в градусах * Pi / 180.

Далее в цикле (пока не нажата кнопка Stop) происходит движение молекулы в пределах границ компонента PainBox1.



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

выполнении операторов цикла, не реагирую ни на нажатие кнопки

StartStopBtn, ни кнопки закрытия окна приложения . Чтобы этого не происходило, после строки Sleep(10); добавлена процедура Application.ProcessMessages, которая предназначена для того, чтобы в ходе выполнения цикла принудительно вызвать обработку возникшего события.



8 – В ходе работы приложения можно убедиться, что молекула начинает движение или останавливается при нажатии на кнопку StartStopBtn. Но при попытке закрыть окно приложения во время движения молекулы программа лишь на мгновение приостанавли-вает свое выполнение, но не прекращает свою работу. Поэтому в завершение следует добавить в код программы обработчик события Form1Close, в котором устанавить значение переменной IfFlying равным False.

9 – Сохранить проект. Запустить приложение и убедиться в том, что программа работает правильно.

Скриншот 1 Скриншот 2 Скриншот 3

Окно приложения сразу после запуска

Окно приложения во время движения

молекулы

Окно приложения после остановки

молекулы

10 – Для небольшого эксперимента закомментируйте в коде строки: …

PaintBox1.Canvas.Pen.Color:= clBtnFace;

PaintBox1.Canvas.Brush.Color:= clBtnFace;

…

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



Тема 13. ВЕСЕЛЫЕ ШУТКИ, ИЛИ ПОЧЕМУ "ЗАМЕР" DESKTOP?

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

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

1 – Сохранить новый "пустой" проект в папку Pro_HumorApp: файл проекта Pro_HumorApp.dpr и файл с программным кодом HumorApp.pas.

2 – Изменить следующие свойства Form1:

BorderStyle = bsNone, чтобы окно приложения не имело

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

WindowState = wsMaximized, чтобы окно приложения раскрывалось на весь экран.

Position = poScreenCenter, чтобы при запуске окно прило-жения было автоматически выравнено относительно центра экрана.

После этих изменений можно запустить приложение клавишей F9. В результате окно приложения полностью закроет собой Desktop и создастся впечатление зависания компьютера, ососбенно, если изменить цвет формы на синий или черный. Закрыть приложение можно клавишами Alt+F4 или через Task Manager (Ctrl+Alt+Delete).

3 – Для того, чтобы отобразить внутри окна приложения содержимое экрана, следует добавить компонент Image1 (Additional). Свойство Align = alClient позволит жестко "привязать" размер компонента к размеру окна.

4 – Для OnCreate компонента Form1 создать обработчик события вписать в него приведенный ниже код. Освобождение памяти, выделенной для переменных ScreenDС и Canvas, выполняется двумя разными методами:

…

ReleaseDC(0, ScreenDC);

Canvas.Free;



Связано это с тем, что ScreenDС – переменная типа HDC, относящаяся к Windows API, а Canvas – переменная типа TCanvas и относится к библиотеке VCL.

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

…

Image1.Canvas.Pen.Color:= clRed;

Image1.Canvas.Pen.Width:= 20;

Image1.Canvas.MoveTo(250,150);

Image1.Canvas.LineTo(Image1.Width-250, Image1.Height-150);

Image1.Canvas.MoveTo(Image1.Width-250,150);

Image1.Canvas.LineTo(250, Image1.Height-150);





Тема 14. ВЕЛИКИЙ ХРАНИТЕЛЬ, ИЛИ КАК "РОЖДАЕТСЯ"

SCREENSAVER

Крутой графикой наш ScreenSaver (хранитель экрана) отличаться не будет. Это тема – для новичков. Вспомним, что ScreenSaver – это обычный exe-файл, только расширение у него *.scr. Исходя из этого создаем обычное приложение, а когда файл будет скомпилирован, – изменим его расширение.

Чтобы наша заставка была на переднем плане, – для свойства формы FormStyle устанавливаем значение fsStayOnTop.

Для формы устанавливаем значения свойств:

Color = clBlack. BorderStyle = bsNone WindowState = wsMaximized

Нам понадобятся следующие обработчики событий (процедуры):

FormСreate – чтобы скрыть курсор мыши и выполнить некоторые

настройки.

OnTime – для программного кода самой заставки.

OnMouseMove – с его помощью можно отследить движение мыши.

FormHide – показываем Курсор.

TimeToExit – необходима для обработки сообщений.

Опишем в разделе var программного модуля новую переменную с именем crs типа TPoint. В ней будем хранить координаты мыши во время запуска программы. Расположим на форме компонент Timer1 и создадим для него обработчик события OnTimer, куда впишем следующую команду:

Form1.Canvas.TextOut(random(Form1.ClientWidth),

random(Form1.ClientHeight),

'It is my ScreenSaver!');

Смысл данной команды: на холсте формы в произвольном порядке воспроизводится текст 'It is my ScreenSaver!' при помощи процедуры TextOut, имеющей 3 значения:

координата х (по горизонтали); координата y (по вертикали); текст для вывода.



В обработчике события OnСreate для формы напишем следующий код: …

Randomize;

//Устанавливаем интервал для таймера

Timer1.Interval:=300;

//Устанавливаем обработчик событий для сообщений

Application.OnMessage:=TimeToExit;

//Убираем курсор с глаз

ShowCursor(False);

with Form1 do

begin

// задаем размер шрифта для холста (Canvas)

Canvas.Font.Size:=17;

// выбираем название шрифта для холста

Canvas.Font.Name:='Comic Sans Ms';

// выбираем цвет шрифта

Canvas.Font.Color:=clRed;

// получаем позицию курсора

GetCursorPos(crs);

// скрываем заголовок формы

BorderStyle:=bsNone;

//Чтоб окно приложения никто "не перекрыл"

FormStyle:=fsStayOnTop;

// изменяем цвет формы

Color:=clBlack;

//Чтоб окно приложения "перекрыло" всѐ остальное

WindowState:=wsMaximized;

end;

В разделе interface напишем следующую процедуру:

procedure TimeToExit(var Msg: TMsg; var Handled: boolean);

Затем щелкнем по ней правой кнопкой мыши и Complete class at cursor, или нажмем на клавиатуре комбинацию клавиш Shift+Ctrl+C.

В появившейся процедуре напишем: …

// Если: a)получено сообщение, или b)нажата кнопка на

клавиатуре, или c)нажата левая/правая/средняя кнопка мыши,

или d)системная кнопка

if (Msg.Message = WM_KeyDown) or

(Msg.Message = WM_LButtonDown) or

(Msg.Message = WM_RButtonDown) or



(Msg.Message = WM_MButtonDown) or

(Msg.Message = WM_SysKeyDown) then close;

Отдельно, для отслеживания движения мыши, создадим обработчик события OnMouseMove, которая будет обрабатывать сообщения от Windows. Посылаемое сообщение хранится в параметре Msg.Message.

Создай обработчик события OnMouseMove для формы: …

if (abs(crs.X-X) > 5) or (abs(crs.Y-Y) > 5) then close;

(* Убираем заставку только тогда,

когда курсор мыши сдвинется больше, чем на 5 пикселей *)

Создай обработчик события OnHide для формы: …

//Запрещаем сообщения

Application.OnMessage:=nil;

//Возращаем курсору видимость

ShowCursor(True);



ВОПРОСЫ И ЗАДАЧИ ПО ТЕМЕ "ПРАКТИЧЕСКИЕ ЗАДАНИЯ"

1. Какой параметр всегда присутствует в заголовке обработчика событий?

2. Что такое таймер, для чего он используется? Перечислите его основные свойства.

3. Что такое модальное и немодальное форма? Каким образом вызывается каждая из них?

4. Как добавить новую форму в приложение? Как удалить из проекта форму?

5. Как подсоединить к форме и/или проекту иконку?

6. Как сделать главной нужную форму?

7. Опишите последовательность проектирования в приложении Delphi главного и контекстного меню.

8. Что произойдёт, если в окне Object Inspector изменить свойство Name компонента, для которого созданы обработчики событий?

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

10. Какие операции допустимы над строковыми данными?

11. В чем различие событий OnKeyDown/OnKeyUp и OnKeyPress?

12. Как можно задать точное расположение компонентов на форме относительно друг друга?

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

14. Укажите, какие из высказываний неправильные:

a. $1FF – шестнадцатиричное число

b. 'Summa' – целочисленная константа

c. 144 – целое число

d. 25A9 – шестнадцатиричное целое число



15. Чему равен будет результат выражения 68 > 93 ?

16. Укажите, каков будет результат выполнения следующих выражений:

a. 24 / 12 = …

b. 11 div = …

c. 15 + 21 div 2 = …

d. 16 mod (5 + 3) = …

17. Какие результаты выполнения выражений неправильны:

a. (3>2) and (5>6) = True

b. (60>86) or (100<90) = True

c. ('a' < 'b') and (1>0) = True

18. Строковые переменные. Максимально возможная длина строки. Функция, позволяющая определить текущую длину строки. Как можно обратиться к отдельным символам строки?

19. Приведите примеры функций обработки данных строкового типа.

20. Может ли условный оператор содержать в себе другие условные операторы?

21. Какие формы оператора цикла с параметром Вам известны?

22. Какие ограничения накладываются на переменную, используе-мую в качестве счетчика в операторе цикла For?

23. В чем состоит отличие между операторами цикла Repeat…Until и While…Do?

24. Как описываются одномерные массивы? Что такое индекс и размерность массива? Как определить минимальный объём памяти, отводимой под массив? Приведите примеры.

25. Приведите примеры компонентов, применяемых для реализации диалога с пользователем. Опишите этапы работы со стандарт-ными диалоговыми окнами. Укажите их основные методы и свойства.



26. Составьте код программы, которая будет считывать строку из Edit1, отыскать в ней все вхождения символа, заданного в Edit2, и заменять их на "–"; а полученный результат выводить на отдельную строку в Memo1. Например,

27. Приведите примеры вывода сообщений пользователю с помощью процедуры ShowMessage и функции MessageDLG.

28. Напишите программу, которая при нажатии клавиши Enter в Edit1 будет выводится на экран сообщение такого вида:

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



30. Как в приложении Delphi создаются инструментальные панели?

31. Как создать многострочную надпись (TLabel)? Возможно ли сделать многострочной надпись на кнопке?

32. Как записываются команды по изменению параметров шрифта в Memo1 (название шрифта, цвет, стиль, размер и др.)?

33. Как изменить цвет и стиль надписи?

34. Перечислите различия между компонентами TMemo и TRichText.

35. Приведите пример кода, в котором с помощью компонента Timer1 через 10 секунд после активизации формы компонент CheckBox1 станет недоступным.

36. Какие значения будет возвращать функция Random(15):

a. целые числа в диапазоне от 0 до 14

b. любые числа в диапазоне от 0 до 14

c. целые числа в диапазоне от 0 до 15

d. любые числа в диапазоне от 0 до 15

e. целые числа в диапазоне от 1 до 15

f. любые числа в диапазоне от 1 до 15

37. Каков будет результат, возвращаемый функцией после ее выполнения, если она описана пользователем как function CompareNum (X, Y: Real): Boolean; ?

a. Real

b. Boolean

c. CompareNum (True)



ТЕСТОВЫЕ ВОПРОСЫ

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

a. Нет.

b. Да.

2. Можно ли изменить значение параметра-константы в программе?

a. Нет.

b. Да.

3. Верно ли написано имя переменной «1_var»?

a. Нет.

b. Да.

4. Должна ли переменная быть объявлена до её использования?

a. Да.

b. Не всегда.

c. Нет.

5. Могут ли быть в программе одноимённые глобальные и локальные переменные?

a. Нет.

b. Да.

6. Допускается ли массив записей?

a. Да.

b. Нет.

7. Каким будет тип результата деления a/b.

a. Integer.

b. Real.

c. Boolean.

8. Чему равно для чётного числа N выражение N mod 2?

a. 0.

b. 1.



9. В какой последовательности выполняются операции при равенстве приоритета?

a. IN, AND, NOT, + .

b. NOT, AND, + , IN.

c. + , AND, NOT, IN.

10. У какой операции выше приоритет – сравнения или логической?

a. У логической операции.

b. У операции сравнения.

11. В чём состоит отличие процедуры от функции?

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

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

c. Отличий нет.

12. Допускается ли вложенность составных операторов?

a. Да.

b. Нет.

c. Не всегда.

13. Можно ли досрочно выйти из любого цикла?

a. Да, командой EXIT.

b. Да, командой BREAK.

c. Нет.

14. Можно ли выполнить цикл FOR с шагом 2?

a. Нет.

b. Да.

15. Может ли счётчик цикла с предусловием изменяться на число, отличное от единицы?

a. Нет.

b. Да.



16. Каково назначение свойства Name?

a. Для изменения содержания объекта.

b. Для вывода надписи на поверхности объекта.

c. Для ссылки на объект в программе.

17. Каково назначение свойства Caption?

a. Содержит текст, который будет отображаться вместе с объектом.

b. Определяет, является ли объект видимым или невидимым.

c. Для ссылки на объект в программе.

18. Каково назначение свойства Transparent?

a. Задает прозрачность объекта (True).

b. Устанавливает перенос слов при переполнении длины на другую строку.

c. Определяет, является ли объект видимым или невидимым.

19. Каково назначение свойства Visible?

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

b. Определяет, является ли объект видимым.

20. Каково назначение встроенных констант?

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

b. Увеличение скорости работы программы.

c. Повышение надёжности программы.

21. Каково назначение свойства AutoSize?

a. Размер объекта определяется автоматически его надписью или изображением на его поверхности (True).

b. Перенос слов при переполнении длины на другую строку.

c. Выравнивание объекта относительно контейнера, в котором находится объект.



22. Каково назначение свойства Align?

a. Высота объекта в пикселях.

b. Ширина объекта в пикселях.

c. Выравнивание объекта относительно контейнера, в котором находится объект.

23. Каково назначение свойства Enabled?

a. Разрешает либо блокирует работу с объектом.

b. Задает прозрачный объект (True).

c. Определяет, является ли объект видимым.

24. Для чего предназначен компонент Memo?

a. для ввода и/или отображения одной текстовой строки.

b. для ввода и/или отображения многострочного текста.

c. для запоминания нажатых на клавиатуре клавиш.

25. Охарактеризуйте компонент ComboBox:

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

b. позволяет выбирать одну строку из списка или непосредственно вводить ее в поле ввода.

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

26. Охарактеризуйте компонент Button?

a. кнопка быстрого доступа, т.е. не может получать фокус, фиксируется положение нажатия, и не может открывать модальные окна.

b. кнопка, которая содержит надпись и рисунок.

c. стандартная кнопка, которая содержит надпись.

27. Для чего используется компонент CheckBox?

a. для задания значений логического типа: "Да" (флажок установлен), "Нет" (флажок сброшен), "Неизвестно" (флажок запрещен).

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



28. Каково назначение компонента RadioButton?

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

b. используется для задания значений логического типа: "Да" (флажок установлен), "Нет" (флажок сброшен), "Неизвестно" (флажок запрещен).

c. это – кнопка, которая кроме надписи содержит рисунок.

Оценочная таблица к тестовым вопросам:

Количество правильных ответов

1…

3

4…

6

7…

9

10

…1

2

13

…1

5

16

…1

8

19

…2

1

22

…2

4

25

…2

6

27

…2

8

Баллы 1 2 3 4 5 6 7 8 9 10



ИСПОЛЬЗОВАННЫЕ ИСТОЧНИКИ

Н.Б. Культин. Основы программирования в Delphi 7. – СПб.: "БХВ-Петербург", 2007. – 608 стр.

М.В. Мозговой. Занимательное программирование. Самоучитель. – СПб.: "Питер", 2005. – 208 стр.

С.И. Бобровский. Delphi 7. Учебный курс. – СПб.: "Питер", 2004. – 736 стр.

А.Я. Архангельский. Delphi 7. Справочное пособие. – Москва.: "Бином", 2003. – 1024 стр.

А.Я. Архангельский. Программирование в Delphi 7. – Москва.: "Бином", 2003. – 1152 стр.

Программирование на языке Delphi. – А.Н. Вальвачев, К.А. Сурков, Д.А. Сурков, Ю.М. Четырько. – http://rsdn.ru/summary/3165.xml

Уроки Delphi начинающим с нуля – http://www.delphi-manual.ru/

Delphi. Графика и игры – http://disketa.info/page.asp?page=doc&raz=2

Основные элементы схем алгоритма. – http://ru.wikipedia.org/wiki/

http://rsdn.ru/summary/3165.xml

http://www.delphi-manual.ru/

http://disketa.info/page.asp?page=doc&raz=2

http://ru.wikipedia.org/wiki/



Приложение 1.

Основные элементы схем алгоритма

Наименование Обозначение Функция

Блок Начало–Конец

(Пуск-Остановка)

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

Блок вычислений

Выполнение одной/нескольких операций, обработка данных (изменение значения, формы представления, расположения данных). Внутри фигуры записывают операции, например, присваивания: a = 10*b + c.

Логический блок (блок условия)

Отображает решение или функцию "переключательного" типа с одним входом и двумя (или более) альтернативными выходами, из которых только один может быть выбран после вычисления условий, определенных внутри этого элемента. Например, условные операторы if (два выхода: true, false) и case (множество выходов).

Предопределенный процесс

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

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_start_stop.png

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_process.png

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_selection.png

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_preprocess.png















Наименование Обозначение Функция

Данные (ввод-вывод)

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

Граница цикла

Символ состоит из двух частей − начало и конец цикла; операции, выполняемые внутри цикла, размещаются между ними. Условия цикла и приращения записываются внутри символа начала или конца цикла − в зависимости от типа цикла.

Комментарий

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

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_io.png

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_loop.png

http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Flowchart_note.png










Значения свойства Kind компонента TBitBtn

Значение и вид кнопки

Результат установки значения

Пояснения

bkOK

Caption = 'OK' ModalResult = mrOK

Кнопка, подтверждающая ввод данных.

bkCancel

Caption = 'Cancel' ModalResult = mrCancel

Кнопка, отменяющая ввод данных.

bkYes

Caption = '&Yes' ModalResult = mrYes

Кнопка положительного ответа на вопрос.

bkNo

Caption = '&No' ModalResult = mrNo

Кнопка отрицательного ответа на вопрос.

bkAll

Caption = '&All' ModalResult = mrAll

Кнопка положительного ответа на все вопросы.

bkAbort

Caption = 'Abort' ModalResult = mrAbort

Кнопка прерывания операции.

bkRetry

Caption = '&Retry' ModalResult = mrRetry

Кнопка повторения операции.

bkIgnore

Caption = '&Ignore' ModalResult = mrIgnore

Кнопка игнорирования произошедших изменений и продолжения начатой операции.

bkHelp

Caption = '&Help'

Кнопка вызова подсказки. Вызов можно описать в обработчике события OnClick или предоставить эту работу Delphi, задав нужное значение свойству формы HelpContext.

bkClose

Caption = '&Close'

Кнопка, закрывающая форму.

bkCustom Любой Кнопка произвольных действий.




Кодировка символов в Windows

Некоторые служебные символы

Код Клавиша (символ) Код Клавиша (символ)

9 Tab 20 Caps Lock

11 Новая строка 27 Esc

13 Enter 32 Space (Пробел)

16 Shift 35, 36 End, Home

17 Ctrl 37, 39 (Left), (Right)

18 Alt 38, 40 (Up), (Down)

Символы с кодами 32 – 127

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

32 Space 48 0 64 @ 80 Р 96 ` 112 p

33 ! 49 1 65 A 81 Q 97 a 113 q

34 " 50 2 66 B 82 R 98 b 114 r

35 # 51 3 67 C 83 S 99 c 115 s

36 $ 52 4 68 D 84 Т 100 d 116 t

37 % 53 5 69 E 85 U 101 e 117 u

38 & 54 6 70 F 86 V 102 f 118 v

39 ' 55 7 71 G 87 W 103 g 119 w

40 ( 56 8 72 H 88 X 104 h 120 x

41 ) 57 9 73 I 89 Y 105 i 121 y

42 * 58 : 74 J 90 Z 106 j 122 z

43 + 59 ; 75 К 91 [ 107 k 123 {

44 , 60 < 76 L 92 \ 108 l 124 |

45 - 61 = 77 М 93 ] 109 m 125 }

46 . 62 > 78 N 94 ^ 110 n 126 ~

47 / 63 ? 79 О 95 _ 111 о 127 I



Символы с кодами 128 – 255 К

од

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

Ко

д

Си

мв

ол

128 Ђ 150 – 172 ¬ 194 Б 216 Ч 238 н

129 Ѓ 151 — 173 195 В 217 Ш 239 о

130 ‚ 152 I 174 ® 196 Г 218 Щ 240 п

131 ё 153 ™ 175 Ї 197 Д 219 Ъ 241 р

132 „ 154 ї 176 ° 198 Е 220 Ы 242 с

133 … 155 › 177 ± 199 Ж 221 Ь 243 т

134 † 156 ј 178 І 200 З 222 Э 244 у

135 ‡ 157 њ 179 є 201 И 223 Ю 245 ф

136 € 158 љ 180 ў 202 Й 224 Я 246 х

137 ‰ 159 ќ 181 µ 203 К 225 а 247 ц

138 Љ 160 182 ¶ 204 Л 226 б 248 ч

139 ‹ 161 Ѝ 183 · 205 М 227 в 249 ш

140 Њ 162 ћ 184 я 206 Н 228 г 250 щ

141 Ќ 163 Ј 185 № 207 О 229 д 251 ъ

142 Ћ 164 ¤ 186 ђ 208 П 230 е 252 ы

143 Ў 165 ѝ 187 » 209 Р 231 ж 253 ь

144 ѐ 166 ¦ 188 і 210 С 232 з 254 э

145 ‗ 167 § 189 Ѕ 211 Т 233 и 255 ю

146 ‘ 168 Ё 190 ѓ 212 У 234 й

147 ― 169 © 191 ѕ 213 Ф 235 к

148 ‖ 170 Є 192 Џ 214 Х 236 л

149 • 171 « 193 А 215 Ц 237 м

В Windows в основном используется кодировка, которая называется ANSI. Разновидность набора ANSI, содержащая символы русского алфавита, называется Windows-1251.




Таблица виртуальных кодов клавиш Windows

(VirtualKeyCodes)

Виртуальный код Соответствующая коду клавиша Hex код

VK_BACK Backspace $08

VK_TAB Tab $09

VK_RETURN Enter $0D

VK_SHIFT Shift $10

VK_CONTROL Ctrl $11

VK_MENU Alt $12

VK_CAPITAL Caps Lock $14

VK_ESCAPE Esc $1B

VK_SPACE Space bar $20

VK_INSERT Insert $2D

VK_DELETE Delete $2E

VK_END End $23

VK_HOME Home $24

VK_PRIOR Page Up $21

VK_NEXT Page Down $22

VK_LEFT Left Arrow $25

VK_UP Up Arrow $26

VK_RIGHT Right Arrow $27

VK_DOWN Down Arrow $28

VK_SNAPSHOT Print Screen $2C

VK_SCROLL Scroll Lock $91

VK_PAUSE Pause $13

VK_NUMLOCK Num Lock $90

VK_NUMPAD0 0 (NumericPad) $60







Виртуальный код Соответствующая коду клавиша Hex код






VK_MULTIPLY Multiply key "*" ( NumericPad) $6A

VK_ADD Add key "+" (NumericPad) $6B

VK_SUBTRACT Subtract key "–" (NumericPad) $6D

VK_DECIMAL Decimal key "." (NumericPad) $6E

VK_DIVIDE Divide key "/" (NumericPad) $6F

VK_F1 F1 $70

VK_F2 F2 $71

VK_F3 F3 $72

VK_F4 F4 $73

VK_F5 F5 $74

VK_F6 F6 $75

VK_F7 F7 $76

VK_F8 F8 $77

VK_F9 F9 $78

VK_F10 F10 $79

VK_F11 F11 $7A

VK_F12 F12 $7B

VK_LWIN Left Windows key $5B

VK_RWIN Right Windows key $5C

VK_APPS Applications key $5D

VK_LBUTTON Left mouse button $01

VK_RBUTTON Right mouse button $02

VK_MBUTTON Middle mouse button $04




Часто используемые классы исключительных ситуаций

Имя класса (Exception)

Когда возникает

EAbort "Тихая" (без сообщения) обработка любого исключения

EAccessViolation Обращение к недоступной области памяти, например, при выходе индекса за границы массива

EControlC Нажата комбинация клавиш CTRL+C в консольном приложении

EConvertError Ошибка преобразования данных с помощью функций IntToStr, StrToInt, StrToFloat, StrToDateTime

EDivByZero Попытка целочисленного деления на ноль

EExternalException Невозможность распознать исключительную ситуацию средствами Delphi 7

EFileStreamError Ошибка ввода/вывода при использовании файла, название которого указано в параметре FileName данного класса

EInOutError Ошибки в файловых операциях ввода/вывода; поле ErrorCode объекта объекта этого класса содержит код ошибки:

2 – File not found

3 – Invalid file name

4 – Too many open files

5 – Access denied

100 – EOF (End of file)

106 – Ivalid input

EIntError Любая ошибка в целочисленных вычислениях

EIntOverFlow Переполнение в операции с целочисленными переменными

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



Имя класса (Exception)

Когда возникает

EInvalidOp Неверная операция над числами с плавающей запятой

EInvalidPointer Неверная операция при работе с указателями

EListError, EStringListError

Неверные действия программы по отношению к разного рода спискам (например, индекс меньше 0)

EMathError Любая ошибка в вычислениях с плавающей запятой

EMenuError Ошибка при работе с меню (например, при добавлении элемента с идентификатором, ранее уже определенным в меню)

EOutOfMemory Программа запрашивает слишком большой объем памяти

EOverFlow Переполнение в операции с плавающей запятой

EPropReadOnly Попытка занесения значения в свойство объекта, доступное только для чтения (Read Only)

ERangeError Присвоение целочисленной переменной значения, выходящего за пределы допустимого диапазона

EResNotFound Генерируется, если определенный ресурс не найден; распространенная причина возникновения – удаленная или закомментированная директива {$R*.DFM} в разделе implementation модуля формы.

EUnderFlow Результат операции плавающей запятой слишком мал ("исчезновение порядка"); результат получает нулевое значение

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

EZeroDivide Попытка вещественного деления на ноль




Параметры свойства Options компонентов палитры Dialogs

Параметр Описание назначения

OpenDialog | OpenPictureDialog | SaveDialog | SavePictureDialog

ofAllowMultiSelect Позволяет пользователю выбирать несколько файлов. Если множественный выбор файлов разрешен, то список выбранных файлов хранится в свойстве Files (тип TStrings).

ofCreatePrompt В случае, если пользователь написал имя несуществующего файла, появляется замечание и запрос, надо ли создать файл с заданным именем

ofEnableIncludeNotify Разрешает посылать в диалог сообщения

ofEnableSizing Разрешает пользователю изменять размер диалогового окна

ofExtensionDifferent Показывает, что расширение файла, выбранного пользователем, отличается от DefaultExt (можно анализировать после выполнения диалога)

ofFileMustExist В случае, если пользователь написал имя несуществующего файла, появляется сообщение об ошибке

ofHideReadOnly Удаляет из диалога индикатор Open as Read Only (Открыть только для чтения)

ofNoChangeDir После щелчка на кнопке OK восстанавливает текущий каталог, независимо от того, какой каталог был открыт при поиске файла

ofNoDereferenceLinks Запрещает переназначать клавиши быстрого доступа в диалоговом окне

ofNoLongNames Отображаются не более 8 символов имени файла и трех символов расширения

ofNoNetworkButton Убирает из диалогового окна кнопку поиска в сети. Действует, только если ofOldStyleDialog установлен в True

ofReadOnly По умолчанию устанавливает индикатор Open as ReadOnly при открытии диалога




ofNoReadOnlyReturn Если пользователь выбрал файл с атрибутом Read Only, то генерируется сообщение об ошибке

ofNoTestFileCreate Запрещает выбор в сети защищенных файлов и недоступных дисков при сохранении файла

ofNoValidate Не позволяет писать в именах файлов неразрешенные символы, но не мешает выбирать файлы с неразрешенными символами

ofOldStyleDialog Создает диалог выбора файла в старом стиле

ofOverwritePrompt В случае, если при сохранении файла пользователь написал имя существующего файла, появляется замечание, что файл с таким именем существует, и от пользователя запрашивается подтверждение на перезапись существующего файла

ofPathMustExist Генерирует сообщение об ошибке, если пользователь указал в имени файла несуществующий каталог

ofShareAware Игнорирует ошибки нарушения условий коллективного доступа и разрешает произвести выбор файла

ofShowHelp Отображает в диалоговом окне кнопку Help

ColorDialog

cdFullopen Отображает дополнительную панель выбора цвета

cdPreventFullOpen Отключает кнопку Define Custom Colors

cdShowHelp Отображает кнопку Help

cdSolidColor Задает вместо выбранного ближайший сплошной цвет

cdAnyColor Выбор несплошных цветов

FontDialog

fdAnsiOnly Устанавливает режим отображения только множества шрифтов символов Windows, но не шрифтов со специальными символами




fdApplyButton Отображает в окне диалога кнопку Apply (Применить) независимо от того, предусмот-рен ли обработчик события OnApply

fdEffects Отображает флажки атрибутов Underline (Подчеркнутый) и Strikeout (Зачеркнутый), а также списка Color

fdFixedPitchOnly Устанавливает режим отображения только шрифтов с постоянной шириной символов

fdForceFontExist Позволять пользователю выбирать шрифты только из списка, запрещая ему вводить другие имена

fdLimitsize Активизирует свойства MaxFontSize и MinFontSize, устанавливающих допустимый диапазон размеров шрифта

fdNoFaceSel Открывает окно диалога без предварительно установленного имени шрифта

fdNoOEMFonts Убирает из списка шрифтов шрифты OEM

fdNoSimulations

Устанавливает режим отображения шрифтов и их начертаний, напрямую поддерживаемых файлами, не отображая шрифты, в которых стили Bold и Italic эмулируется

fdNoSizeSel Открывает окно диалога без предварительно установленного размера шрифта

fdNoStyleSel Открывает окно диалога без предварительно установленного начертания шрифта

fdNoVectorFonts Убирает из списка векторные шрифты (типа Roman или Script для Windows 1.0)

fdScalableOnly Отображает в списке только масштабируемые шрифты, убирая из него немасштабируемые (шрифты bitmap)

fdTrueTypeOnly Устанавливает режим отображения в списке только шрифтов TrueType

fdWysiwyg Устанавливает режим отображения в списке шрифтов, одновременно доступных и для экрана, и для принтера

fdShowHelp Отображать в диалоговом окне кнопку Справка




Горячие клавиши Delphi

F1 помощь

F3 продолжить поиск (начать - Ctrl+F )

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

F5 Break Point

F9 запустить программу

F10 активизировать главное меню

F11 открыть/закрыть Object Inspector

F12 переход между формой и кодом

Ctrl-F1 контекстная помощь

Ctrl-F2 прервать выполнение программы

Ctrl-F4 закрыть текущий модуль

Ctrl-F5 список переменных для просмотра (Watch List)

Ctrl-F7 просмотр значений переменных

Ctrl-F9 компилировать проект

Ctrl-F10 активизировать главное меню

Ctrl-F11 открыть проект

Ctrl-F12 список модулей проекта

Shift-F7 трассировка с заходом в каждую процедуру и перескакивание в каждое возникающее событие

Shift-F10 всплывающее меню

Shift-F11 добавить модуль к проекту

Shift-F12 список форм проекта для быстрой навигации

Alt-F4 закрыть проект и все файлы

Alt-F6 переключение окон

Alt-F8 переход к следующей ошибке компиляции

Alt-F7 переход к предыдущей ошибке компиляции

Ctrl-Shift-F4 закрыть проект и все файлы

Alt-Ctrl-F11 менеджер проектов

Ctrl-Shift-0..9 поставить метку 0..9

Ctrl-0..9 перейти на метку 0..9

Documents

PRAKTISKO DARBU UZDEVUMU...используется для хранения информации о формах и модулях. В нем содержатся операторы