Отображение сообщений об ошибках

Метод SetError компонента ErrorProvider позволяет вывести сообщение об ошибке рядом с элементом управления.

Добавим к предыдущей задаче элемент управления ErrorProvider

private void textBox1_Validating(object sender, CancelEventArgs e)

{

if (textBox1.Text == "")

{

textBox1.BackColor = Color.Red;

MessageBox.Show("Значение не введено!!!");

e.Cancel = true;

errorProvider1.SetError(textBox1, "Значение не введено!!!");

}

else

{

errorProvider1.SetError(textBox1, "");

}

}

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

Ряд свойств компонента ErrorProvider определяет способ отображения сообщения об ошибке. Свойство Icon задает значок, отображаемый после элемента управления. Одна форма может содержать несколько экземпляров ErrorProvider, например один, отображающий сообщения об ошибках, а другой — предупреждения, при этом каждому экземпляру ErrorProvider разрешается назначить собственный значок. Другое свойство этого компонента — BlinkStyle — заставляет значок мигать, частоту мигания определяет свойство BlinkRate.

Тема Графика в C#.

Графический интерфейс GDI+

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

Графический интерфейс приложений C#, как и других приложений, предназначенных для работы в рамках Microsoft.NET Framework, состоит из набора классов. Эти классы инкапсулируют поведение объектов и инструментов, предназначенных для рисования.

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

Что же касается приложений, то для них в составе ОС Microsoft Windows был предусмотрен набор системных функций, реализующих интерфейс графических устройств (Graphics Device Interface, GDI). Применительно к приложениям Microsoft Windows мы рассмотрели этот интерфейс в [8]. Что же касается этой книги, то здесь мы расскажем о работе с усовершенствованным интерфейсом GDI+, доступным приложениям Microsoft.NET Framework.

Интерфейс графических устройств GDI, как это можно предположить из названия, предназначен для взаимодействия приложений Microsoft Windows с графическими устройствами, такими как видеоадаптер, принтер или плоттер.

Когда приложения обращаются к GDI для выполнения операции вывода графического изображения, они работают не с реальными (физическими) устройствами вывода, а с логическими устройствами. Приложения Microsoft Windows не определяют тип видеоадаптера (EGA, VGA, SVGA и т.п.), а работают с логическим видеоадаптером, имеющим феноменальные характеристики: способность отображать практически любой цвет, имеющим огромное разрешение и т. д.

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

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

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

Такая ситуация, когда приложение запрашивает у ОС Microsoft Windows одно, а получает другое, возникает не только при работе с цветом. Приложение может запросить для вывода шрифт, описав его характеристики. Интерфейс GDI подберет для вывода наиболее подходящий (с его точки зрения) шрифт, соответствующий описанию, и предоставит его приложению.

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

Составляя программы для MS-DOS, Вы работали с видеоадаптерами, указывая конкретные цвета и загружая в его память конкретные шрифты из отдельных файлов. Поэтому программы MS-DOS были крепко «привязаны» к аппаратуре. Для использования новых возможностей требовалось вносить изменения в программы. Приложения Microsoft Windows способны работать в неизменном виде на любом оборудовании, лишь бы был соответствующий драйвер. Чем лучше используемая аппаратура, чем большими возможностями она обладает, тем ближе будут параметры полученного шрифта и цвета соответствовать запрошенным.

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

Контекст отображения

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

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

Кроме контекста отображения и инструментов для рисования, приложениям доступны десятки функций программного интерфейса GDI, предназначенные для работы с контекстом отображения и инструментами. Что же касается приложений Microsoft.NET Framework, то они реализуют возможности интерфейса GDI+ с помощью набора соответствующих классов и интерфейсов.

В терминах ОС Microsoft Windows контекст отображения (display context) представляет собой структуру данных, описывающую устройство отображения. В этой структуре хранятся различные характеристики устройства и набор инструментов для рисования, выбранный по умолчанию. Приложение может выбирать в контекст отображения различные инструменты (например, перья различной толщины и цвета, с различными «наконечниками»). Поэтому если надо нарисовать линию красного или зеленого цвета, перед выполнением операции следует выбрать в контекст отображения соответствующее перо.

