Lab1_Organizatsia_interfeysa_i_risovanie_v_form..

ТВЕРСКОЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

Кафедра ЭВМ










Программирование на языке C# в среде Microsoft Visual Studio.
Графические возможности интегрированной среды Visual Studio и основные приёмы разработки программ под Windows.



Методические указания к лабораторным работам
по курсу " Технология программирования "
для студентов 2-го курса специальности ВМКСС





Лабораторная работа ( 1















Тверь 2011
Цель лабораторной работы заключается в изучении и приобретении практических навыков работы с интегрированной средой разработки программных приложений Visual Studio.
Основными задачами, решаемыми в процессе выполнения лабораторной работы, являются:
Ознакомление с основными элементами организации графического интерфейса приложений в интегрированной среде разработки Microsoft Visual Studio
Изучение особенностей проектирования и разработки программ, предназначенных для функционирования в среде графической операционной системы Windows.
Приобретение практических навыков работы c графикой в процессе разработки простейших программных приложений.

Методическое указание обсуждено на заседании кафедры ЭВМ (протокол (___от _____________года) и рекомендовано к печати.

Составитель: проф. кафедры ЭВМ ТГТУ, д.т.н., Веселов А.А.

Содержание:

№ п/п
Раздел
Стр.

1.


13 LINK \l "Теоретическая_часть" 14Теоретическая часть15
3


1.1

13 LINK \l "Организация_интерфейса" 14Организация интерфейса15
3


1.2

13 LINK \l "Форма_и_элементы_управления" 14Форма и элементы управления15
3


1.3

13 LINK \l "Взаимодействие_форм" 14Взаимодействие форм15
5


1.4

13 LINK \l "Модальные_и_немодальные_формы" 14Модальные и немодальные формы15
6


1.5

13 LINK \l "Передача_информации_между_формами" 14Передача информации между формами15
6


1.6

13 LINK \l "Образцы_форм" 14Образцы форм15
7



1.6.1
13 LINK \l "Главная_кнопочная_форма" 14Главная кнопочная форма15
7



1.6.2
13 LINK \l "Шаблон_формы_для_работы_с_классом" 14Шаблон формы для работы с классом15
7



1.6.3
13 LINK \l "Работа_со_списками" 14Работа со списками (еще один шаблон)15
8



1.6.4
13 LINK \l "Элемент_управления_класса_ListBox" 14Элемент управления класса ListBox15
8


1.7

13 LINK \l "Наследование_форм" 14Наследование форм15
12



1.7.1
13 LINK \l "Два_наследника_формы_TwoLists" 14Два наследника формы TwoLists15
13


1.8.

13 LINK \l "Организация_меню_в_формах" 14Организация меню в формах15
16



1.8.1
13 LINK \l "Создание_меню_в_режиме_проектирования" 14Создание меню в режиме проектирования15
17



1.8.2
13 LINK \l "Классы_меню" 14Классы меню15
19



1.8.3
13 LINK \l "Создание_инструментальной_панели" 14Создание инструментальной панели с командными кнопками15
20


1.9

13 LINK \l "Рисование_в_форме" 14Рисование в форме15
22



1.9.1
13 LINK \l "Класс_Graphics" 14Класс Graphics15
22



1.9.2
13 LINK \l "Методы_класса_Graphics" 14Методы класса Graphics15
23



1.9.3
13 LINK \l "Класс_Pen" 14Класс Pen15
23



1.9.4
13 LINK \l "Класс_Brush" 14Класс Brush15
23



1.9.5
13 LINK \l "Проект_Паутина_Безье_кисти_и_краски" 14Проект «Паутина Безье, кисти и краски»15
23



1.9.6
13 LINK \l "Паутина_Безье" 14Паутина Безье15
24



1.9.7
13 LINK \l "Событие_Paint" 14Событие Paint15
26



1.9.8
13 LINK \l "Кисти_и_краски" 14Кисти и краски15
26

2


13 LINK \l "Задание_на_лабораторную_работу" 14Задание на лабораторную работу15
29

3


13 LINK \l "Содержание_отчёта" 14Содержание отчета по лабораторной работе15
29

4


13 LINK \l "Вопросы_для_самопроверки" 14Вопросы для самопроверки15
29



1. Теоретическая часть
1.1. Организация интерфейса
Целью данной работы является разработка интерфейса для Windows-приложений в среде Microsoft Visual Studio. Windows-проект по умолчанию содержит класс Form1, который является наследником класса Form. Этот класс содержит точку входа в проект – процедуру Main, вызывающую статический метод Run класса Application, который создает объект класса Form1 и открывает форму – видимый образ объекта – для интерактивной работы пользователя с приложением. Открываемая форма содержит пользовательский интерфейс – окошки, кнопки, списки, другие элементы управления, меню. Все эти элементы способны реагировать на события, возникающие при выполнении пользователем каких-либо действий – нажатии кнопок, ввод текста, выбор пунктов меню.
1.2. Форма и элементы управления
Как воспользоваться форму элементами управления в своих приложениях? Для этого Visual Studio имеется специальная панель (Toolbox), на которой отображаются все доступные элементы управления, которые можно перетаскивать на форму. Этот процесс поддерживается специальным инструментарием – дизайнером форм (Designer Form). Как только на этапе проектирования размещается на форме элемент управления, то немедленно в тексте класса появляются соответствующие строки кода. Конечно, все можно делать и программно – появление соответствующих строк кода приводит к появлению элементов управления на форме. Но нужно понимать, что форма – это видимый образ класса Form, а элементы управления, размещенные на форме, – это видимые образы клиентских объектов соответствующих классов – наследников класса Control. Так что форма с ее элементами управления непосредственно отображается в виде соответствующего программного кода.

Каждый элемент управления описывается собственным классом. Библиотека FCL содержит большое число классов, задающих различные элементы управления. В Microsoft Visual Studio можно создать тип проекта, позволяющий создавать элементы управления, так что ничто не мешает создавать собственные элементы управления и размещать их на формах наряду со встроенными элементами управления.
В каких отношениях находятся класс Form, класс Control, классы элементов управления? На рис.1 показана иерархия отношений, связывающих эти классы.

Рис. 1. Иерархия классов элементов управления
Естественно все эти классы являются потомками прародителя – класса object. Следует заметить, что класс Control в иерархии классов занимает довольно высокое положение, хотя и у него есть два важных родительских класса – класс Component, определяющий возможность элементам управления быть компонентами, и класс MarshalByRefObject, задающий возможность передачи элементов управления по сети. Класс Control задает важные свойства, методы и события, наследуемые всеми его потомками. Все классы элементов управления являются наследниками класса Control. Чаще всего, это прямые наследники, но иногда они имеют и непосредственного родителя, которым может быть абстрактный класс – это верно для кнопок, списков, текстовых элементов управления. Может показаться удивительным, но класс Form является одним из потомков класса Control, так что форма – это элемент управления со специальными свойствами. Будучи наследником классов ScrollableControl и ContainerControl форма допускает прокрутку и размещение элементов управления.

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

Следует четко различать процесс создания формы, как соответствующего объекта, класса Form или наследнику этого класса, и процесс показа формы на экране. Для показа формы служит метод Show этого класса, вызываемый соответствующим объектом. Для скрытия формы используется метод Hide. Реально методы Show и Hide изменяют свойство Visible объекта, так что вместо вызова этих методов можно изменять значение этого свойства, устанавливая его значение либо в true, либо в false.
Следует видеть разницу между сокрытием формы и ее закрытием (т.е. между методами Hide и Close. Первый из них делает форму невидимой, но сам объект продолжает оставаться в памяти (т.е. - живым и невредимым). Метод Close отбирает у формы все ее ресурсы, делая объект недоступным, и удаляет его из памяти. Если не создать объект заново, то вызвать метод Show после вызова метода Close невозможно, поскольку формы уже не существует. Открытие и показ формы всегда означает одно и то же – вызов метода Show. У формы есть метод Close, но нет метода Open. Формы, как и все объекты, создаются при вызове конструктора формы при выполнении операции new.

Форма, открываемая в процедуре Main при вызове метода Run, называется главной формой проекта. Ее закрытие приводит к закрытию всех остальных форм и завершению Windows-приложения. Завершить приложение можно и программно, вызвав в нужный момент статический метод Exit класса Application. Закрытие других форм не приводит к завершению проекта. Зачастую главная форма проекта всегда открыта, в то время как остальные формы проекта открываются и закрываются (скрываются). Если необходиммо, чтобы в каждый текущий момент была открыта только одна форма, то нужно принять определенные меры, чтобы при закрытии (скрытии) формы открывалась другая форма. Иначе возможна клинчевая ситуация, – все формы закрыты, предпринять ничего нельзя, а приложение не завершено. Конечно, выход всегда есть – всегда можно нажать магическую тройку клавиш CTRL +ALT +DEL и завершить любое приложение.
Можно создавать формы как объекты класса Form. Однако такие объекты довольно редки. Чаще всего создается специальный класс FormX – наследник класса Form. Так, в частности происходит для Windows-приложения, создаваемого по умолчанию, когда создается класс Form1 – наследник класса Form. Так происходит и в режиме проектирования, когда в проект добавляется новая форма, используя пункт меню Add Windows Form. Как правило, каждая форма в проекте – это объект собственного класса. Если когда вновь создаваемая форма должна быть похожа на уже существующую форму, тогда класс новой формы может быть сделан наследником класса существующей формы.
1.4. Модальные и немодальные формы
Первичным является понятие модального и немодального окна. Окно называется модальным, если нельзя закончить работу в открытом окне до тех пор, пока оно не будет закрыто. Модальное окно не позволяет временно переключиться на работу с другим окном, оставив модальное окно открытым. Выйти из модального окна можно, только закрыв его. Немодальные окна допускают параллельную работу с другими окнами. Метод Show открывает форму как немодальную, а метод ShowDialog открывает форму как модальную. Название метода отражает основное назначение модальных форм, которые предназначены только для организации диалога с пользователем. Пока диалог не завершится, покидать форму не разрешается.
1.5. Передача информации между формами
Часто многие формы работают с одним и тем же объектом, производя над ним различные операции. Как это делается? Обычная схема такова: такой объект создается в одной из форм, чаще всего, в главной. При создании следующей формы глобальный объект передается конструктору новой формы в качестве аргумента. Естественно, что одно из полей новой формы должно представлять ссылку на объект соответствующего класса, так что конструктору останется только связать ссылку с переданным ему объектом. Заметьте, все это эффективно реализуется, поскольку объект создается лишь один раз, а разные формы содержат ссылки на этот единственный объект.
Если такой глобальный объект создается в главной форме, то можно передавать не объект, требуемый другим формам, а содержащий его контейнер – главную форму. Это удобнее, поскольку при этом можно передать несколько объектов, можно не задумываться над тем, какой объект передавать той или иной форме. Иметь ссылку на главную форму часто необходимо, хотя бы для того, чтобы при закрытии любой формы можно было бы открывать главную форму, если она была предварительно скрыта.
Представим себе, что несколько форм должны работать с объектом класса Books. Пусть в главной форме такой объект объявлен:
public Books myBooks;
В конструкторе главной формы такой объект создается:
myBooks = new Books(max_books);
где max_books – заданная константа.
Пусть еще в главной форме объявлена форма – объект класса NewBook:
public NewBook form2;
При создании объекта form2 его конструктору передается ссылка на главную форму:
form2 = new NewBook(this);
Класс newBook содержит поля:
private Form1 mainform;
private Books books;
а его конструктор следующий код:
mainform = form;
books = mainform.myBooks;
Теперь объекту form2 доступны ранее созданные объекты, задающие книги и главную форму, так что в обработчике события Closed, возникающего при закрытии формы, можно задать код:
private void NewBook_Closed(object sender, System.EventArgs e)
{
mainform.Show();
}
открывающий главную форму.
1.6. Образцы форм
Создание элегантного и интуитивно понятного интерфейса пользователя – это своего рода искусство, требующее определенного художественного вкуса. Здесь все играет важную роль – размеры и расположение элементов управления, шрифты, цвет. Всвязи с этим полезно знать некоторые основные правила и приемы организации интерфейса.
1.6.1. Главная кнопочная форма
Одним из образцов, применимых к главной форме, является главная кнопочная форма. Такая форма состоит из изображения окна с соответствующим набором управляющих элементов, позволяющих решать задачи, поддерживаемые приложением. В качестве примера рассмотрим Windows-приложение, позволяющее работать с различными динамическими структурами данных. Главная кнопочная форма такого приложения показана на рис. 2.

Рис.2. Главная кнопочная форма
Обработчик события Click для каждой командной кнопки открывает форму для работы с соответствующей динамической структурой данных. Вот как выглядит обработчик события кнопки "Список":
private void button4_Click(object sender, System.EventArgs e)
{
//Переход к показу формы для работы со списком
FormList f1= new FormList();
F1.Show();
}
Как видите, открывается новая форма для работы со списком, но главная форма не закрывается и остается открытой.
1.6.2. Шаблон формы для работы с классом
Можно предложить следующий образец формы, предназначенной для поддержки работы с объектами некоторого класса. Напомню, каждый класс представляет тип данных. Операции над типом данных можно разделить на три категории: конструкторы, команды и запросы. Конструкторы класса позволяют создать соответствующий объект, команды, реализуемые процедурами, изменяют состояние объекта, запросы, реализуемые функциями без побочных эффектов, возвращают информацию о состоянии объекта, не изменяя самого состояния. Исходя из этого, можно сконструировать интерфейс формы, выделив в нем три секции. В первой секции, разделенной на три раздела будут представлены команды, запросы и конструкторы. Следующая секция выделяется для окон, в которые можно вводить аргументы исполняемых команд. Последняя секция предназначается для окон, в которых будут отображаться результаты запросов.
На рис.3 показана форма для списка с курсором, построенная в соответствии с описанным шаблоном:

Рис.3. Форма для списка с курсором, построенная по образцу
Список с курсором имеет группу команд, позволяющих перемещать курсор вверх, вниз, к началу и концу списка, к элементу с заданным номером. Другая группа команд позволяет производить операции по вставке элементов сверху или снизу от курсора, удалять элемент, отмеченный курсором. Еще одна группа команд позволяет производить поиск элементов в списке. Запросы позволяют получить данные об активном элементе, отмеченном курсором, определить число элементов в списке и получить другую полезную информацию.
1.6.3. Работа со списками (еще один шаблон)
Для организации интерфейса разработано большое число элементов управления, часть из них была показана на рис.1. Все они обладают большим набором свойств, методов и событий, их описание может занять отдельную книгу. Такие элементы как, например: ListView, TreeView, DataGrid несомненно заслуживают отдельного рассмотрения. Однако, ограничимся более подробным рассмотрением лишь одного элемента управления – ListBox – позволяющего отображать данные в виде некоторого списка.
1.6.4. Элемент управления класса ListBox
Во многих задачах пользователю предлагается некоторый список товаров, гостиниц, услуг и прочих прелестей и он должен выбрать некоторое подмножество элементов из этого списка. Элемент управления ListBox позволяет собрать в виде списка некоторое множество объектов и отобразить для каждого объекта связанную с ним строку. Он дает возможность пользователю выбрать из списка один или несколько элементов.
В списке могут храниться строки, тогда объект совпадает с его отображением. Если же хранятся объекты, то в классе объекта следует переопределить метод ToString, возвращаемый результат которого и будет строкой, отображаемой в списке.
Давайте рассмотрим главный вопрос, как список заполняется элементами? Есть несколько разных способов. Новой и интересной технологией, применимой к самым разным элементам управления, является связывание элемента управления с данными, хранящимися в различных хранилищах, прежде всего, в базах данных. Для этого у списка есть ряд свойств – DataBinding и другие. Эта технология заслуживает отдельного рассмотрения и, поэтому, сейчас мы ее рассматривать не будем. Рассмотрим три других способа.
Заполнить список элементами можно еще на этапе проектирования. Для этого достаточно выбрать в окне свойств списка - свойство Items. В результате появится специальное окно для заполнения списка строками – элементами списка. Добавлять объекты других классов таким способом невозможно.
Но это можно делать при программной работе со свойством Items, возвращающим специальную коллекцию объектов, заданную классом ObjectCollection. Эта коллекция представляет объекты, хранимые в списке, и является основой для работы со списком. Класс ObjectCollection предоставляет стандартный набор методов для работы с коллекцией – вставки, удаления и поиска элементов. Метод Add позволяет добавить новый объект в конец коллекции, метод Insert позволяет добавить элемент в заданную позицию, указанную индексом. Метод AddRange позволяет добавить сразу множество элементов, заданное обычным массивом, массивом класса ListArray или коллекцией, возвращаемой свойством Items другого списка. Для удаления элементов из коллекции используются методы Remove, RemoveAt, Clear. Метод Contains позволяет определить содержится ли заданный объект в коллекции, а метод IndexOf позволяет определить индекс такого элемента. Коллекция может автоматически сортироваться, для этого достаточно задать значение true свойства Sorted, которым обладает список ListBox.
Еще один способ задания элементов списка поддерживается свойством DataSource, значение которого позволяет указать источник данных, ассоциируемый со списком. Понятно, что этот способ является альтернативой коллекции, задаваемой свойством Items. Так что, если источник данных определен свойством DataSource, то нельзя использовать методы класса ObjectCollection – Add и другие для добавления или удаления элементов списка, – необходимо изменять сам источник данных.
Главное назначение элемента ListBox – предоставить пользователю возможность осуществлять выбор из отображаемых списком элементов. Свойство SelectionMode позволяет указать, сколько элементов разрешается выбирать пользователю – один или несколько. Для работы с отобранными элементами имеется ряд свойств – SelectedItem и SelectedIndex возвращают первый отобранный элемент и его индекс. Свойства SelectedItems и SelectedIndices возвращают коллекции, заданные классами SelectedObjectCollection и SelectedIndexCollection, позволяющие анализировать все отобранные пользователем объекты. Методы Contains и IndexOf позволяют определить выбрал ли пользователь некоторый элемент или нет. Добавлять или удалять элементы из этих коллекций нельзя.
Среди других методов и свойств ListBox следует упомянуть свойство MultiColumn, позволяющее организовать показ элементов списка в нескольких столбцах, свойство HorizonalScrollBar, задающее горизонтальный скроллинг, методы BeginUpdate и EndUpdate, позволяющие повысить эффективность работы со списком. Все методы по добавлению и удалению элементов, стоящие после BeginUpdate, не будут приводить к перерисовке списка, пока не встретится метод EndUpdate.
У элемента управления ListBox большое число событий, с некоторыми из которых мы встретимся при рассмотрении примеров. Перейдем теперь к рассмотрению примеров работы с этим элементом управления и, как обещано, построим некоторую форму, демонстрирующую работу с двумя списками, когда пользователь может переносить данные из одного списка в другой и обратно. На рис. 4 показано, как выглядит форма, реализующая данный шаблон:

Рис. 4. Шаблон формы для обмена данными двух списков
На форме показаны два списка – listBox1и listBox2, между которыми расположены две командные кнопки. Обработчик события Click первой кнопки переносит выбранную группу элементов одного списка в конец другого списка (если включено свойство Sorted, то автоматически поддерживается сортировка списка). Переносимые элементы удаляются из первого списка. Вторая кнопка реализует операцию переноса всех элементов списка. Направление переноса – из левого списка в правый и обратно – задается заголовками (“>”, “>>”) или (“<”, “<<”), изображенными на кнопках. Заголовки меняются автоматически в обработчиках события Enter, возникающих при входе в левый или правый списки – listBox1 или listBox2. Еще две командные кнопки, как следует из их заголовков, предназначены для закрытия формы с сохранением или без сохранения результатов работы пользователя. Таково общее описание шаблона. А теперь рассмотрим реализацию. Начнем с обработчиков события Enter наших списков:
private void listBox1_Enter(object sender, System.EventArgs e)
{
// Событие Enter у списка возникает при входе в список
button1.Text = ">"; button2.Text = ">>";
}
private void listBox2_Enter(object sender, System.EventArgs e)
{
// Событие Enter у списка возникает при входе в список
button1.Text = "<"; button2.Text = "<<";
}
Посмотрим, как устроены обработчики события Click для командных кнопок, осуществляющих перенос данных между списками:
private void button1_Click(object sender, System.EventArgs e)
{
// Обработчик события Click кнопки ">"("<")
// Выборочный обмен данными между списками
// ListBox1 и ListBox2
if(button1.Text == ">")
MoveSelectedItems(listBox1, listBox2);
else
MoveSelectedItems(listBox2, listBox1);
}
private void button2_Click(object sender, System.EventArgs e)
{
// Обработчик события Click кнопки "<<"(">>")
// Перенос всех данных одного списка в конец другого списками
// ListBox1 и ListBox2
if(button2.Text == ">>")
MoveAllItems(listBox1, listBox2);
else
MoveAllItems(listBox2, listBox1);
}
Обработчики событий устроены достаточно просто – они вызывают соответствующий метод, передавая ему нужные аргументы в нужном порядке. Рассмотрим метод, переносящий множество отобранных пользователем элементов из одного списка в другой:
private void MoveSelectedItems(ListBox list1, ListBox list2)
{
// Выделенные элементы списка list1 помещаются в конец списка List2
// и удаляются из списка list1
list2.BeginUpdate();
foreach (object item in list1.SelectedItems)
{
list2.Items.Add(item);
}
list2.EndUpdate();
ListBox.SelectedIndexCollection indeces = list1.SelectedIndices;
list1.BeginUpdate();
for (int i = indeces.Count -1; i >=0 ; i--)
{
list1.Items.RemoveAt(indeces[i]);
}
list1.EndUpdate();
}
Следует заметить, что для добавления выделенных пользователем элементов к другому списку используется коллекция SelectedItems и метод Add поочередно добавляющий элементы коллекции. Метод AddRange для добавления всей коллекции здесь не проходит:
list2.Items.AddRange(list1.SelectedItems);
поскольку нет автоматического преобразования между коллекциями ObjectCollection и SelectedObjectCollection.
Для удаления выделенных элементов из списка list1 используется коллекция индексов. Обратите внимание, при удалении элемента с заданным индексом из любой коллекции индексы оставшихся элементов автоматически пересчитываются. Поэтому удаление элементов происходит в обратном порядке, начиная с последнего индекса, что гарантирует корректность оставшихся индексов.
Намного проще устроен метод, переносящий все элементы списка:
private void MoveAllItems(ListBox list1, ListBox list2)
{
// Все элементы списка list1 переносятся в конец списка list2
// список list1 очищается
list2.Items.AddRange(list1.Items);
list1.Items.Clear();
}
Добавим еще одну функциональную возможность, которая позволяет переносить элементы из одного списка в другой двойным щелчком кнопки мыши. Для этого зададим обработчики события DoubleClick наших списков:
private void listBox1_DoubleClick(object sender, System.EventArgs e)
{
// Обработчик события DoubleClick левого списка
// Выбранный элемент переносится в правый список
// ListBox1 < - > ListBox2
MoveSelectedItems(listBox1, listBox2);
}
private void listBox2_DoubleClick(object sender, System.EventArgs e)
{
// Обработчик события DoubleClick правого списка
// Выбранный элемент переносится в левый список
// ListBox1 <-> ListBox2
MoveSelectedItems(listBox2, listBox1);
}
Обработчики вызывают уже рассмотренные нами методы.
1.7. Наследование форм
Для объектного программиста форма – это обычный класс, а населяющие ее элементы управления – это поля класса. Так что создать новую форму – новый класс, наследующий все поля, методы и события уже существующей формы, не представляет никаких проблем. Достаточно написать как обычно одну строку:
public class NewForm : InterfacesAndDrawing.TwoLists
Нужно учитывать, что имени класса родителя должно предшествовать имя пространства имен.
Чаще всего, наследуемые формы создаются в режиме проектирования при выборе пункта меню Add Inherited Form( Добавить производную форму). Добраться до этого пункта можно двояко. Можно выбрать пункт Project/ AddInheritedForm (Проект/Добавить/Производная форма) из главного меню, либо выбрать имя проекта в окне проекта и выбрать пункт Add/Add Inherited Form (Добавить/Форма Windows/Производная форма) из контекстного меню, открывающегося при щелчке правой кнопкой.
В результате открывается окно Inheritance Picker (Выбор компоненты для наследования), в котором можно выбрать родительскую форму. Заметьте, родительская форма может принадлежать как текущему проекту, так и любому другому проекту. Единственное ограничение – проект, содержащий родительскую форму, должен быть скомпилирован как exe или dll. Вот как выглядит окно для задания родительской формы:
Рис. 5. Окно Inheritance Picker наследования форм
При наследовании форм следует обратить внимание на модификаторы доступа элементов управления родительской формы. По умолчанию они имеют статус private, означающий запрет на изменение свойств и обработчиков событий этих элементов. Чаще всего, такая концепция не верна. Мы не можем знать причин, по которым наследникам захочется изменить созданные родителем свойства элементов. Правильным решением является изменение значение модификатора для всех элементов управления родительской формы на protected. У всех элементов родительской формы есть свойство modifiers, в котором можно указать статус элемента управления, что и было сделано для всех элементов нашего шаблона – формы TwoLists.
Наследованную форму можно затем открыть в дизайнере форм, добавить в нее новые элементы, новые обработчики событий или изменить установки наследуемых элементов, если родительская форма предоставила такую возможность.
1.7.1. Два наследника формы TwoLists
Построим по указанной технологии двух наследников формы TwoLists. Дадим им имена: TwoLists_Strings и TwoLists_Books. Они будут отличаться тем, что первый из них будет заполнять левый список строками, а второй «настоящими объектами» класса Book. Второй список при открытии форм будет оставаться пустым и служит для хранения выбора, сделанного пользователем. Оба наследника будут также задавать обработчики события Click для командных кнопок, завершающих работу с этими формами. На рис.6 показана наследуемая форма, открытая в дизайнере форм:

Рис.6. Наследуемая форма, открытая в дизайнере
Обратите внимание на значки, сопровождающие все наследуемые элементы управления. В классе TwoLists_Strings добавлены поля:
string[] source_items;
string[] selected_items;
const int max_items = 20;
В конструктор класса добавлен код, инициализирующий массивы:
source_items = new string[max_items];
selected_items = new string[max_items];
InitList1();
Вызываемый в конструкторе закрытый метод класса InitList заполняет массив source_items – источник данных – строками, а затем передает эти данные в левый список формы:
void InitList1()
{
//задание элементов источника и инициализация списка формы
source_items[0] ="Бертран Мейер: Методы программирования";
//аналогично заполняются другие элементы массива
//перенос массива в список ListBox1
int i = 0;
while (source_items[i] != null)
{
this.listBox1.Items.Add(source_items[i]); i++;
}
//this.listBox1.DataSource = source_items;
}
Закомментирована альтернативная возможность заполнения списка формы, использующая свойство DataSource. Когда форма откроется, то ее левый список будет заполнен и пользователь сможет выбрать из этого списка понравившиеся ему книги и перенести их в правый список. Зададим теперь обработчики события Click для командных кнопок («Сохранить выбор» и «Не сохранять»):
private void button3_Cl
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Оба они в отладочной (Debug) версии проекта выводят данные о книгах, выбранных пользователем, скрывая затем форму. Но первый из них сохраняет результаты выбора в поле selected_items.
Второй наследник TwoLists_Books устроен аналогично, но хранит в списке не строки, а объекты класса Book. Приведу уже без комментариев соответствующие фрагменты кода:
Book[] source_items;
Book[] selected_items;
const int max_items = 20;
Код, добавляемый в конструктор:
source_items = new Book[max_items];
selected_items = new Book[max_items];
InitList1();
Метод InitList1 скорректирован для работы с книгами:
void InitList1()
{
//задание элементов источника и инициализация списка формы
Book newbook;
newbook = new Book("Бертран Мейер",
"Методы программирования",3,1980);
source_items[0] =newbook;
//остальные элементы массива заполняются аналогичным образом
//перенос массива в список ListBox1
int i = 0;
while (source_items[i] != null)
{
this.listBox1.Items.Add(source_items[i]);
i++;
}
}
Обработчики событий Click командных кнопок, завершающих работу с формой, имеют вид:
private void button3_Click(object sender, System.EventArgs e)
{
int i =0;
foreach(object item in listBox2.Items)
{
selected_items[i] =
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
· Класс Book определен следующим образом:
public class Book
{
//поля
string author;
string title;
int price;
int year;
public Book(string a, string t, int p, int y)
{
author = a; title = t; price = p; year = y;
}
public override string ToString()
{
return( title + " : " + author);
}
public void PrintBook()
{
Debug.WriteLine("автор:" + author + " название: " +
title + " цена: " + price.ToString() +
" год издания: " + year.ToString());
}
}
Обратите внимание, в классе, как и положено, переопределен метод ToString, задающий строку, отображаемую в списке. В завершение проекта нам осталось спроектировать главную форму. Сделаем ее в соответствии с описанным ранее шаблоном кнопочной формой. Вот как она выглядит в процессе работы:

Рис.7. Главная кнопочная форма проекта
Обработчики событий Click вызывают соответствующую форму либо для работы со списком, хранящим строки, либо списком, хранящим объекты. На рис.8 показана форма, хранящая строки, в процессе работы с ней:

Рис.8. Форма TwoLists_Strings в процессе работы
1.8. Организация меню в формах
Важными атрибутами интерфейса являются меню и инструментальные панели с кнопками. Рассмотрим, как организуются эти элементы интерфейса в формах. Меню и панели с кнопками можно создавать как руками в режиме проектирования, так и программно.
Несколько слов о терминологии. Когда мы говорим о меню, то имеем в виду некоторую структуру, организованную в виде дерева. Меню состоит из элементов меню, часто называемых пунктами меню. Каждый пункт – элемент меню может быть либо меню (подменю), состоящим из пунктов, либо быть конечным элементом меню – командой, при выборе которой выполняются определенные действия. Главным меню называется строка, содержащая элементы меню верхнего уровня, появляющаяся в вершине окна приложения – в нашем случае в вершине формы. Как правило, главное меню всегда видимо и только оно всегда видимо. Если из главного меню выбрать некоторый элемент, то, если он не задает команду, под ним появятся пункты меню, заданные этим элементом, – говорят, что появляется выпадающее меню. Поскольку каждый из пунктов выпадающего меню, может быть меню, то при выборе этого пункта соответствующее выпадающее меню появляется слева или справа от него.
Кроме структуры, заданной главным меню, в форме и в элементах управления разрешается организовывать контекстные меню, появляющиеся (всплывающие) при нажатии правой кнопки мыши.
1.8.1. Создание меню в режиме проектирования
Для построения в режиме проектирования главного меню и связанной с ним структуры достаточно перетащить на форму элемент управления, называемый MainMenu. В Visual Studio элемент управления для создания меню называется MenuStrip, а для создания инструментальных панелей ToolStrip.
После перетаскивания метка с изображением этого элемента управления появляется ниже формы, а на форме появляется элемент меню с информационным полем, в котором можно задать название пункта меню, и двумя указателями на правого брата и старшего сына, позволяющими перейти к следующему пункту меню того же уровня или опуститься на нижний уровень. Технология создания меню руками интуитивно ясна и не вызывает обычно никаких проблем. На рис.9 показан процесс создания меню:

Рис. 9. Создание меню в режиме проектирования
Рассмотрим пример, в котором главное меню содержит 3 пункта – File, Figure, Color. Меню File содержит две команды – Open и Save. Меню Figure состоит из двух пунктов – Closed и Unclosed, первый из которых содержит две команды – Circle и Rectangle, второй содержит одну команду – Line. Пункт Color главного меню в данном случае является командой и не содержит выпадающего меню. Полагаю, что для демонстрации возможностей, этой структуры вполне достаточно. Создать ее руками минутное дело. Содержательный пример появится в следующей заключительной главе, а в этой ограничимся демонстрационной версией.
Перенесем на форму еще один элемент управления – текстовое окно, и свяжем его с командами меню обработчики события Click. Для команд Open, Save и Color, имеющих общепринятый смысл, обработчики будут открывать соответствующие этим командам диалоговые окна, позволяющие в диалоге с пользователем открыть файл, сохранить файл и выбрать подходящий цвет. Диалоговые окна – это важный элемент организации интерфейса. Связывание команды меню с обработчиком события в режиме проектирования выполняется стандартным образом – выделяется соответствующая команда меню, затем в окне Properties (Свойства) щелкается значок молнии, и из списка событий выбирается событие Click, после чего открывается заготовка обработчика события, заполняемая нужным кодом.
Вот как выглядят обработчики события Click команд Open(Открыть), Save(Сохранить) и Color(Цвет):
private void menuItem4_Click(object sender, System.EventArgs e)
{
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.ShowDialog();
//код, показывающий, что делать с открытым файлом
textBox1.Text = "Открытие Файла!";
}
private void menuItem10_Click(object sender, System.EventArgs e)
{
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.ShowDialog();
//код, анализирующий результат операции сохранения файла
textBox1.Text = "Сохранение Файла!";
}
private void menuItem3_Click(object sender, System.EventArgs e)
{
ColorDialog colorDialog1 = new ColorDialog();
if (colorDialog1.ShowDialog()== DialogResult.OK)
this.textBox1.BackColor =colorDialog1.Color;
}
На рис. 10 показано диалоговое окно для выбора цвета, открытое при выборе команды Color.

Рис. 10. Диалоговое окно ColorDialog, позволяющее выбрать цвет
Для полноты картины зададим обработчики событий для команд меню Circle, Rectangle, Line, не выполняющие пока содержательной работы, а лишь информирующие о намерениях:
private void menuItem7_Click(object sender, System.EventArgs e)
{
textBox1.Text = "Рисование круга!";
}
private void menuItem8_Click(object sender, System.EventArgs e)
{
textBox1.Text = "Рисование прямоугольника!";
}
private void menuItem9_Click(object sender, System.EventArgs e)
{
textBox1.Text = "Рисование прямой!";
}
На этом закончим рассмотрение процесса создания меню в режиме проектирования, опуская ряд деталей, например, возможность задания горячих клавишей для элементов меню.
1.8.2. Классы меню
Все, что можно делать руками, можно делать и программно. Рассмотрим классы, используемые при работе с меню. Основным родительским классом является абстрактный класс Menu, задающий базовую функциональность трех своих потомков – классов MainMenu, ContextMenu и MenuItem. Класс MenuItem задает элемент меню, который, напомню, сам может являться меню (подменю). Свойство MenuItems, которым обладают все классы меню, возвращает коллекцию MenuItems из элементов меню класса MenuItem. С коллекцией можно работать обычным образом. Создание меню означает создание объектов контейнерных классов MainMenu и ContextMenu и множества объектов класса MenuItem. Последние добавляются в коллекцию либо контейнерных классов, либо в коллекцию соответствующих элементов MenuItem. Созданные объекты классов MainMenu и ContextMenu связываются со свойствами формы – Menu и ConextMenu. Проанализируем код, созданный в процессе проектирования Дизайнером Меню и Дизайнером Формы для нашего примера.
Вот какие поля формы, задающие объекты меню, были сформированы:
private System.Windows.Forms.MainMenu mainMenu1;
private System.Windows.Forms.MenuItem menuItem1;
//другие элементы меню
private System.Windows.Forms.MenuItem menuItem10;
Основной код, создаваемый дизайнерами, помещается в метод InitializeComponent. Рассмотрим лишь фрагменты этого кода:
this.mainMenu1 = new System.Windows.Forms.MainMenu();
this.menuItem1 = new System.Windows.Forms.MenuItem();

// mainMenu1
this.mainMenu1.MenuItems.AddRange(new System.Windows.Forms.MenuItem[]
{
this.menuItem1,this.menuItem2,this.menuItem3});
// menuItem1
this.menuItem1.Index = 0;
this.menuItem1.MenuItems.AddRange(new System.Windows.Forms.MenuItem[]
{ this.menuItem4, this.menuItem10 });
this.menuItem1.Text = "File";

// menuItem4
this.menuItem4.Index = 0;
this.menuItem4.Text = "Open";
this.menuItem4.Click += new System.EventHandler(this.menuItem4_Click);

// Form1

this.Controls.AddRange(new System.Windows.Forms.Control[] { this.textBox1 } );
this.Menu = this.mainMenu1;
this.Name = "Form1"; this.Text = "Form1";
}
Приведенный программный код достаточно прозрачен и не требует дополнительных комментариев.
1.8.3. Создание инструментальной панели с командными кнопками
Панель с командными кнопками дополняет меню. Панель устроена проще, поскольку здесь нет иерархии. На панели располагаются кнопки, щелчок по каждой из которых запускает на выполнение соответствующую команду, заданную обработчиком события Click. Как правило, команды, задаваемые кнопками панелей, соответствуют наиболее часто используемым командам меню и являются альтернативным способом их запуска. Но это не обязательно, и команды, задаваемые кнопками панели, могут не пересекаться с командами меню.
Роль контейнерного класса для командных кнопок играет класс, определяющий панель – ToolBar. Командные кнопки – элементы, располагаемые на панели, задаются классом ToolBarButton.
Давайте спроектируем панель с тремя кнопками, задающими команды Open, Save и Color, повторяющие команды меню. Принято кнопки делать красивыми, вынося на них рисунки, ассоциированные с командами. Поэтому посадим на форму два элемента управления – ImageList, хранящий рисунки, связываемые с кнопками, и ToolBar – панель, на которой будут располагаться кнопки. В коллекцию объекта imageList1 добавим три подходящие картинки, свяжем этот объект со свойством ImageList объекта toolBar1. Затем добавим три кнопки в коллекцию объекта toolBar1 и зададим для них нужные свойства – текст, появляющийся на кнопке, подсказку к кнопке и индекс элемента из списка ImageList. На рис. 11 показан процесс задания кнопки и установки ее свойств.

Рис.11. Проектирование панели с командными кнопками
Проанализируем теперь созданный дизайнером программный код. Как всегда начнем с полей класса, хранящих созданные в процессе проектирования элементы:
private System.Windows.Forms.ToolBar toolBar1;
private System.Windows.Forms.ImageList imageList1;
private System.Windows.Forms.ToolBarButton toolBarButton1;
private System.Windows.Forms.ToolBarButton toolBarButton2;
private System.Windows.Forms.ToolBarButton toolBarButton3;
В методе InitializeComponent эти объекты создаются и инициализируются:
this.toolBar1 = new System.Windows.Forms.ToolBar();
this.imageList1 = new System.Windows.Forms.ImageList(this.components);
this.toolBarButton1 = new System.Windows.Forms.ToolBarButton();
this.toolBarButton2 = new System.Windows.Forms.ToolBarButton();
this.toolBarButton3 = new System.Windows.Forms.ToolBarButton();

// toolBar1
this.toolBar1.Buttons.AddRange( new System.Windows.Forms.ToolBarButton[]
{ this.toolBarButton1, this.toolBarButton2,this.toolBarButton3 } );
this.toolBar1.DropDownArrows = true;
this.toolBar1.ImageList = this.imageList1;
this.toolBar1.Name = "toolBar1";
this.toolBar1.ShowToolTips = true;
this.toolBar1.Size = new System.Drawing.Size(432, 42);
this.toolBar1.TabIndex = 1;
this.toolBar1.ButtonClick += new System.Windows.Forms.ToolBarButtonClickEventHandler(this.toolBar1_ButtonClick);
// toolBarButton1
this.toolBarButton1.ImageIndex = 0;
this.toolBarButton1.Text = "OpenFile";
this.toolBarButton1.ToolTipText = "Диалоговое окно открытия файла ";

Этот текст должен быть понятен без комментариев, а вот об обработчике события Click стоит сказать несколько слов. Во-первых, событие Click не связывается с каждой командной кнопкой, расположенной на панели, – оно связано с самой панелью. Так что в обработчике происходит разбор случаев с анализом того, какая кнопка была нажата. Вот как это делается:
private void toolBar1_ButtonClick(object sender,
System.Windows.Forms.ToolBarButtonClickEventArgs e)
{
int buttonNumber = toolBar1.Buttons.IndexOf(e.Button);
switch (buttonNumber)
{
case 0: OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.ShowDialog();
//код, показывающий, что делать с открытым файлом
textBox1.Text = "Открытие Файла!";
break;
case 1: SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.ShowDialog();
//код, анализирующий результат операции сохранения файла
textBox1.Text = "Сохранение Файла!";
break;
default: ColorDialog colorDialog1 = new ColorDialog();
if (colorDialog1.ShowDialog()== DialogResult.OK)
this.textBox1.BackColor =colorDialog1.Color;
break;
}
}
В заключение взгляните на спроектированную форму с меню и панелью с командными кнопками:

Рис.12. Форма с меню и инструментальной панелью

1.9. Рисование в форме
Графика необходима при организации пользовательского интерфейса. Образы информативнее текста. Framework .Net реализует расширенный графический интерфейс GDI+, обладающий широким набором возможностей. Но по минимуму для рисования в формах достаточно иметь три объекта – перо, кисть и, хочется сказать, бумагу, но третий нужный объект – это объект класса Graphics, методы которого позволяют в формах заниматься графикой – рисовать и раскрашивать.
1.9.1. Класс Graphics
Класс Graphics – это основной класс, необходимый для рисования. Класс Graphics, также как и другие рассматриваемые здесь классы для перьев и кистей, находятся в пространстве имен Drawing, хотя классы некоторых кистей вложены в подпространство Drawing2D.
Объекты этого класса зависят от контекста устройства, (графика не обязательно отображается на дисплее компьютера, она может выводиться на принтер, графопостроитель или другие устройства), поэтому создание объектов класса Graphics выполняется не традиционным способом – без вызова конструктора класса. Создаются объекты специальными методами разных классов. Например, метод CreateGraphics класса Control – наследника класса Form – возвращает объект, ассоциированный с выводом графики на форму.
При рисовании в формах можно объявить в форме поле, описывающее объект класса Graphics:
Graphics graph;
а в конструкторе формы произвести связывание с реальным объектом:
graph = CreateGraphics();
Затем всюду в программе, где нужно работать с графикой, используется глобальный для формы объект graph и его методы. Есть другой способ получения этого объекта – обработчики некоторых событий получают объект класса Graphics среди передаваемых им аргументов. Например, в обработчике события Paint, занимающегося перерисовкой, этот объект можно получить так:
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
Graphics gr = e.Graphics;
//перерисовка, использующая методы объекта gr
}
Для получения этого объекта можно использовать и статические методы самого класса Graphics.
1.9.2. Методы класса Graphics
У класса Graphics есть большое число методов и свойств. Рассмотрим лишь некоторые из них. Группа статических методов класса позволяет создать объект этого класса, задавая например описатель (handle) контекста устройства.
Для рисования наиболее важны три группы методов. К первой относится перегруженный метод DrawString, позволяющий выводить тексты в графическом режиме. Вторую группу составляют методы Draw – DrawEllipse, DrawLine, DrawArc и другие, позволяющие цветным пером (объектом класса Pen) рисовать геометрические фигуры – линии, различные кривые, прямоугольники, многоугольники, эллипсы и прочее. К третьей группе относятся методы Fill – FillEllipse, FillPie, FillRectangle и другие, позволяющие нарисовать и закрасить фигуру кистью. Кисти (объекты классов, производных от Brush), могут быть разные – сплошные, узорные, градиентные.
1.9.3. Класс Pen
Методам группы Draw класса Graphics, рисующим контур фигуры, нужно передать перо – объект класса Pen. В конструкторе этого класса можно задать цвет пера и его толщину (чаще говорят ширину пера). Цвет задается объектом класса (структурой) Color. Для выбора подходящего цвета можно использовать упоминавшееся выше диалоговое окно Color, либо одно из многочисленных статических свойств класса Color, возвращающее требуемый цвет. Возможно и непосредственное задание элементов структуры в виде комбинации RGB – трех цветов – красного, зеленого и голубого. Вместо создания нового пера с помощью конструктора можно использовать специальный класс предопределенных системных перьев.
1.9.4. Класс Brush
Класс Brush, задающий кисти, устроен более сложно. Начну с того, что класс Brush является абстрактным классом, так что создавать кисти этого класса нельзя, но можно создавать кисти классов-потомков Brush. Таких классов пять – они задают кисть:
SolidBrush – для сплошной закраски области заданным цветом;
TextureBrush – для закраски области заданной картинкой (image);
HatchBrush – для закраски области предопределенным узором;
LinearGradientBrush – для сплошной закраски с переходом от одного цвета к другому, где изменение оттенков задается линейным градиентом;
PathGradientBrush – для сплошной закраски с переходом от одного цвета к другому, где изменение оттенков задается более сложным путем.
Первые два класса кистей находятся в пространстве имен System.Drawing, остальные – System.Drawing.Drawing2D. У каждого из этих классов свои конструкторы. В примере, обсуждаемом далее, рассмотрим создание кистей трех разных классов, там и поговорим о конструкторах классов.
1.9.5. Проект «Паутина Безье, кисти и краски»
Построим проект для рисования в формах. В одной из форм будем рисовать пером, в другом – кистями различного типа. Главную форму сделаем простой кнопочной формой. Вот как она выглядит:

Рис.13. Кнопочная форма «кисть или перо»
Выбор соответствующей командной кнопки открывает форму для рисования пером или кистью.
1.9.6. Паутина Безье
В форме BezierWeb будем рисовать несколько кривых Безье, исходящих из одной точки – центра. Положение центра определяется курсором. Перемещая мышь, меняем положение курсора, а, следовательно, и центра, так что рисунок в форме будет все время перерисовываться, следуя за мышью. Кривые Безье – это широко используемый в графике и технических приложениях вид гладких кривых. Кривая Безье задается четырьмя точками, первая и последняя из которых являются начальной и конечной точками кривой. Две оставшиеся точки являются точками притяжения. Прямую, заданную началом и концом, они притягивают к себе, превращая ее в гладкую кривую. Строгое математическое определение несложно, но мы приводить его не будем.
Прежде, чем рассмотреть программный код, давайте посмотрим, как выглядят нарисованные программой кривые Безье, исходящие из одной точки:

Рис.14. Паутина Безье
Перейдем к рассмотрению кода. Первым делом добавим в поля формы нужные нам объекты:
//fields
Point center;
Point[] points = new Point[10];
Pen pen;
Graphics graph;
int count;
Точка center будет задавать общую начальную точку для всех рисуемых кривых Безье, массив points будет задавать остальные точки, используемые при построении кривых Безье. О роли объектов pen и graph, необходимых при рисовании уже говорилось. Объект count играет техническую роль и прямого отношения к рисованию он не имеет.
В конструкторе формы вызывается метод MyInit, инициализирующий введенные объекты:
void MyInit()
{
int cx = ClientSize.Width;
int cy = ClientSize.Height;
points[0] = new Point(0,0);
points[1] = new Point(cx/2,0);
points[2] = new Point(cx,0);
points[3] = new Point(0,cy/2);
points[4] = new Point(cx,cy/2);
points[5] = new Point(0,cy);
points[6] = new Point(cx/2,cy);
points[7] = new Point(cx,cy);
points[8] = new Point(0,0);
points[9] = new Point(cx/2,0);
graph = this.CreateGraphics();
center = new Point(cx/2,cy/2);
count =1;
}
Рисование кривых Безье выполняется в методе DrawWeb, устроенном очень просто. В цикле рисуется 8 кривых, используя точку center и массив points:
void DrawWeb()
{
for (int i = 0; i<8; i++)
graph.DrawBezier(pen, center,points[i],points[i+2],points[i+1]);
}
Метод DrawBezier, вызываемый объектом graph класса Graphics, принадлежит группе рассмотренных нами методов Draw. Первым аргументом у всех этих методов является объект класса Pen, а остальные зависят от типа рисуемой фигуры. Для кривой Безье, как уже говорилось, необходимо задать четыре точки.
Главный вопрос, требующий решения, – где же вызывать сам метод DrawWeb, где инициализировать рисование в форме? Будем вызывать этот метод в двух местах – в двух обработчиках событий. Поскольку нам хочется реализовать стратегию, по которой точка center будет следовать за курсором мыши, то естественно, чтобы рисование инициировалось обработчиком события MouseMove нашей формы BezierWeb. Для подключения события формы или элемента управления достаточно в режиме проектирования выбрать нужный элемент, в окне свойств этого элемента щелкнуть по значку с изображением молнии и из списка возможных событий данного элемента выбрать нужное, что приведет к созданию заготовки обработчика событий.
Вот текст обработчика этого события:
private void BezierWeb_MouseMove(object sender,
System.Windows.Forms.MouseEventArgs e)
{
pen = SystemPens.Control;
DrawWeb();
center.X = e.X; center.Y = e.Y;
//pen = new Pen(Color.Aquamarine);
pen = SystemPens.ControlText;
DrawWeb();
}
Метод DrawWeb вызывается дважды – первый раз с пером цвета фона, другой – с цветом, принятым системой для отображения текста. Обратите внимание, для создания нужного пера в данном случае не вызывается конструктор класса, а используется класс предопределенных системных перьев. Оператор, создающий объект pen с помощью конструктора закомментирован. Он может использоваться при желании рисовать кривые определенным цветом.
Перед рисованием кривых цветом переднего плана общая для всех кривых точка center получает координаты курсора мыши, передаваемые аргументом обработчика события.
1.9.7. Событие Paint
Вызов метода DrawWeb добавлен еще и в обработчик события Paint:
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
pen = SystemPens.ControlText;
DrawWeb();
Debug.WriteLine(count++);
}
Говоря о рисовании, нельзя не упомянуть о событии Paint. Оно возникает всякий раз, когда область, в которой происходило рисование, повреждена. Причины этого могут быть разные – пользователь свернул форму, изменил ее размеры, произошло перекрытие другой формой, был вызван метод Invalidate – во всех этих случаях требуется перерисовать область. Вот тогда и возникает событие Paint, в задачу его обработчика входит перерисовка поврежденной области. Первый раз событие Paint возникает при открытии формы. Переменная count, введенная нами, позволяет в режиме отладки подсчитывать число вызовов события Paint.
Событие Paint подключают обычно не так, как это делалось, например, для события MouseMove. Вместо этого переопределяют родительский метод OnPaint. Как переопределяются родительские методы группы On, занимающиеся обработкой событий, другие методы классов родителей и базовых интерфейсов? В режиме проектирования в окне классов, отражающем структуру класса, нужно выбрать соответствующий класс (в нашем случае класс формы BezierWeb), раскрыть узел BasesAndInterfaces этого класса и из появившегося списка всех наследованных свойств и методов выбрать нужный (в нашем случае метод OnPaint). В результате появится заготовка для переопределения метода.
В данном контексте перерисовка сводится, как это обычно делается, к вызову метода, выполняющего рисование. Для повышения эффективности можно анализировать поврежденную область и выполнять рисование только в пределах этой области.
Закончим на этом с рисованием пером и перейдем к рассмотрению рисования кистью.
1.9.8. Кисти и краски
Создадим в нашем проекте новую форму RandomShapes, в которой будем рисовать и закрашивать геометрические фигуры трех разных типов – эллипсы, сектора, прямоугольники. Для каждого типа фигуры будем использовать свой тип кисти: эллипсы будем закрашивать градиентной кистью, сектора – сплошной, а прямоугольники – узорной. Цвет фигуры, ее размеры и положение будем выбирать случайным образом. Рисование фигур будет инициироваться в обработчике события Click. При каждом щелчке кнопкой мыши на форме будут рисоваться три новых экземпляра фигур каждого типа. В отличие от кривых Безье старые фигуры стираться не будут.
На рис. 15 показана форма после нескольких щелчков кнопки мыши. Конечно, черно-белый рисунок в книге не может передать цвета, особенно смену оттенков для градиентной кисти. На экране дисплея или цветном рисунке все выглядит красивее.

Рис. 15. Рисование кистями разного типа
А теперь приведем программный код, реализующий рисование. Начнем, как обычно, с полей класса:
//fields
int cx,cy;
Graphics graph;
Brush brush;
Color color;
Random rnd;
Инициализация полей производится в методе MyInit, вызываемом конструктором класса:
void MyInit()
{
cx = ClientSize.Width;
cy = ClientSize.Height;
graph = CreateGraphics();
rnd = new Random();
}
Рассмотрим теперь основной метод, реализующий рисование фигур различными кистями:
void DrawShapes()
{
for(int i=0; i<3; i++)
{
//выбирается цвет - красный, желтый, голубой
int numcolor = rnd.Next(3);
switch (numcolor)
{
case 0: color = Color.Blue; break;
case 1: color = Color.Yellow; break;
case 2: color = Color.Red; break;
}
//градиентной кистью рисуется эллипс,
//местоположение случайно
Point top = new Point(rnd.Next(cx), rnd.Next(cy));
Size sz = new Size(rnd.Next(cx-top.X), rnd.Next(cy-top.Y));
Rectangle rct = new Rectangle(top, sz);
Point bottom = top + sz;
brush = new LinearGradientBrush(top, bottom, Color.White,color);
graph.FillEllipse(brush,rct);
//сплошной кистью рисуется сектор (местоположение случайно)
top = new Point(rnd.Next(cx), rnd.Next(cy));
sz = new Size(rnd.Next(cx-top.X), rnd.Next(cy-top.Y));
rct = new Rectangle(top, sz);
brush = new SolidBrush(color);
graph.FillPie(brush,rct,30f,60f);
//узорной кистью рисуется прямоугольник (местоположение случайно)
top = new Point(rnd.Next(cx), rnd.Next(cy));
sz = new Size(rnd.Next(cx-top.X), rnd.Next(cy-top.Y));
rct = new Rectangle(top, sz);
HatchStyle hs = (HatchStyle)rnd.Next(52);
brush = new HatchBrush(hs,Color.White, Color.Black);
graph.FillRectangle(brush,rct);
}
}
Прокомментируем приведенный программный текст метода. Здесь многое построено на работе со случайными числами. Случайным образом выбирается один из возможных цветов для рисования фигуры, ее размеры и положение. Наиболее интересно рассмотреть создание кистей разного типа. Когда создается градиентная кисть:
brush = new LinearGradientBrush(top, bottom, Color.White,color);
то нужно в конструкторе кисти задать две точки и два цвета. Точки определяют интервал изменения оттенков цвета от первого до второго. В начальной точке имеет место первый цвет, в конечной – второй, в остальных точках – их комбинация. Разумно, как это сделано у нас, в качестве точек выбирать противоположные углы прямоугольника, ограничивающего рисуемую фигуру.
Наиболее просто задается сплошная кисть:
brush = new SolidBrush(color);
Для нее достаточно указать только цвет. Для узорной кисти нужно задать предопределенный тип узора, всего их возможно 52. В нашем примере тип узора выбирается случайным образом:
HatchStyle hs = (HatchStyle)rnd.Next(52);
brush = new HatchBrush(hs,Color.White, Color.Black);
Помимо первого аргумента, задающего тип узора, указываются еще два цвета – первый определяет цвет повторяющегося элемента узора, второй – цвет границы между элементами узора.
Непосредственное рисование кистью осуществляют методы группы Fill:
graph.FillEllipse(brush,rct);
graph.FillPie(brush,rct,30f,60f);
graph.FillRectangle(brush,rct);
Первый аргумент всегда задает кисть, а остальные аргументы зависят от типа рисуемой фигуры, как правило, всегда задается прямоугольник, ограничивающий данную фигуру.
Вызов метода DrawShapes, как уже говорилось, встроен в обработчик события Click формы RandomShapes:
private void RandomShapes_Click(object sender, System.EventArgs e)
{
DrawShapes();
}
2. Задание на лабораторную работу.

I. Создание проекта приложения.
I.1. Создать проект нового приложения с пустой главной формой и сохранить его в отдельном каталоге.
I.2. Ознакомится с составом панели элементов, окном обозревателя решений, окном свойств приложения и просмотра свойств компонент.
II. Создать приложения с двумя шаблонами форм.
II.1. Создать приложение с главной кнопочной формой и подчиненной формой в соответствии с описанием, представленным в разделах 1.4-1.6.2.
II.2. Создать приложение с главной и подчиненной формой, работающей с двумя списками в соответствии с разделами 1.6.3-1.6.4.
III. Наследование форм.
III.1. Создать приложение, в котором подчиненные формы для работы со строками и книгами создаются на основе ранее разработанной формы с двумя списками (разделы 1.7-1.7.1).
IV. Организация меню и инструментальных панелейв формах (разделы 1.8, 1.8.3).
IV.1. Создание приложения для рисования фигур с меню на главной форме (раздел 1.8.1-1.8.2).
IV.2. Разработка приложения для работы с файлами с меню и инструментальной панелью на главной форме (раздел 1.8.3).
V. Рисование на формах (разделы 1.9-1.9.4).
V.1. Разработка проекта приложения для работы с графическими примитивами ("Паутина Безье, кисти и краски", разделы 1.9.5 – 1.9.8).
VI. Составление отчета и защита лабораторной работы.

3. Содержание отчета по лабораторной работе

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

4. Вопросы для самопроверки:
Вариант 1
Объект класса Graphics можно создать:
конструктором класса Graphics;
статическим методом класса Graphics;
используя статическое свойство класса Form;
методом CreateGraphics;
используя аргумент, переданный обработчику события.
Отметьте истинные высказывания:
модальное окно нельзя покинуть, не закрыв его;
при рисовании цвет рисунка может быть выбран только из фиксированного набора цветов;
с пунктом меню всегда связан обработчик события Click;
существует пять различных классов перьев;
класс Menu является абстрактным классом.
Классы Control, Form и ListBox связаны следующими отношениями наследования:
класс Control является наследником класса Form;
класс Form является наследником класса Control;
класс ListBox является наследником класса Form;
класс ListBox является наследником класса Control;
классы Control и Form не связаны отношением наследования.
Вариант 2
Объект, задающий кисть, можно получить:
конструктором класса Brush;
методом CreateBrush класса Control;
конструктором класса PathGradientBrush;
конструктором класса SolidBrush;
используя аргумент, переданный обработчику события.
Отметьте истинные высказывания:
при проектировании формы указывается, будет ли она модальной или немодальной;
класс Color имеет фиксированное число статических свойств, задающих различные цвета;
закрытие формы и скрытие формы – это разные понятия;
каждая кнопка на инструментальной панели выполняет одну из команд меню;
толщина пера и ширина пера – это разные понятия.
Элемент управления ListBox:
может хранить объекты;
хранит только строки;
может отображать объекты;
отображает только строки;
позволяет задавать элементы на этапе проектирования.
Вариант 3
При наследовании форм:
наследуемая форма должна принадлежать тому же проекту, что и родительская форма;
родительская форма может принадлежать любому проекту;
родительская форма может принадлежать только exe или dll проектам;
наследуемая форма не может быть открыта в дизайнере форм;
обработчики событий не наследуются.
Отметьте истинные высказывания:
метод DrawString предназначен для вывода текста в графическом режиме;
кисть класса LinearGradientBrush предназначена для рисования линий разного цвета;
контекстное меню может быть связано как с формой, так и с элементом управления;
любую форму можно открыть как модальную;
новые кисти создаются конструктором класса Brush.
Для форм справедливы следующие утверждения:
действие методов Hide и Show эквивалентно установке свойства Visible в false или true;
действия методов Hide и Close эквивалентны;
выполнение метода Close для главной формы приводит к завершению приложения;
все формы могут быть скрыты, а приложение может продолжать выполняться;
выполнение метода Close для любой формы приводит к завершению приложения.









13PAGE 15


13PAGE 14515




Заголовок 1 Заголовок 2 Заголовок 315

Приложенные файлы

  • doc 17633215
    Размер файла: 898 kB Загрузок: 1

Добавить комментарий