Программисту приходится работать не только со строками, но и с отдельными символами. Символ – это любая буква, цифра, арифметический знак, знаки препинания или пробел. Кроме того, существуют специальные символы, например, символ перехода на новую строку. Delphi поддерживает два типа символьных данных:
AnsiChar – символ ANSI таблицы. Используется по умолчанию, то есть, когда мы указываем тип Char, подразумеваем именно этот тип.
WideChar – символ UNICODE таблицы. Разница между ними такая же, как и у строк этих типов.
Как и в случае со строками, программист обычно объявляет тип Char, что соответствует типу AnsiChar.
Логический тип данных
Логический тип данных используется в условных выражениях. Он необходим для создания логики программы. Условное выражение проверяет – соответствует ли действительность заданному условию? Если соответствует, то выражение возвращает результат True (Истина). Если не соответствует, то возвращается False (Ложь). Таким образом, логический тип данных может иметь только одно из двух этих значений.
Boolean – логический тип данных.
В таблице 4.1 приведены операнды, с помощью которых формируют логические выражения:
| Таблица 4.1. Логические операнды | |||
| Логическая операция | Описание | Логическая операция | Описание |
| = | Равно | = | Больше или равно |
| Больше | Меньше или равно | ||
| Меньше | Не равно | ||
| == | Точное равно |
Предположим, у нас есть два числа, и нужно проверить их на равенство. Эти числа хранятся в переменных целого типа a и b. Тогда выражение сравнения будет выглядеть так:
a = b;
Если в обоих переменных хранится одно и то же значение, то результатом такого сравнения будет True, иначе – False.
Занятие 4
| Begin .. end В языке программирования Delphi, как и в других языках, существуют программные скобки, показывающие начало и конец какого-либо блока кода. Эти скобки имеют вид Begin //блок кодаend; Обратите внимание, что после слова Begin точка с запятой не ставится. Эти программные скобки обязательны для каждой процедуры или функции, даже если они содержат только одну команду. Однако эти же скобки часто применяются в управляющих конструкциях или циклах. Циклы, как и управляющие конструкции, работают только с одним оператором (командой). А что, если в этом месте требуется использовать более одного оператора? Тут на помощь приходят эти самые программные скобки. Весь блок кода, сколько бы команд там не было, заключенный междуBeginиEndвоспринимается, как один оператор. Мы не раз будем использовать эти скобки. Управляющая конструкция if В предыдущих примерах нам уже приходилось применять эту конструкцию на практике, теперь пришло время познакомиться с ней поближе. Управляющая конструкция if является основной конструкцией, на которой строится логика программы. Простейший синтаксис этой конструкции выглядит так: if условие then оператор; Кто знаком с английским языком, уже ухватил суть этой конструкции. На русский язык это выражение можно перевести так: если условие то оператор; Другими словами, если какое-то заданное условие верно, то выполняется указанный оператор. Иначе этот оператор не выполняется. Часто одного оператора бывает недостаточно, тогда используют программные скобки: if условие then begin Оператор 1; Оператор 2; … Оператор n;end; Операторы, заключенные в программные скобки begin .. end воспринимаются, как единый оператор. Иногда и этого бывает недостаточно. Что, если по логике программы требуется выполнить один оператор, если условие верно, и другой, если оно неверно? Тут приходит на помощь расширенная конструкция: if условие then оператор 1else оператор2; Как видно из синтаксиса, если указанное условие истинно, то выполнится оператор 1. Иначе выполнится оператор 2. Еще одно правило, которое следует запомнить: перед словомelseточка с запятой не ставится! Конечно же, с помощью программных скобок можно расширить и эту конструкцию: if условие then begin Оператор 1; … Оператор n;end else beginОператор 1; …Оператор n;end; Сейчас самое время упомянуть о классических стилях программирования. Мы уже говорили, что хороший стиль программирования подразумевает каждый отдельный оператор писать на своей строке, применять отступы. В литературе по программированию часто встречается два классических стиля. Один стиль выглядит так: if условие then begin Оператор 1; … Оператор n;end; То есть, слово begin пишется на отдельной строке. Другой стиль выглядит иначе: if условие then begin Оператор 1; … Оператор n;end; Оба эти стиля являются классическими, какой из них применять – дело вкуса. На этой лекции будет использоваться второй стиль. Однако и это еще не все. В предыдущем примере мы рассматривали только одно условие. Если оно верно, то выполнялся один оператор, а если нет – другой. А что, если по логике программы требуется проверить более, чем одно условие? И снова мы можем расширить эту конструкцию. Взгляните на синтаксис: if условие 1 then оператор 1else if условие 2 then оператор 2else оператор 3; Здесь, если условие 1 будет верно, конструкция выполняет оператор 1 и завершает работу. Если это условие неверно, проверяется условие 2. Если условие 2 верно, то выполняется оператор 2, и конструкция завершает работу. Если же оба условия неверны, выполняется оператор 3. Расширений else if в такую конструкцию можно вставлять сколько угодно. Давайте теперь проанализируем часть кода из примера прошлой лекции. If Perem2 = 0 then begin Soobshenie; Edit3.Text := ‘0’; end else begin Perem3 := Delenie(Perem1, Perem2); Edit3.Text := FloatToStr(Perem3);end; Вам уже должно быть понятно, что если Perem2 действительно равна 0, то выполнится первый блок кода. Иначе будет выполнен второй блок кода. |
|
|
|
Цикл for Еще один мощный инструмент в Delphi – циклы. Эти циклы выполняют оператор или блок операторов заданное количество раз. Синтаксис цикла for следующий: for счетчик := нач_значение to кон_значение do оператор; В расширенном варианте синтаксис такой: for счетчик := нач_значение to кон_значение do begin оператор 1; оператор 2; … оператор n; end; Здесь:
В качестве счетчиков используют обычно целые переменные. Чтобы не тратить попусту оперативную память, счетчикам назначают тип Byte или Word, в зависимости от того, какое значение может оказаться у конечного значения. В самом начале счетчик будет равен начальному значению. Когда выполнятся все указанные операторы блока, управление вновь вернется к началу цикла. Счетчик увеличится на единицу, и цикл будет выполнен снова. И так далее, до тех пор, пока счетчик не станет равным конечному значению. Давайте изучим цикл for на примере. Пусть нам нужно перевести температуру от 0 до 100 градусов из шкалы Цельсия в шкалу Фаренгейта. Правила здесь просты: нужно взять температуру по Цельсию, умножить ее на 9/5 и к результату прибавить 32. Сам результат нужно будет программно добавить в компонент Memo в виде строки: x градусов по Цельсию = y градусов по Фаренгейту Создайте новое приложение. Сразу же свойству Name формы присвойте имя fName. В свойстве Caption напишите Перевод температур из Цельсия в Фаренгейты. Сохраните проект в новую папку. В верхнюю часть окна поместите компонент Memo и в свойстве Lines удалите из него весь текст. Растяните Memo по форме, как на рисунке 4.1:
Рис. 4.1. Внешний вид приложения Ниже Memo добавьте кнопку Button, в свойстве Caption которой укажите Расчет температур. Теперь создадим обработчик нажатия на кнопку, дважды щелкнув по ней. Процедуравыглядиттак: procedure TfName.Button1Click(Sender: TObject); var i : Byte; //счетчик begin for i := 0 to 100 do //делаемот 0 до 100 Memo1.Lines.Add(IntToStr(i) + ‘ градусовЦельсия = ‘ + FloatToStr(CelToFar(i)) + ‘ Фаренгейта’); end; Здесь следует обратить внимание на последний оператор. Оператор Memo1.Lines.Add(‘Строка’); добавляет строку ‘Строка’ в компонент Memo. При этом, в качестве строки, мы использовали сложное выражение, формирующее строку из разных частей. Разберем каждую часть подробно. IntToStr(i) в качестве результата вернет значение i (счетчика) в виде строки. Как уже говорилось, это значение за каждый проход цикла будет увеличиваться на единицу. То есть, в первом проходе i будет равна 0, во втором 1, и так далее, пока не станет равна 100. Выполнив оператор в последний раз, цикл прекратит свою работу. А мы каждый раз будем получать это число в виде строки. Далее у нас идет строка ‘ градусов Цельсия = ‘ С помощью знака + (знак конкатенации) мы добавляем одну строку к другой. В результате, при первом проходе мы получим строку ‘0 градусов Цельсия = ‘ Обратите внимание, что во второй строке в начале и в конце есть пробелы. Без пробела строки сольются: 0градусов Цельсия =, а это некрасиво. Далее мы имеем строку FloatToStr(CelToFar(i)) Функция FloatToStr() возвращает вещественное число в виде строки. В качестве вещественного числа мы использовали вызов функции CelToFar(i), передав ей в качестве параметра целое число – текущее значение счетчика. Функция использует это число, как градус Цельсия, преобразует его в Фаренгейт и вернет значение в виде вещественного числа. Этой функции пока еще не существует, мы напишем ее позже. В результате мы получим строку 0 градусов Цельсия = 32. Далее мы добавляем еще строку ‘ Фаренгейта’ в результате чего получаем готовую строку 0 градусов Цельсия = 32 Фаренгейта. И уже готовую строку с помощью метода Add() мы добавляем в компонент Memo. Еще одно правило, которое можно увидеть из этого примера – если оператор получается длинным, его можно перенести на следующую строку после арифметического знака или запятой. Функцию CelToFar() нужно будет создать выше нашей процедуры: function CelToFar(a : Byte): Real; begin Result := a * 9/5 + 32; end; Функция принимает параметр в виде целого числа, переводит его в Фаренгейты и возвращает в качестве результата, как вещественное число. Наша программа готова. Сохраните ее, скомпилируйте и посмотрите, как она работает. Если у вас не умещается весь полученный текст в Memo, добавьте в компонент вертикальную полосу прокрутки. |
Занятие 5
Объект 21/04/2014
Объект – это совокупность свойств, методов и событий. То есть объект состоит из этих свойств, методов и событий, а они обеспечивают его полноценную работу. Представим себе кнопку. Она обладает:
Свойствами – цвет, текст на кнопке, шрифт текста и так далее.
Событиями – события пользовательских действий, например, пользователь нажал на кнопку, указатель мыши оказался над кнопкой, и т.п.
Методами – обеспечивающими работу кнопки, например прорисовка кнопки в нажатом и не нажатом виде, прорисовка фокуса (то есть, фокус ввода находится на кнопке).
Раньше приходилось затрачивать много времени и усилий, чтобы нарисовать такую кнопку на форме, код кнопки мог занимать страницу – полторы. Теперь мы имеем автономный объект, который достаточно бросить на форму, и он уже готов к употреблению. Нужно две кнопки? Три? Нет проблем – кидаем на форму столько кнопок, сколько нужно, и не заботимся о том, как программно эти объекты описаны в коде. Итак,
- Свойства – это переменные, которые влияют на состояние объекта. Например, ширина, высота, положение кнопки на форме или надпись на ней.
- Методы – это те же процедуры и функции, то есть это то, что объект умеет делать (вычислять). Например, объект может иметь процедуру для вывода какого-то текста на экран. Кнопка при нажатии меняет форму – это метод кнопки, процедура прорисовки вида нажатой и не нажатой кнопки.
- События – это те же процедуры и функции, которые вызываются при наступлении определенного события. Например, пользователь нажал на кнопку, вызывается процедура обработки этого нажатия. Или мышка оказалась над кнопкой – вызывается процедура обработки этого события, если программист ее создал.
Как уже упоминалось в первой лекции, программирование с применением объектов для программиста существенно упростилось. Вместо того, чтобы вписывать сотни строк кода, описывающего поведение одной единственной кнопки, программист просто объявляет объект типа Кнопка. Далее появились системы визуального программирования, такие как Delphi, которые используют компонентную модель программирования. Здесь уже программисту не нужно самостоятельно задавать такие свойства объекта, как его положение на форме, высоту и ширину. Вы просто устанавливаете нужный компонент на форму, и мышкой или клавиатурой двигаете, растягиваете или сжимаете его до нужных размеров. Серьезное программирование превратилось в детский конструктор, где Вы создаете интерфейс программы даже не задумываясь над тем, сколько кода для этого нужно было бы написать! Delphi это делает за Вас.
Компоненты – это более совершенные объекты. То есть, это объекты, с которыми можно работать визуально. Справедливости ради следует отметить, что существуют и не визуальные компоненты, например, диалоги, с которыми нам скоро предстоит познакомиться. Не следует путать понятия объект и компонент. Каждый компонент – это объект, но не каждый объект является компонентом.
Представим себе отвлеченный пример. Допустим, у нас на палитре компонентов есть компонент ТЧел, который представляет собой усредненного человека. Если мы мышкой щелкнем по этому компоненту, а затем щелкнем по форме, то мы создадим отдельный, автономный объект этого компонента, который уже обладает всеми свойствами, методами и событиями, присущими каждому человеку.
Как у любого объекта, у него есть свойство Name – имя компонента, то имя, по которому мы будем в дальнейшем обращаться к этому объекту. Delphi по умолчанию присвоит ему текст Чел1. Если мы установим на форму еще один такой компонент, то будет создан еще один автономный объект, у которого свойство Name будет содержать строку Чел2. Итак, свойство Name – это переменная строкового типа, принадлежащая любому объекту, и являющаяся идентификатором (опознавателем), по которому к этому объекту нужно обращаться.
Далее, у нашего воображаемого объекта есть и другие свойства. К примеру, свойства Имя, Фамилия, Отчество. Это также строковые переменные, принадлежащие этому объекту. Мы можем вписать в них нужный текст программно:
Чел1.Имя := ‘Иван’;
Чел1.Отчество := ‘Иванович’;
Чел1.Фамилия := ‘Иванов’;
Обратите внимание, что свойство Name содержит имя объекта, по которому мы к этому объекту обращаемся. Если бы мы изменили в свойстве Name Чел1 на Человек, то код выглядел бы иначе:
Человек.Имя := ‘Иван’;
Точно также, эти свойства мы можем менять в Инспекторе объектов, в момент создания программы. Так, мы меняли свойства Caption у кнопок, выводя на них нужный нам текст. А перемещая кнопку на нужную позицию, мы тем самым меняли свойства Left и Top.
Далее, этот объект имеет не только строковые, но и другие типы свойств – переменных. Например, возраст (в годах) и рост (в сантиметрах) – это будут переменные целого типа:
Чел1.Возраст := 30;
Чел1.Рост := 180;
Объект может иметь и символьную переменную, например, свойство Пол (м – мужской, ж – женский):
Чел1.Пол := ‘м’;
Также такой объект может иметь и логический тип данных, например, Военнообязанный, то есть, был в армии или нет:
Чел1.Военнообязанный := True;
| Очень часто бывает, что в различных компонентах мы указываем в инспекторе объектов начальные значения, как бы по умолчанию, а затем во время работы программы меняем их на нужные. В программе с убегающей кнопкой, мы задали кнопке начальное положение, а затем, во время работы программы, мы изменяли свойства Left и Top. А когда пользователь вводил текст в компонент Edit, программно менялось его свойство Text. Итак, мы получили более-менее оформленный объект человека. Мы можем накидать целую форму таких объектов, используя компонент ТЧел, и создать целый город Челов. И у каждого заполнить приведенные в примерах свойства, так что все объекты будут разными, хотя и произошли от одного общего компонента. Вернемся к реальным компонентам. Возьмем компонент TEdit. Если мы кинем на форму такой компонент, то Delphi автоматически установит свойство Name равным строке Edit1. В дальнейшем мы будем обращаться к этому объекту по этому имени. Если же мы в Инспекторе объектов изменим свойство Name с Edit1 на, скажем, MyEdit, то обращаться придется уже не к Edit1, а к MyEdit. Предположим, мы изменили это свойство. Не забываем, что свойство Name – переменная типа строка. Далее, в компоненте TEdit нас интересуют еще несколько свойств. Это свойства Left и Top, которые имеют целый тип, и обеспечивают положение компонента на форме. Свойство Left указывает в пикселях расстояние от левой границы формы до компонента, а свойство Top – такое же расстояние от верхней границы. Еще есть свойства Width (ширина компонента) и Height (высота компонента). Это тоже целые типы, они указывают значение в пикселях. Также нас интересует свойство Text. Это строковая переменная, она указывает, какой текст отображается в этом компоненте. Мы можем ввести в него текст в Инспекторе объектов, и тогда при работе программы он сразу же будет отображаться в поле ввода. Гораздо чаще его оставляют пустым. В Инспекторе объектов просто очищают это свойство, а программно можно присвоить компоненту пустую строку: MyEdit.Text := »; Затем, во время выполнения программы, пользователь вводит какой то текст в наш Edit. Нам нужно обработать этот текст, и получить к нему доступ мы можем, указав имя нужного объекта и его свойство: s := MyEdit.Text; В данном примере мы присвоили строковой переменной s тот текст, который в данный момент хранился в поле ввода нашего компонента Edit. Напомним, что присвоение происходит справа – налево, то есть вначале указывается переменная, которой мы собираемся присвоить значение, затем идет знак присваивания :=, после чего идет то значение, которое мы присваиваем этой переменной. Мы имеем возможность программно изменить текст в этом объекте, и в данном случае будем указывать переменную – свойство Text: MyEdit.Text := ‘Новый текст’; Теперь наш объект будет отображать строку с новым текстом. Кроме того, мы программно можем изменять и другие свойства. Например, свойство Left – положение от левой границы формы. Мы можем указать: MyEdit.Left := MyEdit.Left – 5; Если мы укажем такой текст, например, в процедуре обработки нажатия кнопки, то каждый раз, когда мы нажимаем на кнопку, объект MyEdit будет сдвигаться влево на 5 пикселей. Попробуйте сами! Создайте новое приложение, установите на форму компонент TEdit и кнопку. Если Вы не изменили свойство Name, то придется обращаться к объекту по имени, которое по умолчанию присвоила ему Delphi: Edit1.Left := Edit1.Left — 5; Конечно, если Вы пишете не какую-нибудь шуточную программу, то менять положение объектов не стоит, даже если у Вас есть такие возможности. Кроме того, Вы имеете возможность программно изменить свойство Name у объекта, но это будет грубейшей ошибкой – как только программа обратится к этому объекту по старому имени, тут же произойдет ошибка выполнения программы – она просто не найдет этот объект. Можете попробовать в данном примере, дописав строку: Edit1.Name := ‘MyEdit’; Как только Вы нажмете кнопку в первый раз, объект послушно сместится влево, и сразу же за этим поменяет имя. Но попробуйте нажать кнопку еще раз, и программа сразу зависнет – она уже не видит объект с новым именем, ведь в коде обработки кнопки мы по прежнему обращаемся к объекту по старому имени, а объекта с таким именем уже не существует! Не волнуйтесь, ничего страшного не произошло. Просто выберите в меню команду Run – Program Reset. Это заставит программу досрочно прекратить выполнение и закрыться. Не забывайте еще вот о чем: не у всех компонентов, которые выводят текст на экран, есть свойство строкового типа Text. Например, у компонента TLabel таким свойством является Caption, и если мы хотим в инспекторе объектов вписать в объект какой-то текст, вписывать его нужно именно в свойство Caption. Точно также, Если мы желаем программно изменить текст в объекте Label1, то делаем присвоение нового текста его свойству Caption: Label1.Caption := ‘Новый текст’; Однако, есть объекты и посложней. Возьмем, к примеру, TMemo. У него нет свойства Text в инспекторе объектов, однако это свойство доступно программно. Переменная – свойство Text объекта Memo1 содержит весь текст, все строки, которые находятся в данный момент в компоненте. Однако гораздо чаще применяют свойство Lines. Это свойство уже не простая строковая переменная, а целый массив строк, где каждый элемент содержит отдельную строку текста. Можно сказать, что Lines – это объект в объекте, который также имеет свои методы, то есть функции и процедуры. Чаще всего используют методы SaveToFile() и LoadFromFile(), которые соответственно, сохраняют текст в файл и читают текст из файла. Свойство Lines имеет тип TStrings, то есть не просто строку, а набор строк. Многие компоненты имеют свойства такого типа. Например, компонент TListBox имеет свойство Items, которое принадлежит к тому же типу TStrings, следовательно, имеет такие же методы, как и Lines у компонента TMemo. Это значит, что вызвав нужный метод, мы можем, к примеру, считать текст из файла и в Memo, и в ListBox: Memo1.Lines.LoadFromFile(‘myfile.txt’);ListBox1.Items.LoadFromFile(‘myfile.txt’); Вы неоднократно будете встречаться со свойствами типа TStrings в разных компонентах. Это очень мощный инструмент, и нужно учиться пользоваться им. Занятие 6 События События – это процедуры, которые выполняются всякий раз, когда это событие происходит. Например, событие OnChange компонента Edit происходит всякий раз, когда меняется текст в поле ввода. События находятся на вкладке Events Инспектора объектов. Если мы ничего не создадим, то при наступлении этого события ничего и не произойдет. Однако, если мы дважды щелкнем мышью по этому событию – создастся процедура обработки этого события. И тот программный код, который мы введем, будет выполняться всякий раз, когда это событие происходит. Событие OnChange применяют довольно часто, когда нужно проверить правильные ли данные вводит пользователь. Хорошая новость – большинство событий (а также свойств и методов), у большинства компонентов одинаковы. Например, практически любой компонент для ввода пользователем текста имеет событие OnChange. Применяете ли вы Edit или Memo, это событие работает одинаково. |
|
|
|
|
Компонент Panel (Панель) Компонент Panel находится на вкладке Standard и применяется для улучшения внешнего вида формы, а также для группировки нескольких компонентов. Этот компонент по своим свойствам немного напоминает форму. Если установить несколько других компонентов на Panel, то при смещении панели будут смещаться и компоненты, установленные на ней. Изучим этот компонент на практике. Создайте новый проект, и установите на форму один компонент Panel. По умолчанию, свойству Caption панели присваивается то же имя, что и свойству Name, то есть прямо по центру панели выходит текст Panel1. Нас это не устраивает. Очистим свойство Caption панели – просто удалите этот текст, ничего туда не вписывая. Разберем другие полезные свойства этого компонента. Свойства семейства Bevel отвечают за внешний вид компонента: BevelIner и BevelOuter имеют одинаковые значения, и отвечают за то, какой панель будет выглядеть – выпуклой или вогнутой. Попробуйте изменять значения этих свойств, и Вы все поймете. BevelWidth указывает ширину оборки панели. Попробуйте изменить значение на 5. Панель выглядит экзотично, но не профессионально, лучше у этого свойства оставлять значение по умолчанию. Еще одно очень важное свойство – Align (Выравнивание). Это свойство часто используют не только у панелей, но и у многих других компонентов. Align имеет несколько значений:
Ранее мы создавали простой редактор текстов. Улучшим этот пример. Укажите у свойства Height (высота) панели значение 40. Свойство Top установите в 0. Тем самым мы прижали панель к самому верху формы. Свойству Align присваиваем значение alTop, растягивая панель по всему верхнему краю. Теперь, если пользователь станет менять размеры формы, сжимая окно или наоборот, растягивая, панель все равно будет занимать весь верх. Устанавливая на эту панель кнопки, мы получим типичную панель инструментов. Так и сделаем: установите на панель три кнопки, одну рядом с другой. На кнопках должен быть текст: Сохранить, Загрузить и Очистить. На оставшееся внизу место помещаем компонент Memo, дважды щелкаем по свойству Lines, чтобы вызвать редактор текста, и удаляем из Memo весь текст. Свойству Align компонента Memo присвоим значение alClient, чтобы растянуть Memo по всему оставшемуся месту. Вот и все, мы имеем панель инструментов и рабочую область редактора текстов. Сохраните проект, скомпилируйте его и посмотрите, как меняются размеры панели и Memo при изменении размера окна. Запрограммировать кнопки вы сможете самостоятельно, используя пример из второй лекции. Компоненты GroupBox и CheckBox GroupBox во многом похож на обычную панель. Он предназначен для группировки схожих по смыслу компонентов. Текст из свойства Caption выходит не посреди панели, а вверху, создавая таким образом заглавие этой панели. При перемещении GroupBox, будут перемещаться и все компоненты, расположенные на нем. Создайте новое приложение. Мы сделаем полезную утилиту, меняющую вид формы в зависимости от настроек. На форму установите компонент GroupBox, присвоив его свойствам Left и Top значение 6, чтобы прижать его к верхнему левому краю окна. В свойстве Caption этого компонента напишите текст BorderIcons. Поскольку обрамление компонента вплотную подходит к тексту – заголовку, с дизайнерской точки зрения будет нелишним добавить пару пробелов перед текстом, и столько же после него. Мы уже знаем, что BorderIcons – это свойство формы, программирующее ее внешний вид. Это свойство имеет 4 значения, каждое из которых можно включить, либо выключить. Таким образом, нам нужно 4 классических флажка, в которые можно будет поставить галочку или убрать ее. Роль таких флажков выполняет компонент CheckBox. Установите 4 CheckBox прямо на панель GroupBox, один над другим:
Рис. 7.1. Внешний вид приложения Измените свойство Caption этих компонентов, написав там, соответственно, biSystemMenu, biMinimize, biMaximize и biHelp. Свойство Checked компонента CheckBox показывает включен ли компонент, другими словами, установлена ли в нем галочка. У формы по умолчанию первые три значения включены, также сделаем и здесь – у первых трех компонентов CheckBox установите свойство Checked в True. Компонент RadioGroup Этот компонент также имеет вид панели и предназначен для группировки так называемых радиокнопок. Включенной может быть лишь одна такая радиокнопка. На рисунке 7.1 в правой части формы вы видите такую панель с установленными радиокнопками. Добавьте компонент RadioGroup на форму, в свойстве Caption установите текст BorderStyle, не забывая про пробелы до и после текста. Устанавливать на этой панели радиокнопки значительно легче, чем кнопки CheckBox. Выделите эту панель и дважды щелкните по ее свойству Items. Откроется редактор текста, такой же, как у Memo. В этом редакторе нужно написать названия кнопок, каждую кнопку обязательно нужно писать на отдельной строке. Напишите следующие кнопки: bsSizeable bsDialog bsNone bsSingle bsSizeToolWin bsToolWindow Как только вы нажмете ОК и закроете редактор, на панели RadioGroup появятся описанные кнопки. Ни одна из них не имеет включенного вида. Мы уже знаем, что можно включить только одну такую кнопку из списка. Компонент RadioGroup имеет свойство ItemIndex, которое указывает, какая кнопка в данный момент включена. По умолчанию, ItemIndex равен -1. Поскольку нумерация кнопок начинается с нуля, значение -1 означает, что ни одна кнопка не включена. Установите значение 0, включив тем самым первую кнопку (на форме одноименное свойство включено по умолчанию). Ниже установите кнопку, написав на ней слово Применить. Все, с дизайном окончено, переходим к программированию кнопки. Если вы еще не сохранили проект в новую папку, сделайте это сейчас. Свойству Name формы, как обычно, дайте имя fMain, модулю – просто Main, всему проекту в целом – FormViewer. Вернемся к кнопке. Щелкните дважды по ней, создав процедуру обработки нажатия кнопки. Процедураимеетследующийвид: procedure TfMain.Button1Click(Sender: TObject); begin //обрабатываемкомпонент BorderIcons if CheckBox1.Checked then fMain.BorderIcons := fMain.BorderIcons + [biSystemMenu] else fMain.BorderIcons := fMain.BorderIcons — [biSystemMenu]; if CheckBox2.Checked then fMain.BorderIcons := fMain.BorderIcons + [biMinimize] else fMain.BorderIcons := fMain.BorderIcons — [biMinimize]; if CheckBox3.Checked then fMain.BorderIcons := fMain.BorderIcons + [biMaximize] else fMain.BorderIcons := fMain.BorderIcons — [biMaximize]; if CheckBox4.Checked then fMain.BorderIcons := fMain.BorderIcons + [biHelp] else fMain.BorderIcons := fMain.BorderIcons — [biHelp]; //обрабатываемкомпонент BorderStyle case RadioGroup1.ItemIndex of 0 : fMain.BorderStyle := bsSizeable; 1 : fMain.BorderStyle := bsDialog; 2 : fMain.BorderStyle := bsNone; 3 : fMain.BorderStyle := bsSingle; 4 : fMain.BorderStyle := bsSizeToolWin; 5 : fMain.BorderStyle := bsToolWindow; end; //case end; Разберемся с кодом. Вначале мы обрабатываем первый флажок CheckBox: if CheckBox1.Checked then fMain.BorderIcons := fMain.BorderIcons + [biSystemMenu] else fMain.BorderIcons := fMain.BorderIcons — [biSystemMenu]; Если этот флажок включен, его свойство Checked вернет Истину, и тогда к свойству формы BorderIcons будет добавлена константа [biSystemMenu]. О константах, в том числе и встроенных, мы будем говорить позднее. Пока что важно одно – если мы прибавляем эту константу, то включаем это значение в свойство BorderIcons. Пример взят из встроенного справочника Delphi. Поставьте мигающий курсор внутри слова BorderIcons и нажмите . Выйдет контекстный справочник с этой командой. Если вам будет предложено выбрать между CLX и VCL, выбирайте последнюю (Visual Components Library – Библиотека визуальных компонентов). Далее щелкните по ссылке Delphi example (Пример для Delphi). В показанном в справке примере отключается кнопка Развернуть окно. Таким же образом, мы обрабатываем остальные три компонента CheckBox. Далее, идет обработка панели RadioGroup. Поскольку только одна кнопка может быть включена, то свойство ItemIndex этой панели может иметь только 6 значений, по количеству кнопок: от 0 до 5. Здесь удобней всего использовать конструкцию case. В зависимости от значения ItemIndex мы присваиваем одноименное включенной кнопке значение свойству BorderStyle формы. Вот и все. Сохраните пример, скомпилируйте и посмотрите, как работает программа. В зависимости от выбранных значений после нажатия кнопки Применить меняется внешний вид формы. В некоторых случаях ее размеры можно менять, раздвигая мышью, в некоторых – нет. В случае, если BorderStyle равен значению bsNone, пропадает и оборка окна, и верхняя системная строка формы. Поэкспериментируйте. Эта утилита может оказаться полезной в дальнейшем, если вы желаете заранее посмотреть, какие настройки выбрать, чтобы окно вашей программы выглядело именно так. Например, чтобы нельзя было менять его размеры, чтобы отсутствовали кнопки Свернуть и Развернуть и т.п. Занятие 7 |
|
|
| Свойства Enabled и Visible Эти свойства присутствуют практически у всех визуальных компонентов, и позволяют использовать интересные приемы программирования. Откройте проект с редактором текста из прошлой лекции. У вас там есть три кнопки – Сохранить, Загрузить и Очистить. Давайте предположим, что пользователь набрал какой-то важный текст и сохранил его. На следующий день он снова загрузил ваш редактор, но по ошибке вместо кнопки Загрузить он нажал кнопку Сохранить. Что произойдет? Никакого текста в данный момент компонент Memo не содержит. Если будет выполнена команда Memo1.Lines.SaveToFile(‘MyFile.txt’); то наш файл перезапишется – важный текст будет стерт, а взамен ничего не запишется, так как текста нет. Пользователь, совершив небольшую ошибку, потеряет свою работу. Конечно, виноват пользователь – он нажал не ту кнопку. Но в большей степени здесь виноват программист, что не предусмотрел такого развития событий, и не сделал для своей программы элементарной защиты от ошибок пользователя. Исправим ошибку. Свойство Enabled отвечает за доступность компонентов. Это свойство имеет логический тип, и может быть либо True, либо False. Выделите кнопку с надписью Сохранить, найдите ее свойство Enabled и вместо установленного по умолчанию значения True, выберите значение False. На форме не произошло видимых изменений, мы не сможем их увидеть в режиме разработки программы. Однако сохраните проект, скомпилируйте командой Run и посмотрите на результат – кнопка Сохранить видна на форме, но ее надпись выходит серым, неактивным цветом, а на кнопку невозможно нажать. Теперь у пользователя нет возможности нажать на эту кнопку, значит, он не совершит такой ошибки. Но это только полдела, надо все-таки в процессе работы программы ему эту возможность вернуть, иначе как же он сможет сохранить текст? В лекции 6 мы обсуждали событие OnChange, которое происходит всякий раз, когда компонент изменяется. Этим мы и воспользуемся. Выделите компонент Memo, в Инспекторе объектов перейдите на вкладку Events (События) и найдите там событие OnChange. Дважды щелкните по нему, чтобы сгенерировать процедуру – обработчик этого события. В этой процедуре запишем всего только одну строку: Button1.Enabled := True; Таким образом, при изменении компонента Memo (пользователь изменил текст), мы делаем доступной кнопку Сохранить. Теперь пользователь может сохранить свои изменения. Подумаем теперь вот о чем: когда пользователь сохранил текст, следует ли оставлять кнопку Сохранить доступной? Очевидно, нет, если у текста не произошли изменения. Поэтому щелкайте дважды по кнопке Сохранить, и после строки, где текст сохраняется, добавьте строку Button1.Enabled := False; Сразу, как только текст будет сохранен, кнопка Сохранить снова станет недоступной, пока пользователь не произведет очередных изменений в тексте. Также сделайте недоступной эту кнопку после того, как пользователь нажмет кнопку Очистка, эта кнопка очищает набранный текст, что само по себе заставляет работать событие OnChange компонента Memo, однако сохранять пустоту смысла нет. Свойство Visible компонентов работает практически также, как свойство Enabled, только вместо того, чтобы делать компонент недоступным, оно делает его невидимым. Visible также имеет логический тип, и может быть либо True (компонент видим), либо False (невидим). Самостоятельно измените все приведенные выше рекомендации, использовав вместо свойства Enabled свойство Visible. Посмотрите на результат. Скрывать или отключать можно не только кнопки, но и вообще все видимые компоненты – редактор Memo, поле Edit, надпись Label. Даже у формы есть эти свойства, поэтому при некоторой фантазии вы можете добиваться вполне профессиональных эффектов. Главное меню Любая более-менее серьезная программа имеет собственное меню. Пришла пора познакомиться с этим компонентом. Для примера снова загрузим наш редактор текстов. Выделите все кнопки на форме и удалите их. Также удалите и панель, на которой эти кнопки были. Затем нам потребуется удалить все процедуры обработки этих кнопок, но тут нужно проявить осторожность – нельзя просто взять, и удалить процедуру. Каждая сгенерированная процедура прописана в коде и выше. Чтобы без ошибок удалить все ненужные последние процедуры, следует просто удалить из них тот код, который мы писали сами, оставив пустую процедуру – имя процедуры и строчки begin.. end :
увеличить изображение Рис. 8.1. Удаление ненужных процедур После того, как вы сохраните проект, все пустые процедуры будут удалены автоматически. Это касается последних процедур – если после такой пустой процедуры будет присутствовать действующая процедура или функция, они обе останутся в коде. Таким образом, у вас должна получиться форма, на которой расположен только компонент Memo, и больше ничего. В редакторе кода не должно остаться ни одной процедуры. В общем, только заготовка программы. Выделите компонент Memo, и убедитесь, что в его свойстве Align установлено значение alClient, то есть, Memo растянуто на всю форму. На вкладке Standard найдите компонент MainMenu (главное меню), и установите его на любое место формы, прямо на компонент Memo. Компонент MainMenu не визуальный, то есть, пользователь все равно не будет его видеть. Будем создавать меню. Дважды щелкните по MainMenu, чтобы вызвать редактор меню. Когда редактор откроется, вы увидите, что первый пункт меню выделен синим цветом. Пусть выделение остается, перейдите на свойство Caption и введите текст Файл. Нажав , вы сформируете в меню команду Файл, а выделение переместится направо, к следующей команде. Другой пункт меню мы пока делать не будем, щелкните мышью немного ниже команды Файл, чтобы выделить пункт ниже. Получается, что мы сделали пункт меню Файл, и сейчас делаем подменю этого пункта. Нам потребуются следующие команды:
Рис. 8.2. Внешний вид редактора главного меню Предпоследняя команда, знак — (минус), формирует в меню разделительную полосу. Как только вы закроете редактор меню, строка с главным меню сейчас же появится над компонентом Memo. Щелкните один раз по слову Файл, и откроется подменю. Щелкните по команде Сохранить, и будет создана процедура обработки этой команды. Команда Сохранить по-прежнему выглядит, как Memo1.Lines.SaveToFile(‘MyFile.txt’); Все остальные команды введите аналогичным образом. Команда Выход выглядит так: Close; //выход из программы |
|
Занятие 8 |
|
|
Всплывающее меню
Всплывающее меню вызывается, когда пользователь щелкает правой кнопкой мыши по объекту – форме или какому либо другому компоненту. Найдите на вкладке Standard компонент PopupMenu (всплывающее меню), и также установите его поверх компонента Memo. Редактор этого меню вызывается таким же образом, как и редактор главного меню. Во всплывающем меню, однако, только одна ветка меню, где команды указываются одна под другой. Другими словами, нет возможности делать пункты меню (Файл, Правка, Вид и т.д.) и подпункты (Файл — Создать, Файл — Загрузить и т.д.).
Создайте следующие команды:
- Сохранить
- Загрузить
- Очистить
- —
- Выход
Чтобы создать обработчик события для команды, нужно дважды щелкнуть по ней в редакторе всплывающего меню. Сами команды точно такие же, как и у главного меню. Напишите код для всех указанных пунктов всплывающего меню.
Примечание: в дальнейших лекциях мы будем изучать компонент ActionList, который позволяет использовать одну команду для одноименных пунктов главного и всплывающего меню, а также панели инструментов. Пока что нам придется дублировать команды главного и всплывающего меню.
Теперь всплывающее меню нужно привязать к форме, само по себе оно работать не будет. Для этого нам нужно выделить форму, что является непростой задачей – компонент Memo растянут на все окно, и нет возможности щелкнуть по свободному месту формы. Форму проще всего выделить в окне Дерева объектов (Object TreeView). Если у вас в данный момент это окно закрыто, открыть его можно командой меню View- Object TreeView , или горячими клавишами . В этом окне легко можно выделить любой компонент, в том числе и форму.
Итак, выделите форму. В окне Инспектора объектов отразятся свойства формы. Нас интересует свойство PopupMenu. Оно имеет вид списка, в котором мы можем выбрать то или иное всплывающее меню. Поскольку такое меню у нас только одно, его и выбираем. Теперь можно сохранить проект, скомпилировать его и запустить на выполнение. Щелчок правой кнопкой на любом месте формы приведет к вызову всплывающего меню.
Всплывающее меню также называют контекстными – дело в том, что многие компоненты имеют свойство PopupMenu – редактор Memo, панели и многие другие компоненты. Можно установить несколько всплывающих меню с разными командами, и привязать к различным компонентам свои собственные PopupMenu. Тогда щелчок правой кнопкой над одним компонентом приведет к вызову одного всплывающего меню, над другим – другого.
Модальные окна
Модальнымназывается дочернее окно, которое не дает главной форме работать, пока не закончена работа этого модального окна.
До сих пор мы делали проекты только с одной формой. Настало время изучить многооконные проекты. Воспользуемся предыдущим примером – редактором текстов. Откройте этот проект, если он закрыт.
Чтобы создать новое окно, выберите команду File – New – Form.
В свойстве Caption новой формы напишите О программе, форму назовите fAbout и сохраните проект. Модуль новой формы, соответственно, назовите About.
На форму установите компонент Label, напишите в его свойстве Caption Программа: MyNotebook v 1.0
Ниже установите еще один Label. Свойство AutoSize (автоматическое изменение размера) поставьте в False, а свойство WordWrap (перенос слов на другую строку) – в True. Здесь напишите такой текст:
Программа предназначена для простого редактирования текстов. Программа позволяет сохранять текст в файл, и считывать его из файла. Файл создается там же, откуда запущена программа, и имеет имя MyFile.txt.
Ниже установим еще один Label. Пишем в нем: Автор: такой-то, можете указать свои собственные фамилию, имя и отчество. Будет красиво, если текст этого компонента выйдет посередине. Чтобы добиться этого, свойство AutoSize (автоматическое изменение размера) установите в False, свойство Aligment (выравнивание текста) в taCenter.
Ниже устанавливаем кнопку. Пишем на ней ОК и создаем обработчик кнопки для выхода из формы.
ИнструкцияCloseглавной формы закрывает всю программу, а инструкцияCloseмодального окна закрывает только это окно.
Рис. 8.3. Внешний вид формы О программе
Можете поиграть со свойствами Font и Color компонентов, чтобы форма выглядела красивей.
Подобные окна не имеют кнопок Свернуть и Развернуть, поэтому в свойстве BorderStyle формы fAbout выберите значение bsDialog. А в свойстве Position (Позиция формы при ее открытии) выберите poMainFormCenter, чтобы форма появлялась по центру главного окна. Обратите внимание на последнее свойство. Обычно для главных окон программы это свойство устанавливают в poDesktopCenter, чтобы форма появлялась по центру рабочего стола, запомните это на будущее.
Теперь, чтобы можно было вызывать это окно модально, нужно привязать его к главной форме. Сейчас в редакторе кодов имеется две вкладки – Main и About, это модули главной формы и формы О программе. Перейдите на вкладку главного окна и нажмите , чтобы вызвать это окно. Выберите команду File – Use Unit. Откроется окно, где мы увидим нашу модальную форму. Выделите ее и нажмите OK. Теперь, если Вы посмотрите код главной формы, под разделом implementation Вы увидите такую картину:
implementation
Урок 13. Символьный тип данных