Заметим, что функции рисования GDI, входящие в программный интерфейс Win32 API, не имеют параметров, указывающих цвет или толщину линии. Такие параметры хранятся в контексте отображения.

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

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

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

Рис. Вывод данных через контекст устройства

Если приложение получает или создает контекст для устройства отображения, такой контекст называется контекстом отображения (display context). Поэтому когда, например, приложение получает контекст для отображения в одном из своих окон, такой контекст называется контекстом отображения. Если же ему требуется выполнять операцию вывода для устройства (для принтера или для экрана дисплея), приложение должно получить или создать контекст устройства (device context).

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

Класс Graphics

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

Пример. Создадим приложение, состоящее из формы с белым фоном и возможностью рисования на ней с помощью пера.

Идея будет состоять в следующем. Для того чтобы иметь возможность рисования мы будем отслеживать два события. Событие нажатия на клавишу мыши(mouseDown) и события отпускания клавиши мыши(mouseUp). Отслеживание будет производиться при помощи переменное типа bool. Если кнопка мыши нажата, то переменная становитcя true, если клавиша отпущена, то false. Чтобы отследить перемещение мыши будем использовать событие mouseMove. Собственно большая часть программы будет сосредоточена в обработчике этого события. Результат работ программы представлен на рис.

Рис. Результат работы программы.

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

private void Form1_MouseUp(object sender, MouseEventArgs e)

{

draw = false;

}

private void Form1_MouseDown(object sender, MouseEventArgs e)

{

draw = true;

}

private void Form1_MouseMove(object sender, MouseEventArgs e)

{

if (draw)

{

Graphics g = Graphics.FromHwnd(this.Handle);

SolidBrush myBrush = new SolidBrush(Color.Red);

g.FillRectangle(myBrush, e.X, e.Y, 1,1);

}

}

Когда пользователь нажимает левую клавишу мыши, управление передается обработчику событий Form1_MouseDown. Этот обработчик записывает в поле Draw значение true, отмечая таким способом тот факт, что пользователь приступил к процедуре рисования.

Нарисовав линию, пользователь отпускает левую клавишу мыши. При этом управление передается обработчику событий Form1_MouseUp, записывающему в поле Draw значение false. Это означает завершение процедуры рисования.

Обработчик события Form1_MouseMove будет получать управление при всяком перемещении курсора мыши, причем свойства e.X и e.Y будут содержать новые координаты курсора.

Мы воспользуемся этим обстоятельством, нарисовав в месте нового расположения курсора квадрат, с шириной стороны в один пиксел. На экране такой квадрат будет выглядеть как точка. Рисование должно выполняться только в том случае, если в поле Draw хранится значение true.

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

Приложения Microsoft.NET Framework могут получить идентификатор формы или любого другого элемента управления при помощи свойства Handle. В частности, наше приложение получает идентификатор окна формы Form1 с помощью свойства this.Handle.

Зная идентификатор окна, с помощью метода Graphics.FromHwnd можно получить нужный объект класса Graphics:

Graphics g = Graphics.FromHwnd(this.Handle);

Для того чтобы рисовать, создадим кисть как объект класса SolidBrush:

SolidBrush redBrush = new SolidBrush(Color.Red);

С помощью этой кисти можно рисовать замкнутые геометрические фигуры, закрашенные заданным цветом. Через единственный параметр мы передаем конструктору класса SolidBrush цвет кисти Color.Red. Таким образом, мы будем рисовать кистью красного цвета.

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

Но классе нет, так это метода, с помощью которого можно было бы нарисовать одну единственную точку. Однако, что вместо точки мы можем нарисовать закрашенный квадрат с шириной стороны, равным 1 пикселу. Эта задача выполняется при помощи метода FillRectangle:

g.FillRectangle(redBrush, e.X, e.Y, 1, 1);

Обратите внимание на то, что метод FillRectangle вызывается для объекта g класса Graphics, созданного нами для окна формы Form1. Поэтому квадрат будет нарисован в окне этой формы.

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

Начало системы координат при этом находится в левом верхнем углу окна, для которого был получен объект Graphics. В нашем случае это левый верхний угол внутренней области окна формы Form1. Ось X в этой системе координат, принятой по умолчанию, направлена слева направо, а ось Y — сверху вниз. Последние два параметра метода FillRectangle задают, соответственно, ширину и высоту прямоугольника.

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

Событие Paint

Если изменить размеры окна предыдущего изображения часть рисунка пропадает. Аналогичная неприятность происходит и в том случае, когда окно приложения перекрывается окном другого приложения. Дело в том, что в приложении не реализована техника рисования в окне, применяемая во всех стандартных приложениях Microsoft Windows. По своей логике способ рисования программ Microsoft Windows в корне отличается от способа, к которому привыкли разработчики, создававшие программы для ОС MS-DOS.

Известно, что приложения Microsoft Windows не могут выводить текст или графику ни с помощью стандартных функций библиотеки компилятора, например таких, как printf, cprintf или putc. Не помогут и прерывания BIOS, так как приложениям Microsoft Windows запрещено их использовать (во всяком случае, для вывода на экран). Все эти функции ориентированы на консольный вывод в одно-единственное окно, предоставленное в полное распоряжение программе MS-DOS.

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

Способ, которым приложение Microsoft Windows выводит что-либо в свои окна, коренным образом отличается от способа, используемого в программах MS-DOS.

Программа MS-DOS формирует изображение на экране «рассредоточенным» образом, то есть в любом месте программы могут вызываться функции, которые выводят что-либо на экран. Например, сразу после запуска программа может нарисовать на экране диалоговую панель, а затем в любой момент времени и, что самое главное, из любого места программы модифицировать ее.

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

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

Для наглядной демонстрации методики обработки события Paint мы подготовим простейшее приложение PaintApp, рисующее в своем окне текстовую строку и геометрические фигуры.

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

Рис. Результат работы программы.

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

private void Form1_Load(object sender, EventArgs e)

{

this.Text = "Событие Paint";

}

Рассмотрим обработчик события Paint.

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

string text = "Событие Paint";

g.Clear(Color.White);

g.DrawString(text, new Font("Helvetica", 15),Brushes.Red, 50, 0);

g.DrawRectangle(new Pen(Brushes.Blue, 2), 10, 30, 200, 100);

g.DrawEllipse(new Pen(Brushes.Green, 2), 10, 30, 200, 100);

}

Обработчику Form1_Paint передаются два параметра.

Через первый параметр передается ссылка на объект, вызвавший событие. В нашем случае это будет ссылка на форму Form1. Что же касается второго параметра, то через него передается ссылка на объект класса PaintEventArgs. Этот объект имеет два свойства, доступных только для чтения — Graphics и ClipRectangle.

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

Через свойство ClipRectangle передаются границы области, которую должен перерисовать обработчик события Paint. Эти границы передаются в виде объекта класса Rectangle. Свойства этого класса Left, Right, Width и Height, наряду с другими свойствами, позволяют определить расположение и размеры области.

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

Рассмотрим содержание обработчика события Paint. Здесь в теле обработчика Form1_Paint мы определили локальную переменную g класса Graphics, предназначенную для хранения контекста отображения. Эта переменная инициализируется при помощи значения, полученного из свойства Graphics первого параметра обработчика Form1_Paint:

Graphics g = e.Graphics;

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

Вначале мы закрашиваем окно белым цветом, вызывая для этого метод Clear, определенный в классе Graphics:

g.Clear(Color.White);

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

Далее мы вызываем методы DrawString, DrawRectangle и DrawEllipse, также определенные в классе Graphics:

g.DrawString(text, new Font("Helvetica", 15),Brushes.Red, 50, 0);

g.DrawRectangle(new Pen(Brushes.Blue, 2), 10, 30, 200, 100);

g.DrawEllipse(new Pen(Brushes.Green, 2), 10, 30, 200, 100);

Тема Методы и свойства класса Graphics. Рисование геометрических фигур

Рисование линии (DrawLine)

За рисование линий в C# отвечает метод DrawLine. Он рисует линию, соединяющую две точки с заданными координатами. Указанный метод может быть перегружен. Ниже (на слайде) указаны варианты перегрузки этого метода. Рассмотрим отдельно каждый вариант перегрузки см. слайд.

public void DrawLine(Pen, int, int, int, int);
public void DrawLine(Pen, float, float, float, float);

public void DrawLine(Pen, Point, Point);
public void DrawLine(Pen, PointF PointF);

Первый параметр во всех вариантах перегрузки задает инструмент для рисования линии — перо. Перья создаются как объекты класса Pen. Программно это будет выглядеть следующим образом:

Pen myPen = new Pen(Brushes.Aqua,5);

Здесь мы создали перо цвета Aqua толщиной 5 пикселов.

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

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

g.DrawLine(myPen,10,100,200,100);

Для варианта с классом Point вызов метода будет выглядеть следующим образом.

Point myPoint1 = new Point(100, 100);

Point myPoint2 = new Point(200,100);

g.DrawLine((new Pen(Brushes.Red, 5)), myPoint1, myPoint2);

В классах Point и PointF определены свойства X и Y, задающие, соответственно, координаты точки по горизонтальной и вертикальной оси. При этом в классе Point эти свойства имеют целочисленные значения, а в классе PointF — значения с плавающей десятичной точкой.

Объединив описанные строки получим обработчик события Form1_Paint.

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

Pen myPen = new Pen(Brushes.Aqua,5);

g.DrawLine(myPen,10,100,100,100);

Point myPoint1 = new Point(100, 100);

Point myPoint2 = new Point(200,100);

g.DrawLine((new Pen(Brushes.Red, 5)), myPoint1, myPoint2);

}

Результат работы программы представлен ниже.

Рис. Результат работы программы.

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

public void DrawLine(Pen, int, int, int, int);

Рис. Задание.

Набор линий (DrawLines)

В C# существует и другой способ нарисовать несколько линий. Этого можно достигнуть, вызвав один раз метод DrawLines, который позволит нарисовать сразу несколько прямых линий, соединенных между собой. По своей сути метод DrawLines позволяет соединить между собой несколько точек. Координаты этих точек по горизонтальной и вертикальной оси передаются методу через массив класса Point или PointF. Ниже представлены перегрузки метода DrawLines.

public void DrawLines(Pen, Point[]);
public void DrawLines(Pen, PointF[];

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

Рис. Задание на метод DrawLines.

Для решения задачи объявим в классе Form1 этого приложения мы создаем кисть pen для рисования линий и объявляем массив mypen.

Pen mypen = new Pen(Color.Red, 2);

Point[] points = new Point[50];

Далее в конструкторе формы инициализируем массив точек points, которые нужно соединить линиями.

for (int i = 0; i < 20; i++)

{

int x;

if (i % 2 == 0)

{

x = 10;

}

else

{

x = 400;

}

points[i] = new Point(x, 10 * i);

}

Координаты точек по горизонтальной оси зависят от того, является ли значение переменной цикла i четным или нечетным.

Обработчик события Form1_Paint будет иметь вид (см. слайд).

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

g.Clear(Color.White);

g.SmoothingMode = SmoothingMode.HighQuality;

g.DrawLines(mypen,points);

}

Результат работы программы приведен на (рис)(см. слайд).

Рис. Результат работы программы.

В приведенном коде появилась новая неизвестная строчка.

g.SmoothingMode = SmoothingMode.HighQuality;

Если сравнить два рисунка, то можно заметить, что линии на втором рисунке гладкие и не содержат ступенек (см. слайд). Это позволил сделать один из параметров контекста отображения, а именно параметр SmoothingMode. Этот параметр задает режим сглаживания при отображении линий. Стоит обратить внимание, что для его использования необходимо добавить пространство имен System.Drawing.Drawing2D в самом начале файла. Для чего используем ключевое слово using.(см. слайд)

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Linq;

using System.Text;

using System.Windows.Forms;

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

Рисование прямоугольника(DrawRectangle)

Метод DrawRectangle позволяет рисовать прямоугольники, заданные координатой верхнего левого угла, а также шириной и высотой. В библиотеке классов.NET Frameworks имеется три перегруженных варианта этого метода см. слайд.

public void DrawRectangle(Pen, Rectangle);
public void DrawRectangle(Pen, int, int, int, int);
public void DrawRectangle(Pen, float, float, float, float);

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

Класс Rectangle используется для описания расположения и размеров прямоугольной области. Интересующая нас сигнатура конструктора имеет вид.

Rectangle(X,Y, Width, Height)

Свойства X и Y этого класса задают координаты верхнего левого угла прямоугольной области, соответственно, по горизонтальной и вертикальной оси координат. Свойства Width и Height, хранят ширину и высоту прямоугольной области.

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

Проверим работу первых двух методов на примере см. слайд (рис.)

Рис. Задание на метод DrawRectangle

Для решения задачи необходимо создать инструмент для рисования.

Pen myPen = new Pen(Brushes.Blue, 2);

В данном случае это перо синего цвета толщиной в 2 пикселя и объект класса Rectangle.

Rectangle myRectangle = new Rectangle(10,10, 200,200);

Далее применим описанные выше методы.

g.DrawRectangle(myPen, myRectangle);

g.DrawRectangle(myPen, 20,20, 180, 180);

Полный текст обработчика события Form1_Paint приведен ниже см. слайд.

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

Pen myPen = new Pen(Brushes.Blue, 2);

g.Clear(Color.White);

Rectangle myRectangle = new Rectangle(10,10, 200,200);

g.DrawRectangle(myPen, myRectangle);

g.DrawRectangle(myPen, 20,20, 180, 180);

}

Набор прямоугольников (DrawRectangles)

Если возникает необходимость нарисовать сразу несколько прямоугольников целесообразно использовать метод DrawRectangles. Существует два перегруженных варианта этого метода:

public void DrawRectangles(Pen, Rectangle[]);
public void DrawRectangles(Pen, RectangleF[]);

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

Для демонстрации работы метода решим задачу из предыдущего пункта.

Для этого в классе Form1 приложения определим перо myPen и массив прямоугольников myRects:

Rectangle[] myRects =

{

new Rectangle(10, 10, 200, 200),

new Rectangle(20, 20, 180, 180),

};

Далее вызываем метод DrawRectangles аргументами которого будут перо myPen и массив прямоугольников myRects.

g.DrawRectangles(myPen, myRects);

Полностью код обработчика события Form1_Paint имеет вид.

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

g.Clear(Color.White);

Pen myPen = new Pen(Color.Blue, 2);

Rectangle[] myRects =

{

new Rectangle(10, 10, 200, 200),

new Rectangle(20, 20, 180, 180),

};

g.DrawRectangles(myPen, myRects);

}

Результат работы программы приведен на рис.

Рис. Результат работы программы с методом DrawRectangles.

Рисование многоугольника (DrawPolygon)

Метод DrawPoligon предназначен для рисования многоугольников. Существуюет две перегруженные версии этого метода (см.слайд).

public void DrawPolygon(Pen, Point[]);
public void DrawPolygon(Pen, PointF[]);

Аргументами метода является в перо Pen и массив точек класса Point.

Продемонстрируем работу метода на примере ромба.

Массив с координатами вершин ромба будет иметь вид.

Point [] myPoint =

{

new Point(140, 10),

new Point(200, 100),

new Point(140, 210),

new Point(80, 100),

};

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

g.DrawPolygon(myPen,myPoint);

Полностью текст обработчика события Form1_Paint имеет вид.

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

g.Clear(Color.White);

Pen myPen = new Pen(Color.Blue, 2);

Point [] myPoint =

{

new Point(140, 10),

new Point(200, 100),

new Point(140, 210),

new Point(80, 100),

};

g.DrawPolygon(myPen,myPoint);

}

Результат работы программы представлен на рис.

Рис. Результат работы метода DrawPolygon.

Рисование эллипса(DrawEllipse)

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

public void DrawEllipse(Pen, Rectangle);
public void DrawEllipse(Pen, RectangleF);
public void DrawEllipse(Pen, int, int, int, int);
public void DrawEllipse(Pen, float, float, float, float);

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

Нарисуем эллипс при помощи первого перегруженного метода. Код обработчика события Form1_Paint имеет вид.

private void Form1_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

g.Clear(Color.White);

Pen myPen = new Pen(Color.Blue, 2);

Rectangle myRect = new Rectangle(10, 10, 200, 100);

g.DrawEllipse(myPen, myRect);

}

Результат работы метода представлен на рис.

Дата добавления: 2014-01-04