Визуальное проектирование приложений C#

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

В этой главе мы расскажем более подробно об использовании некоторых наиболее часто встречающихся элементов управления, но из-за ограниченного объема книги приведем описания не всех свойств и событий. Что же касается наиболее полной информации о свойствах и событиях элементов управления, то Вы сможете ее найти в справочно-информационной системе MSDN, входящей в комплект системы разработки Microsoft Visual Studio .NET. Вы также сможете найти эту справочно-информационную систему в Интернете по адресу http://msdn.microsoft.com.

Кнопки

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

Кнопки создаются на базе класса System.Windows.Forms.Button. В этом классе предусмотрено значительное количество свойств, с помощью которого можно создавать кнопки самого разного вида. Специально для демонстрации возможностей этого класса мы подготовили приложение ButtonsApp, главное и единственное окно которого показано на рис. 6-1.

Рис. 6-1. Кнопки различного вида

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

Надпись на кнопке

Как мы уже говорили, текст надписи, расположенной на кнопке, задается с помощью свойства Text. Это свойство, как и другие свойства элементов управления, можно задавать во время проектирования приложения (design time), а также программно во время работы приложения (run time).

Текст

Вот, например, как программа может изменить текст надписи для кнопки buttonRed:

buttonRed.Text = "Красный";

Стандартные кнопки ОС Microsoft Windows не допускают изменение шрифта или цвета надписей. Что же касается кнопок System.Windows.Forms.Button, то здесь перед программистом открываются широкие возможности.

Шрифт

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

buttonYellow.Font = new System.Drawing.Font("Comic Sans MS", 11.25F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(204)));

Здесь мы создаем новый шрифт как объект класса System.Drawing.Font, передавая конструктору через параметры такие атрибуты шрифта, как название, размер, стиль, единицы измерения размера шрифта и кодировку. Подробнее о шрифтах читайте в 10 главе нашей книги.

Цвет

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

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

buttonYellow.ForeColor = System.Drawing.Color.DarkGreen;

Здесь мы задали темно-зеленый цвет надписи, воспользовавшись для этого статической константой System.Drawing.Color.DarkGreen.

Выравнивание текста

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

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

buttonGreen.TextAlign = System.Drawing.ContentAlignment.BottomCenter;

Стиль кнопки

Учитывая стремление разработчиков приложений придавать своим программам интерфейс, подобный интерфейсу Web-приложений, создатели класса System.Windows.Forms.Button позаботились о возможности изменения стиля кнопки.

Стиль кнопки задается свойством FlatStyle. Это свойство может иметь следующие значения:

· Flat;

· Popup;

· Standard;

· System

Стиль Standard предназначен для создания обычных «серых» кнопок, знакомых Вам по старым приложениям Microsoft Windows.

Если выбрать стиль System, то внешний вид кнопки будет определяться настройками ОС.

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

И, наконец, кнопка Flat всегда остается плоской. Но если пользователь располагает над такой кнопкой курсор мыши, кнопка становится темнее.

Стиль кнопки можно определить средствами Microsoft Visual Studio .NET, а можно задать программно, например:

buttonYellow.FlatStyle = System.Windows.Forms.FlatStyle.Popup;

Заметим, что кнопки, располагаемые на страницах Web-сайтов, обычно ведут себя именно так, как только что описанные кнопки Popup и Flat. Поэтому если внешний вид Вашего автономного приложения должен быть похож на внешний вид страниц Web, применяйте именно эти стили.

Блокирование кнопки

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

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

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

Изображение на поверхности кнопки

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

Выбор файла изображения

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

Программно изображение на поверхности кнопки задается так:

buttonGreen.Image =
((System.Drawing.Bitmap)
(resources.GetObject("buttonGreen.Image")));

Здесь изображение извлекается из ресурсов приложения с помощью метода resources.GetObject, а затем, после приведения типа к System.Drawing.Bitmap, записывается в свойство Image.

Выравнивание изображения

Редактируя свойство ImageAlign, Вы можете изменить выравнивание изображения, добавленного в кнопку (по умолчанию изображение центрируется в окне кнопки). Это можно делать при помощи средств Microsoft Visual Studio .NET, или программно:

buttonGreen.ImageAlign = System.Drawing.ContentAlignment.TopCenter;

Как правило, если на кнопе имеется и текст, и изображение, нужно задать соответствующее выравнивание и для текста, и для изображения. Например, можно выровнять изображение влево по центру, а текст — вправо по центру, как это сделано в кнопке Голубой на рис. 6-1. А можно выровнять изображение верх по центру, а текст — вниз по центру (кнопка Зеленый на рис. 6-1)

Фоновое изображение для кнопки

Чтобы еще больше улучшить внешний вид кнопки, Вы можете задать для нее фоновое изображение. Оно будет использовано таким же образом, как фоновое изображение формы или Web-страницы.

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

Чтобы задать фоновое изображение для кнопки, отредактируйте свойство BackgroundImage. Это можно сделать во время разработки приложения или из программы:

buttonWhite.BackgroundImage =
((System.Drawing.Bitmap)
(resources.GetObject("buttonWhite.BackgroundImage")));

События

До сих пор мы обрабатывали только одно событие Click, создаваемое при щелчке кнопки мышью. В приложении ButtonsApp мы подготовили обработчики этого события, предназначенные для изменения цвета панели panel1 класса Panel, расположенной в правой части главного окна этого приложения. Создавая приложение, перетащите эту панель в форму из инструментальной панели Toolbox.

Каждый такой обработчик события устанавливает свойство panel1.BackColor, записывая в него тот или иной цвет:

private void buttonRed_Click(object sender, System.EventArgs e)
{
panel1.BackColor = System.Drawing.Color.Red;
}

private void buttonYellow_Click(object sender, System.EventArgs e)
{
panel1.BackColor = System.Drawing.Color.LightYellow;
}

private void buttonBlue_Click(object sender, System.EventArgs e)
{
panel1.BackColor = System.Drawing.Color.LightSkyBlue;
}

private void buttonGreen_Click(object sender, System.EventArgs e)
{
panel1.BackColor = System.Drawing.Color.MediumSpringGreen;
}

private void buttonWhite_Click(object sender, System.EventArgs e)
{
panel1.BackColor = System.Drawing.Color.White;
}

Цвет задается как статическая константа класса System.Drawing.Color.

Если в окне проектирования формы щелкнуть кнопку дважды, для нее по умолчанию будет создан обработчик события Click. Однако кнопка, как и остальные элементы управления, создает множество других событий. Чтобы увидеть список событий, создаваемых кнопкой, выделите ее левой клавишей мыши в окне проектирования формы, а затем откройте вкладку событий, расположенную в окне Properties (рис. 6-2).

Рис. 6-2. Вкладка событий для кнопки

Как видите, для обработки события Click здесь назначен обработчик buttonWhite_Click.

Все события, перечисленные на вкладке событий, разделены на группы. Группа Action (действие) включает в себя только событие Click. Что же касается группы Mouse (события, связанные с мышью), то в ней имеется целых шесть событий. Они создаются, когда пользователь нажимает кнопку мыши в окне кнопки (событие MouseDown), располагает курсор мыши над поверхностью окна кнопки (MouseEnter) или убирает курсор мыши из этого окна (MouseLeave) и т.д. Выделяя по очереди левой клавишей мыши названия событий, Вы можете прочитать в нижней части вкладки краткое описание условий, при которых это событие возникает.

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

Выделите в окне дизайнера форм приложения ButtonsApp любую кнопку, а затем создайте для событий MouseEnter и MouseLeave обработчики buttonsEnter и buttonsLeave. Для этого введите имена обработчиков в соответствующих полях вкладки событий (рис. 6-3).

Рис. 6-3. Добавление обработчиков событий

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

private void buttonsEnter(object sender, System.EventArgs e)
{

}

private void buttonsLeave(object sender, System.EventArgs e)
{

}

Обработчик buttonsEnter получит управление, когда курсор мыши входит в область окна кнопки, а обработчик buttonsLeave — когда курсор мыши выходит из этой области.

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

Рис. 6-4. Подключение существующего обработчика событий

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

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

Модифицируйте исходные тексты приложения ButtonsApp.

Прежде всего, добавьте в класс Form1 поле oldColor, предназначенное для хранения исходного цвета фона кнопки:

Color oldColor;

Далее добавьте исходный текст обработчика событий buttonsEnter, подключенного ко всем кнопкам нашего приложения:

private void buttonsEnter(object sender, System.EventArgs e)
{
Button btn = (Button)sender;
oldColor = btn.BackColor;
btn.BackColor = Color.Red;

switch(btn.Text)
{
     case "Красный":
     {
       panel1.BackColor = System.Drawing.Color.Red;
       break;
     }
     case "Желтый":
     {
       panel1.BackColor = System.Drawing.Color.LightYellow;
       break;
     }
     case "Голубой":
     {
       panel1.BackColor = System.Drawing.Color.LightSkyBlue;
       break;
     }
     case "Зеленый":
     {
       panel1.BackColor = System.Drawing.Color.MediumSpringGreen;
     break;
     }
     case "Белый":
     {
       panel1.BackColor = System.Drawing.Color.White;
       break;
     }
}
}

Получив управление, наш обработчик событий получает идентификатор кнопки, вызвавшей событие, и сохраняет его в переменной btn. Затем обработчик сохраняет в поле oldColor текущий цвет фона кнопки, получая его из свойства btn.BackColor, а затем раскрашивает фон кнопки в красный цвет:

Button btn = (Button)sender;
oldColor = btn.BackColor;
btn.BackColor = Color.Red;

Далее обработчик события получает текст надписи на кнопке btn.Text и определяет, какая кнопка вызвала появление события:

switch(btn.Text)
{
case "Красный":
{
panel1.BackColor = System.Drawing.Color.Red;
break;
}
…
}

Далее обработчик событий изменяет соответствующим образом цвет панели panel1.

Когда мышь покидает окно наших кнопок, управление получает обработчик событий buttonsLeave:

private void buttonsLeave(object sender, System.EventArgs e)
{
Button btn = (Button)sender;
btn.BackColor = oldColor;
panel1.BackColor = System.Drawing.Color.LightGray;
}

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

Создавая подобные обработчики событий buttonsEnter и buttonsLeave, Вы можете динамически изменять графическое изображение, расположенное в окне кнопки. Фоновое графическое изображение, текст надписи или шрифтовое оформление этого текста. Словом, здесь все ограничивается только Вашей фантазией.

Обработка событий MouseDown и MouseUp позволяет задать, например, произвольный вид кнопки в нажатом и отжатом состоянии.

Флажки с зависимой фиксацией

В разделе «Диалоговое окно регистрации программы» 5 главы мы кратко рассказывали Вам об использовании флажков с зависимой и независимой фиксацией в форме регистрации программы SimpleNotepad. В этом разделе мы рассмотрим свойства и события флажков подробнее.

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

Флажки с зависимой фиксацией создаются на базе класса System.Windows.Forms.RadioButton.

Приложение RadioButtonApp

Мы будем рассказывать о флажках с зависимой фиксацией на примере приложения RadioButtonApp, главное окно которого показано на рис. 6-5.

Рис. 6-5. Приложение RadioButtonApp

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

Панели GroupBox и Panel

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

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

Добавление объектов в панели

Как наши флажки привязываются к панелям GroupBox и Panel?

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

На этапе инициализации приложения создается сам элемент управления GroupBox (как объект класса System.Windows.Forms.GroupBox), и флажки с зависимой фиксацией:

this.groupBox1 = new System.Windows.Forms.GroupBox();
this.radioButtonBkgRed = new System.Windows.Forms.RadioButton();
this.radioButtonBkgGreen = new System.Windows.Forms.RadioButton();
this.radioButtonBkgBlue = new System.Windows.Forms.RadioButton();
this.radioButtonBkgWhite = new System.Windows.Forms.RadioButton();

Далее флажки добавляются в элемент управления GroupBox при помощи метода AddRange:

//
// groupBox1
//
this.groupBox1.Controls.AddRange(
new System.Windows.Forms.Control[]
{
     this.radioButtonBkgWhite,
     this.radioButtonBkgBlue,
     this.radioButtonBkgGreen,
     this.radioButtonBkgRed
});

Таким образом, флажки оказываются добавленными к панели groupBox1 класса GroupBox. Далее программа настраивает свойства панели GroupBox, определяющие ее расположение, размеры, текст надписи и т.д.:

this.groupBox1.Location = new System.Drawing.Point(24, 16);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Size = new System.Drawing.Size(152, 136);
this.groupBox1.TabIndex = 0;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "Укажите цвет фона";

Аналогичным образом создается панель panel1 класса Panel, надпись и флажки, расположенные внутри панели:

this.panel1 = new System.Windows.Forms.Panel();
this.label1 = new System.Windows.Forms.Label();
this.radioButtonForeRed = new System.Windows.Forms.RadioButton();
this.radioButtonForeGreen = new System.Windows.Forms.RadioButton();
this.radioButtonForeBlue = new System.Windows.Forms.RadioButton();
this.radioButtonForeBlack = new System.Windows.Forms.RadioButton();

Все объекты, расположенные внутри правой панели, добавляются в нее все тем же методом AddRange:

//
// panel1
//
this.panel1.Controls.AddRange(
new System.Windows.Forms.Control[]
{
     this.radioButtonForeBlack,
     this.radioButtonForeBlue,
     this.radioButtonForeGreen,
     this.radioButtonForeRed,
     this.label1
});
this.panel1.Location = new System.Drawing.Point(192, 8);
this.panel1.Name = "panel1";
this.panel1.Size = new System.Drawing.Size(152, 144);
this.panel1.TabIndex = 1;

Обратите внимание, что в панель panel1 добавляются не только флажки, но и надпись label1 класса Label.

Обработка событий

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

Чтобы создать обработчик событий bkgChanged для группы флажков, отвечающих за изменение цвета фона нашей надписи, выделите любой флажок в группе Укажите цвет фона. Затем в окне Properties откройте вкладку событий, введите в поле CheckedChanged строку bkgChanged и нажмите клавишу Enter. В результате будет создано тело обработчика событий bkgChanged.

Рис. 6-6. Создание обработчика события CheckedChanged

Далее выделите по очереди все остальные флажки группы Укажите цвет фона, и назначьте для них обработчик событий bkgChanged при помощи только что упомянутого окна Properties. Таким образом, изменение состояния всех флажков группы Укажите цвет фона будет отслеживаться единым обработчиком событий bkgChanged.

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

Ниже мы привели модифицированные исходные тексты обработчиков событий bkgChanged и foreChanged:

private void bkgChanged(object sender, System.EventArgs e)
{
RadioButton rb = (RadioButton)sender;
switch(rb.Text)
{
     case "Красный":
     {
       label2.BackColor = Color.LightCoral;
       break;
     }
     case "Зеленый":
     {
       label2.BackColor = Color.LightGreen;
       break;
}
     case "Синий":
     {
       label2.BackColor = Color.LightBlue;
       break;
     }
     case "Белый":
     {
       label2.BackColor = Color.White;
       break;
     }
}
}

private void foreChanged(object sender, System.EventArgs e)
{
RadioButton rb = (RadioButton)sender;

switch(rb.Text)
{
     case "Красный":
     {
       label2.ForeColor = Color.Red;
       break;
     }
     case "Зеленый":
     {
       label2.ForeColor = Color.Green;
       break;
     }
     case "Синий":
     {
       label2.ForeColor = Color.Blue;
       break;
     }
     case "Белый":
     {
       label2.ForeColor = Color.White;
       break;
     }
}
}

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

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

Использование изображений

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

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

На рис. 6-7 мы привели внешний вид измененного приложения RadioButtonApp. В нем мы снабдили флажки, задающие цвет фона, графическими изображениями. Кроме того, для флажка Белый мы задали фоновое графическое изображение.

Рис. 6-7. Использование изображений

Для того чтобы поместить в окно флажка графическое изображение, необходимо отредактировать свойство Image. Сделав это, необходимо настроить свойства ImageAlign и TextAlign, чтобы задать взаимное расположение графического изображения и текста надписи для флажка. Фоновое графическое изображение помещается в окно флажка при помощи свойства BackgroundImage.

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

Флажки с независимой фиксацией

Напомним, что флажки с независимой фиксацией работают независимо друг от друга. При этом не имеет никакого значения, расположены они внутри панелей GroupBox и Panel, или непосредственно в окне приложения. Эти флажки создаются на базе класса System.Windows.Forms.CheckBox.

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

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

Приложение CheckBoxApp

Для демонстрации приемов работы с флажками CheckBox мы подготовили приложение CheckBoxApp (рис. 6-8). Это приложение предназначено для ввода параметров подключения к почтовым серверам POP3 и SMTP.

Рис. 6-8. Приложение CheckBoxApp

Как оно работает?

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

Группа Сервер SMTP объединяет элементы управления, позволяющие задать параметры подключения к серверу SMTP, ведающему передачей электронной почты.

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

Если отметить флажок Использовать авторизацию на сервере SMTP, то поле ввода пароля и флажок Запомнить пароль будут разблокированы. Это позволит пользователю ввести пароль для сервера SMTP, а также указать режим запоминания пароля.

После того как пользователь заполнил все поля, наша программа отображает введенные значения в окне, показанном на рис. 6-9.

Рис. 6-9. Просмотр введенных параметров

Если пользователь отметил флажки Запомнить пароль, то этот факт отмечается словом «сохранить».

Настройка свойств флажков CheckBox

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

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

Свойство CheckAlign позволяет изменять взаимное расположение флажка и надписи к нему. Изменяя это свойство, Вы можете, например, поместить подпись не справа, а слева от флажка.

Очень интересное свойство называется ThreeState. Если это свойство имеет значение true, то флажок сможет принимать не два, а три состояния:

· включен;

· выключен;

· неопределенное состояние.

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

Если флажок может находиться только в двух состояниях (свойство ThreeState равно false), то это свойство может принимать значения CheckState.Checked (флажок установлен) и CheckState.Unchecked (флажок не установлен).

В том случае, когда значение свойства ThreeState равно true и флажок может принимать три состояния, свойство CheckState может иметь значение CheckState.Indeterminate (неопределенное состояние).

Обработка событий

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

Переключение флажка в неопределенное состояние

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

private void checkBox1_CheckedChanged(object sender,
System.EventArgs e)
{
CheckBox cb = (CheckBox)sender;
if(cb.Checked)
{
     textBoxSMTPPassword.Enabled = true;
     checkBoxStoreSMTPPassword.Enabled = true;
}
else
{
     textBoxSMTPPassword.Enabled = false;
     checkBoxStoreSMTPPassword.Enabled = false;

     if(checkBoxStoreSMTPPassword.Checked)
     {
       checkBoxStoreSMTPPassword.CheckState =
          CheckState.Indeterminate;
     }
}
}

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

Если флажок отмечен, обработчик события разблокирует поле ввода пароля для сервера SMTP и флажок Запомнить пароль:

if(cb.Checked)
{
textBoxSMTPPassword.Enabled = true;
checkBoxStoreSMTPPassword.Enabled = true;
}

В противном случае эти поля блокируются:

textBoxSMTPPassword.Enabled = false;
checkBoxStoreSMTPPassword.Enabled = false;

После блокировки полей обработчик события проверяет текущее состояния флажка Запомнить пароль. Если этот флажок отмечен, то он переводится в неопределенное состояние:

if(checkBoxStoreSMTPPassword.Checked)
{
checkBoxStoreSMTPPassword.CheckState =
CheckState.Indeterminate;
}

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

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

Извлечение состояния флажков

В окне нашего приложения предусмотрена кнопка Сохранить (рис. 6-8), предназначенная для просмотра информации, введенной пользователем.

Подготовьте обработчик события button1_Click для этой кнопки в следующем виде:

private void button1_Click(object sender, System.EventArgs e)
{
string str =
     "POP3 Server: " + textBoxPOP3Server.Text + "\n"+
     "POP3 Username: " + textBoxAccount.Text + "\n" +
     "POP3 Password: " + textBoxPOP3Password.Text;

if(checkBoxStorePOP3Password.Checked)
{
     str += " (сохранить)";
}

str += "\n\nSMTP Server: " + textBoxSMTPServer.Text + "\n";

if(checkBoxUseSMTPPassword.Checked)
{
     str += "SMTP Password: " + textBoxSMTPPassword.Text;
}

if(checkBoxStoreSMTPPassword.Checked &&
       checkBoxStorePOP3Password.Checked)
{
     str += " (сохранить)";
}

MessageBox.Show(str);
}

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

Вот, например, как мы проверяем состояние флажка Запомнить пароль:

if(checkBoxStorePOP3Password.Checked)
{
str += " (сохранить)";
}

Напомним, что если флажок может находиться в трех состояниях, то свойство Checked может принимать следующие значения:

· CheckState.Checked

· CheckState.Unchecked

· CheckState.Indeterminate

Списки

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

На панели инструментов Tools системы разработки программного обеспечения Microsoft Visual Studio .NET имеются готовые элементы управления, с помощью которых программист может легко добавить списки различных типов в свое приложение.

На рис. 6-10 мы показали главное окно приложения ListBoxApp, созданного нами для демонстрации способов применения списков в оконных приложениях C#.

Рис. 6-10. Списки в окне приложения ListBoxApp

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

Список, создаваемый на базе класса CheckedListBox, тоже допускает выбор одного или нескольких элементов. Этот список показан в правом верхнем углу рис. 6-10 и обозначен как CheckedListBox. Он представляет собой комбинацию списка ListBox и флажков CheckBox, рассмотренных в предыдущем разделе этой главы.

Список класса ComboBox, показанный в левой части рис. 6-10, является комбинацией списка и однострочного редактора текста. Поэтому для данного списка используются свойства и события, аналогичные свойствам и событиям списка ListBox и редактора текста класса TextBox.

Если щелкнуть мышью кнопку со стрелкой, расположенную в правой части окна списка ComboBox, это окно раскроется (рис. 6-11).

Рис. 6-11. Раскрыт список ComboBox

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

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

Расскажем об использовании этих элементов управления более подробно.

Список ListBox

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

Создание списка

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

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

this.listBox1 = new System.Windows.Forms.ListBox();

Здесь список создается как объект класса System.Windows.Forms.ListBox.

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

this.listBox1.Items.AddRange(
new object[]
{
     "Каждый",
     "Охотник",
     "Желает",
     "Знать",
     "Где",
     "Сидит",
     "Фазан"
}
);

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

Настройка свойств

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

this.listBox1.Location = new System.Drawing.Point(16, 32);
this.listBox1.Name = "listBox1";
this.listBox1.Size = new System.Drawing.Size(120, 95);
this.listBox1.TabIndex = 0;

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

Целый ряд свойств элемента управления ListBox позволяет задать внешний вид и поведение списка.

Свойство SelectionMode определяет режим выделения элементов списка и может принимать следующие значения:

· SelectionMode.None;

· SelectionMode.One;

· SelectionMode.MultiSimple;

· SelectionMode.MultiExtended.

Значение SelectionMode.None запрещает выделение элементов и может быть использовано, например, для динамического блокирования списка.

Если присвоить свойству SelectionMode значение SelectionMode.One, пользователь сможет выделить в списке только один элемент.

Значения SelectionMode.MultiSimple и SelectionMode.MultiExtended позволяют выделять в списке сразу несколько элементов. В первом из этих случаев выделение нескольких элементов выполняется мышью или клавишей пробела, а во втором дополнительно можно использовать клавишу Shift и клавиши перемещения курсора.

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

При помощи свойства Sorted, присвоив ему значение true, можно включить режим сортировки строк списка, отключенный по умолчанию.

Свойство MultiColumn позволяет расположить строки списка в несколько столбцов.

Получение списка выделенных строк

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

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

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

Что же касается SelectedItem, то это свойство хранит текст строки, выделенной в списке пользователем, или пустую строку, если пользователь не выделил ни одной строки списка.

Для работы с этими свойствами создайте обработчик событий button1_Click для кнопки OK, расположенной в главном окне нашего приложения (рис. 6-10):

private void button1_Click(object sender, System.EventArgs e)
{
string str;
str = "Список ListBox:";

str += "\nИндекс: " + listBox1.SelectedIndex;
str += "\nЭлемент: " + listBox1.SelectedItem;
MessageBox.Show(str);
}

Этот обработчик последовательно дописывает к строке str индекс выделенной строки списка и текст этой строки, а затем отображает результат в диалоговом окне MessageBox (рис. 6-12).

Рис. 6-12. Просмотр выбранной строки списка ListBox

Если пользователю разрешено выбирать из списка сразу несколько элементов, то программа может получить номера выделенных строк, анализируя свойство SelectedIndices. Это свойство представляет собой контейнер, содержащий список выделенных строк. Аналогично, текст выделенных строк можно извлечь из контейнера SelectedItems:

str += "\n";
foreach (int idx in listBox1.SelectedIndices)
{
str += " " + idx;
}

str += "\n";
foreach (string s in listBox1.SelectedItems)
{
str += " " + s;
}

Добавьте приведенные выше строки в тело обработчика событий button1_Click непосредственно перед вызовом метода MessageBox.Show. На рис. 6-13 мы показали, как теперь будет отображаться информация о выделенных строках.

Рис. 6-13. Результат выбора нескольких строк

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

Список CheckedListBox

Элемент управления CheckedListBox во многом напоминает только что рассмотренный список ListBox, но обладает несколькими особенностями.

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

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

Заметим, что в отличие от списка ListBox, список CheckedListBox не допускает одновременное выделение нескольких строк. Соответственно, свойство SelectionMode может принимать значения SelectionMode.One или SelectionMode.None. В первом случае пользователь сможет выделить одну строку, а во втором — ни одной.

Тем не менее, в списке CheckedListBox пользователь может отметить несколько флажков, расположенных около разных строк, реализовав, таким образом, множественное выделение.

Добавление элементов в список CheckedListBox выполняется примерно тем же самым способом, что и в список ListBox, а именно, с применением метода AddRange:

this.checkedListBox1 = new System.Windows.Forms.CheckedListBox();
…
this.checkedListBox1.Items.AddRange(
new object[]
{
     "Каждый",
     "Охотник",
     "Желает",
     "Знать",
     "Где",
     "Сидит",
     "Фазан"
}
);

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

this.checkedListBox1.Location = new System.Drawing.Point(160, 32);
this.checkedListBox1.Name = "checkedListBox1";
this.checkedListBox1.Size = new System.Drawing.Size(112, 94);
this.checkedListBox1.TabIndex = 1;
this.checkedListBox1.CheckOnClick = true;

Для того чтобы узнать номер выделенной строки и получить ее текст, воспользуйтесь свойствами SelectedIndex и SelectedItem, соответственно. Что же касается множественной отметки строк, то свойство CheckedIndices содержит список искомых номеров, а свойство CheckedItems — список искомых текстовых строк.

Чтобы попробовать все это в действии, добавьте следующий фрагмент кода в тело обработчика событий button1_Click непосредственно перед вызовом метода MessageBox.Show:

str += "\n\nСписок CheckedListBox:";
str += "\nИндекс: " + checkedListBox1.SelectedIndex;
str += "\nЭлемент: " + checkedListBox1.SelectedItem;

str += "\n";
foreach (int idx in checkedListBox1.CheckedIndices)
{
str += " " + idx;
}

str += "\n";
foreach (string s in checkedListBox1.CheckedItems)
{
str += " " + s;
}

На рис. 6-14 мы показали сведения о строках, выделенных в списках ListBox и CheckedListBox.

Рис. 6-14. Добавлена обработка списка CheckedListBox

Список ComboBox

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

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

this.comboBox1 = new System.Windows.Forms.ComboBox();
…
this.comboBox1.Items.AddRange(
new object[]
{
     "Каждый",
     "Охотник",
     "Желает",
     "Знать",
     "Где",
     "Сидит",
     "Фазан"
}
);

Далее происходит настройка основных свойств списка:

this.comboBox1.Location = new System.Drawing.Point(16, 168);
this.comboBox1.Name = "comboBox1";
this.comboBox1.Size = new System.Drawing.Size(120, 21);
this.comboBox1.TabIndex = 2;
this.comboBox1.Text = "Каждый";

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

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

Чтобы получить строку, выбранную пользователем из списка или введенную в поле редактирования элемента управления ComboBox, необходимо обратиться к свойству Text:

str += "\n\nСписок ComboBox: " + comboBox1.Text;

Список DomainUpDown

Элемент управления DomainUpDown, показанный в левой нижней части рис. 6-10, позволяет последовательно выбирать текстовые строки, нажимая кнопки со стрелками, расположенные в правой части окна списка. При этом происходит «прокрутка» текстовых строк списка.

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

Ниже мы привели фрагмент кода, создающий и наполняющий список DomainUpDown, а также настраивающий его некоторые свойства:

private System.Windows.Forms.DomainUpDown domainUpDown1;
…
this.domainUpDown1.Items.Add("Каждый");
this.domainUpDown1.Items.Add("Охотник");
this.domainUpDown1.Items.Add("Желает");
this.domainUpDown1.Items.Add("Знать");
this.domainUpDown1.Items.Add("Где");
this.domainUpDown1.Items.Add("Сидит");
this.domainUpDown1.Items.Add("Фазан");
this.domainUpDown1.Location = new System.Drawing.Point(16, 232);
this.domainUpDown1.Name = "domainUpDown1";
this.domainUpDown1.TabIndex = 3;
this.domainUpDown1.Text = "Каждый";

Среди свойств списка DomainUpDown заслуживает упоминание свойство ReadOnly. Если установить значение этого свойства, равное true, пользователь сможет выбирать строки из списка, но ввод строки с клавиатуры будет ему недоступен.

Свойства UpDownAlign и TextAlign позволяют задать выравнивание кнопок прокрутки списка и текста строк списка, соответственно. По умолчанию кнопки располагаются справа, а текст выравнивается по левой границе окна списка.

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

Для того чтобы получить строку, введенную пользователем или выбранную в списке DomainUpDown, Вам потребуется обратиться к свойству Text:

str += "\nСписок DomainpDown: " + domainUpDown1.Text;

Элемент управления NumericUpDown

Хотя, строго говоря, элемент управления NumericUpDown и не является списком в обычном понимании этого слова, он, подобно списку DomainUpDown, позволяет изменять цифровые значения, «прокручивая» их в окне при помощи кнопок со стрелками.

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

this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();

По умолчанию мастер форм инициализирует элемент управления NumericUpDown следующим образом:

this.numericUpDown1.Location = new System.Drawing.Point(160, 232);
this.numericUpDown1.Name = "numericUpDown1";
this.numericUpDown1.Size = new System.Drawing.Size(112, 20);
this.numericUpDown1.TabIndex = 4;

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

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

Свойство DecimalPlaces задает количество цифр после десятичной точки. Присвоив значению ThousandsSeparator значение true, можно включить режим выделения разрядов тысяч.

Величина инкремента и декремента задается свойством Increment, а минимальное и максимальное значения — при помощи свойств Minimum и Maximum, соответственно.

Для того чтобы получить текущее значение, установленное пользователем в окне элемента управления NumericUpDown, воспользуйтесь свойством Value:

str += "\nСписок NumericUpDown: " + numericUpDown1.Value;

На рис. 6-15 мы показали результат просмотра состояния всех списков, включая списки DomainUpDown и NumericUpDown.

Рис. 6-15. Теперь программа обрабатывает все списки

Элемент управления TrackBar

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

Движок элемента управления TrackBar можно передвигать мышью, клавишами перемещения курсора, а также клавишами Home, End, PgUp и PgDn. При перемещении движка создаются события Scroll.

Помимо движка, в окне элемента управления TrackBar есть деления. Они отображаются в виде коротких штрихов, расположенных на равном расстоянии друг от друга (рис. 6-16).

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

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

Создание элемента управления TrackBar

Для демонстрации возможностей элемента управления TrackBar мы подготовили приложение TrackBarApp, главное окно которого показано на рис. 6-16.

Рис. 6-16. Элемент управления TrackBar

В этом окне всего два элемента управления — текстовое поле Label и элемент управления TrackBar. Последний из них позволяет регулировать значение, отображаемое в текстовом поле. Диапазон регулировки — от 0 до 100. При использовании клавиш перемещения курсора значение регулируется с дискретностью 1, а при использовании клавиш PgUp и PgDn — с дискретностью 5.

При визуальном проектировании приложения Вам нужно перетащить значок элемента управления TrackBar из инструментальной панели Microsoft Visual Studio .NET в окно формы. При этом мастер формы создаст для Вас весь необходимый программный код.

Элемент управления TrackBar создается как объект класса System.Windows.Forms.TrackBar:

this.trackBar1 = new System.Windows.Forms.TrackBar();

Свойства элемента управления TrackBar

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

this.trackBar1.Location = new System.Drawing.Point(40, 104);
this.trackBar1.Maximum = 100;
this.trackBar1.Name = "trackBar1";
this.trackBar1.Size = new System.Drawing.Size(224, 42);
this.trackBar1.TabIndex = 0;
this.trackBar1.TickFrequency = 5;
this.trackBar1.Scroll +=
new System.EventHandler(this.trackBar1_Scroll);

Этот обработчик будет получать управление при изменении положения движка в окне элемента управления TrackBar.

Рассмотрим самые важные свойства регулятора TrackBar.

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

Свойства Minimum и Maximum определяют, соответственно, минимальное и максимальное значение, связанное с движком. По умолчанию минимальное значение равно 1, а максимальное — 10. В нашем приложении TrackBarApp мы увеличили максимальное значение, записав в свойство Maximum число 100.

Дискретность изменения значения при использовании клавиш перемещения курсора задается свойством SmallChange. По умолчанию она равна 1, и мы не стали менять это значение.

Что же касается дискретности при использовании клавиш PgUp и PgDn, то ее можно задать с помощью свойства LargeChange. По умолчанию значение этого свойства равно 5.

Чтобы задать количество штрихов, отображаемых на шкале элемента управления TrackBar, нужно отредактировать свойство TickFrequency. В приложении TrackBarApp мы присвоили этому свойству значение 5.

Изменяя свойство Orientation, можно задать горизонтальное или вертикальное (рис. 6-17) расположение окна элемента управления TrackBar. В первом случае свойство должно содержать значение System.Windows.Forms.Orientation.Horizontal, а во втором — System.Windows.Forms.Orientation.Vertical.

Рис. 6-17. Вертикальное расположение элемента управления TrackBar

Свойство TickStyle задает стиль шкалы и ползунка. Вот возможные значения:

· None;

· TopLeft;

· BottomRight;

· Both.

В первом случае, при использовании значения None, штрихи не отображаются на шкале. Остальные константы позволяют задать расположение штрихов сверху или снизу (справа или слева) от движка, а также по обе стороны движка (значение Both).

Обработка события Scroll

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

В приложении TrackBarApp мы извлекаем это значение, преобразуем его в текст с помощью метода ToString, а затем отображаем в текстовом поле:

private void trackBar1_Scroll(object sender, System.EventArgs e)
{
label1.Text = trackBar1.Value.ToString();
}

Элемент управления ProgressBar

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

На рис. 6-18 мы показали окно приложения TrackBarApp, в которое добавили TrackBar, перетащив значок этого элемента управления в окно формы из инструментальной панели Toolbar.

Рис. 6-18. Добавлен элемент управления ProgressBar

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

Элемент управления ProgressBar создается при помощи конструктора как объект класса System.Windows.Forms.ProgressBar:

this.progressBar1 = new System.Windows.Forms.ProgressBar();

Когда Вы добавляете ProgressBar в окно формы, дизайнер форм автоматически добавляет код настройки свойств этого элемента управления:

this.progressBar1.Location = new System.Drawing.Point(24, 64);
this.progressBar1.Name = "progressBar1";
this.progressBar1.Size = new System.Drawing.Size(224, 23);
this.progressBar1.TabIndex = 2;

Рассмотрим наиболее интересные свойства элемента управления ProgressBar.

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

Текущее значение должно находиться в границах, задаваемых при помощи свойств Minimum и Maximum. Первое из них определяет минимально возможное значение, отображаемое при помощи ProgressBar, а второе — максимально возможное значение. По умолчанию ProgressBar отображает значения в диапазоне от 0 до 100.

При инициализации наше приложение TrackBarApp устанавливает начальную позицию элементов управления TrackBar и ProgressBar, используя для этого свойство Value:

trackBar1.Value = 37;
label1.Text = trackBar1.Value.ToString();
progressBar1.Value = trackBar1.Value;

Новый обработчик сообщения trackBar1_Scroll отображает численное значение мощности в текстовом поле label1, а также устанавливает новую позицию элемента управления progressBar1:

private void trackBar1_Scroll(object sender, System.EventArgs e)
{
label1.Text = trackBar1.Value.ToString();
progressBar1.Value = trackBar1.Value;
}

С помощью методов Increment и PeformStep программа может увеличивать текущую позицию элемента управления ProgressBar. Эти методы удобно использовать в цикле. Метод Increment увеличивает позицию на величину, передаваемую этому методу через единственный параметр. Что же касается метода PeformStep, то он увеличивает значение на шаг, заданный при помощи свойства Step.

При необходимости заблокировать ProgressBar Ваша программа может записать в свойство Enabled значение false.

Полосы прокрутки HScrollBar и VScrollBar

Элементы управления HScrollBar и VScrollBar представляют собой обычные полосы прокрутки, отображаемые на границах окон редактирования и просмотра приложений Microsoft Windows. Эти элементы управления, показанные на рис. 6-19, могут также использоваться и для регулировки числовых значений, хотя для этого лучше применять только что описанный элемент управления TrackBar.

Рис. 6-19. Элементы управления HScrollBar и VScrollBar

Окно элемента управления HScrollBar располагается горизонтально, а элемента управления VScrollBar — вертикально.

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

Свойства элементов управления HScrollBar и VScrollBar аналогичны свойствам регулятора TrackBar.

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

Свойства Minimum и Maximum определяют, соответственно, минимальное и максимальное значение, связанное с движком полосы прокрутки. По умолчанию минимальное значение равно 1, а максимальное — 100.

Дискретность изменения значения при использовании клавиш перемещения курсора задается свойством SmallChange. По умолчанию она равна 1. Дискретность при использовании клавиш PgUp и PgDn задается с помощью свойства LargeChange и равна по умолчанию 10.

Календарь

В разделе «Создание модальных окон» 5 главы мы создавали диалоговое окно регистрации программы, в котором использовали очень мощное и удобное средство работы с датами — календарь MonthCalendar. Элементы управления MonthCalendar и DateTimePicker пригодятся Вам в любом приложении, требующем от пользователя ввода дат, диапазонов дат и времени.

В этом разделе мы будем показывать возможности элементов управления MonthCalendar и DateTimePicker на примере приложения DateTimeApp. Исходный вид главного окна этого приложения, в котором находится только один элемент управления MonthCalendar, мы показали на рис. 6-20.

Рис. 6-20. Календарь на один месяц

Создание календаря

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

private System.Windows.Forms.MonthCalendar monthCalendar1;
…

this.monthCalendar1 = new System.Windows.Forms.MonthCalendar();
…
//
// monthCalendar1
//
this.monthCalendar1.Location = new System.Drawing.Point(24, 16);
this.monthCalendar1.Name = "monthCalendar1";
this.monthCalendar1.TabIndex = 1;

Как видите, календарь создается с помощью конструктора на базе класса System.Windows.Forms.MonthCalendar.

Настройка свойств

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

Прежде всего, расскажем о свойствах, определяющих внешний вид календаря.

Свойства CalendarDimensions.Width и CalendarDimensions.Height задают, соответственно, ширину и высоту календаря. По умолчанию значения этих свойств равны 1, в результате чего календарь отображает числа только одного месяца (рис. 6-20).

Задав значение свойства CalendarDimensions.Width равное 3, а свойства CalendarDimensions.Height — равное 2, можно создать календарь на 6 месяцев (рис. 6‑21).

Рис. 6-21. Календарь на полгода

По умолчанию в календаре отмечена текущая дата, а в нижней части календаря присутствует строка Сегодня: ХХ.ХХ.ХХХХ. Однако если записать значение false в свойство ShowToday, эта строка не будет отображаться. Если при этом записать значение false в свойство ShowTodayCircle, текущая дата никак не будет отмечена в календаре.

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

При необходимости можно показывать в календаре номера недель, записав значение true в свойство ShowWeekNumbers.

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

Если значение свойства MaxSelectionCount установить равным 1, то пользователь сможет выбрать только один день. Если же значение этого свойства увеличить до 365, можно будет выбрать максимальный интервал дат, равный 1 году. На рис. 6-22 мы выделили диапазон дат, равный 4 месяцам.

Рис. 6-22. Выделен диапазон дат, равный 4 месяцам

Свойства SelectionStart и SelectionEnd содержат, соответственно, начальную и конечную дату из диапазона дат, выделенных пользователем. Кроме того, диапазон выделенных дат можно получить из свойства SelectionRange.

Если значение свойства MaxSelectionCount равно 1 и пользователь может выделить только один день, то дату, соответствующую этому дню, можно извлечь из свойства SelectionStart.

Что касается свойств SelectionStart и SelectionEnd, то в них хранится дата в виде объектов класса DateTime. В табл. 6-1 мы перечислили некоторые свойства этого класса.

Таблица 6-1. Свойства класса DateTime

Свойство	Что содержит
Day	Число
Mouhth	Номер месяца
Year	Год
Millisecond	Миллисекунды
Second	Секунды
Minute	Минуты
Hour	Часы
DayOfWeek	Номер дня в неделе
DayOfYear	Номер дня в году
Ticks	Количество периодов системного таймера
TimeOfDay	Время дня
Today	Текущая дата
UtcNow	Текущая локальная дата в терминах универсального координированного времени (coordinated universal time, UTC)

Ранее в разделе «Создание модальных окон» 5 главы мы уже пользовались свойством SelectionStart, извлекая из него отдельные компоненты даты:

public string UserBirthDay
{
get
{
DateTime dt = monthCalendar1.SelectionStart;
return dt.Day + "." + dt.Month + "." + dt.Year;
}
}

Здесь мы вначале получили из свойства monthCalendar1.SelectionStart дату, выделенную пользователем, и сохранили ее в переменной dt типа DateTime. Далее из отдельных компонентов даты (календарного числа dt.Day, номера месяца dt.Month и года dt.Year) была сформирована текстовая строка.

Аналогичным образом программа может обработать и содержимое свойства SelectionEnd.

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

Дополните приложение DateTimeApp обработчиком события button1_Click, получающим управление по щелчку кнопки OK:

Здесь мы извлекаем начальную и конечную дату, а затем отображаем на экране текстовую строку с диапазоном дат, выделенным пользователем в окне календаря (рис. 6-23).

Рис. 6-23. Отображение выделенного диапазона дат

Элемент управления DateTimePicker

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

Создание элемента управления DateTimePicker

Перетащите из инструментальной панели Microsoft Visual Studio .NET значки элемента управления DateTimePicker и разместите их в окне приложения DateTimeApp, как это показано на рис. 6-24.

Рис. 6-24. Использование элемента управления DateTimePicker

Элемент управления DateTimePicker создается с помощью конструктора как объект класса System.Windows.Forms.DateTimePicker:

private System.Windows.Forms.DateTimePicker dateTimePicker1;
…
this.dateTimePicker1 = new System.Windows.Forms.DateTimePicker();
…
this.dateTimePicker1.Location = new System.Drawing.Point(240, 16);
this.dateTimePicker1.Name = "dateTimePicker1";
this.dateTimePicker1.Size = new System.Drawing.Size(136, 20);
this.dateTimePicker1.TabIndex = 3;

Настройка свойств

Внешний вид окна элемента управления DateTimePicker определяется свойством Format, которое может иметь несколько значений:

· Long;

· Short;

· Time;

· Custom

Значение Long используется по умолчанию. В этом случае окно элемента управления DateTimePicker содержит поля для ввода числа, месяца и года, а также кнопку со стрелкой. На рис. 6-24 такой элемент управления показан справа вверху.

Пользователь может вводить компоненты даты, непосредственно редактируя их при помощи клавиатуры, увеличивать или уменьшать эти компоненты при помощи клавиш перемещения курсора, а также с помощью кнопки со стрелкой. В последнем случае рядом с окном элемента управления DateTimePicker появится уже знакомый Вам календарь (рис. 6-25).

Рис. 6-25. Ввод даты с помощью календаря

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

Формат Short аналогичен формату Long, но вместо названия месяца в окне элемента управления отображается его номер. На рис. 6-24 элемент управления с таким форматом показан вторым сверху в правом углу.

Формат Time используется для ввода времени в часах, минутах и секундах. На рис. 6-24 этот формат имеют два оставшихся элемента управления DateTimePicker.

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

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

Окно DateTimePicker можно снабдить флажком, установив значение свойства ShowCheckBox, равным true. Если этот флажок не отмечен пользователем, работа соответствующего элемента управления DateTimePicker блокируется. Состояние флажка можно установить или определить при помощи свойства Checked.

Свойства MinDate и MaxDate задают, соответственно, нижнюю и верхнюю границу изменения дат. Используя эти свойства, программист может ограничить диапазон изменения дат в окне элемента управления DateTimePicker.

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

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

private void button1_Click(object sender, System.EventArgs e)
{
string s = "Выбран диапазон дат: ";
DateTime dtStart = monthCalendar1.SelectionRange.Start;
DateTime dtEnd = monthCalendar1.SelectionRange.End;

s += "("
     + dtStart.Day + "." + dtStart.Month + "." + dtStart.Year +
     " - " +
     dtEnd.Day + "." + dtEnd.Month + "." + dtEnd.Year + ")";

DateTime dt1 = dateTimePicker1.Value;
DateTime dt2 = dateTimePicker2.Value;
DateTime dt3 = dateTimePicker3.Value;
DateTime dt4 = dateTimePicker4.Value;

s += "\n\nДата 1: " + dt1.Day + "." + dt1.Month + "." + dt1.Year;
s += "\nДата 2: " + dt2.Day + "." + dt2.Month + "." + dt2.Year;

s += "\n\nВремя 3: " +
       dt3.Hour + ":" + dt3.Minute + ":" + dt3.Second;

s += "\nВремя 4: " +
     dt4.Hour + ":" + dt4.Minute + ":" + dt4.Second;

MessageBox.Show(s);
}

Результат работы этого фрагмента нашего приложения показан на рис. 6-26.

Рис. 6-26. Отображение времени и даты

Таймер

Во многих программах требуется следить за временем или выполнять какие-либо периодические действия. Программы MS-DOS для работы с таймером перехватывали аппаратное прерывание таймера INT 8.

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

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

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

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

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

Для демонстрации приемов работы с программным компонентом Timer мы подготовили приложение TimerApp (рис. 6-27), представляющее собой простейшие часы.

Рис. 6-27. Таймер в действии

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

Создание таймера

Чтобы добавить таймер Timer в наше приложение, перетащите мышью значок таймера из инструментальной панели в проектируемую форму приложения или щелкните этот значок дважды левой клавишей мыши. Значок таймера с идентификатором timer1 будет показан в нижней части окна дизайнера форм (рис. 6-28).

Рис. 6-28. Свойства таймера Timer

Таймер будет создан как объект класса System.Windows.Forms.Timer. Ниже мы привели код, созданный дизайнером форм при добавлении таймера и после настройки его свойств:

private System.Windows.Forms.Timer timer1;
…
this.timer1 = new System.Windows.Forms.Timer(this.components);
…
this.timer1.Enabled = true;
this.timer1.Interval = 1000;
this.timer1.Tick += new System.EventHandler(this.timer1_Tick);

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

Свойства таймера

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

this.timer1.Enabled = true;

Свойство Interval определяет период, с которым таймер создает события Tick. Это время задается в миллисекундах. Ниже мы задали для таймера период времени, равный 1 секунде:

this.timer1.Interval = 1000;

Методы таймера

Наиболее важны методы таймера Start и Stop. Первый из этих методов запускает таймер, а второй — останавливает.

В приложении TimerApp мы вызываем эти методы при обработке событий от кнопок Старт и Стоп, соответственно:

private void button1_Click(object sender, System.EventArgs e)
{
timer1.Start();
}

private void button2_Click(object sender, System.EventArgs e)
{
timer1.Stop();
}

Обработка события Tick

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

Наш обработчик события timer1_Tick получает текущую дату с помощью свойства DateTime.Now, а затем отображает ее в виде текстовой строки в поле label1:

private void timer1_Tick(object sender, System.EventArgs e)
{
DateTime dt = DateTime.Now;
label1.Text = dt.Hour + ":" + dt.Minute + ":" + dt.Second;
}

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

Элемент управления TabControl

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

Если посмотреть, как выглядит система настройки параметров, например, в приложении Microsoft Word, то видно, что она организована в виде блокнота, состоящего из нескольких диалоговых окон с закладками (рис. 6-29). По-видимому, это один из наиболее удачных вариантов, позволяющих пользователю легко найти и выбрать нужную ему группу параметров.

Рис. 6-29. Диалоговое окно Параметры в приложении Microsoft Word

Специально для создания блокнотов с диалоговыми окнами, подобных блокноту, показанному на рис. 6-29, предусмотрен элемент управления TabControl, значок которого можно найти на инструментальной панели Toolbox системы разработки Microsoft Visual Studio .NET.

Создание элемента управления TabControl

Для демонстрации способов применения блокнот TabControl мы подготовим приложение TabControlApp, состоящее из одной формы. Чтобы создать в форме этого приложения блокнот, перетащите значок элемента управления TabControl из только что упомянутой инструментальной панели Toolbox в окно формы. Добавьте туда же кнопку с надписью OK (рис. 6-30).

Рис. 6-30. Добавлен элемент управления TabControl

Добавление страниц

Пока наш блокнот отображается в виде пустого прямоугольника и не содержит ни одной страницы. Для добавления страниц Вам нужно отредактировать свойство TabPages. Эта операция выполняется с помощью редактора страниц блокнота, показанного на рис. 6-31.

Рис. 6-31. Редактор страниц блокнота

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

Редактирование свойств блокнота и страниц

После того как страницы будут добавлены, отредактируйте для каждой страницы свойство Text. Это свойство определяет название страницы. Назовите первую страницу SMTP, вторую POP3, а третью — IMAP. Таким образом, на первой странице мы будем редактировать параметры доступа к почтовому серверу SMTP, предназначенному для передачи почты, а на второй и третьей — параметры серверов POP3 и IMAP, предназначенных для приема почты.

Если теперь оттранслировать и запустить наше приложение, на экране появится блокнот с тремя пустыми страницами (рис. 6-32).

Рис. 6-32. Добавлены три страницы

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

· Top;

· Bottom;

· Left;

· Right

По умолчанию используется значение Top, в результате чего закладки располагаются в верхней части блокнота, как это показано на рис. 6-32. Если приравнять свойству Alignment значение Bottom, закладки появятся в нижней части блокнота (рис. 6-33). И, наконец, значения Left и Right предназначены для размещения закладок слева и справа от окна блокнота, соответственно.

Рис. 6-33. Изменение расположения закладок

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

Если выделить окно страницы, а затем изменить свойство BorderStyle этого окна на Fixed3D, то страница будет выделена объемной рамкой. На рис. 6-34 мы показали оформленную таким образом страницу SMTP, на которую также были добавлены некоторые элементы управления. Экспериментируя с приложением TabControlApp, попробуйте также использовать стиль, задаваемый константой FixedSingle.

Рис. 6-34. Изменение стиля страниц

Заметим, что использование элемента управления TabControl не требует от Вас написания какого-либо дополнительного программного кода. Создавая диалоговое окно настройки параметров, подобное окну, показанному на рис. 6-29, Вам достаточно разместить все необходимые элементы управления на соответствующих страницах блокнота, а затем создать для этих элементов управления обработчики событий. При этом Вы можете использовать приемы, описанные нами в 5 главе нашей книги с названием «Диалоговые окна».

Элемент управления ToolTip

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

На рис. 6-35 мы показали такую всплывающую подсказку около текстового поля, предназначенного для ввода доменного имени сервера SMTP.

Рис. 6-35. Всплывающая подсказка ToolTip

Добавление всплывающих подсказок

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

Прежде всего, перетащите в окно формы из инструментальной панели Toolbox значок программного компонента ToolTip. Значок этого компонента toolTip1 появится в нижней части окна дизайнера формы (рис. 6-36).

Рис. 6-36. Добавлен программный компонент ToolTip

Теперь выделите левой клавишей мыши поле редактирования доменного имени сервера SMTP, как это показано на только что упомянутом рисунке. Далее в окне редактирования свойств Properties (рис. 6-37) введите текст подсказки в поле ToolTip on toolTip1.

Рис. 6-37. Добавление всплывающей подсказки

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

Настройка параметров всплывающих подсказок

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

Чтобы отредактировать эти свойства, выделите компонент toolTip1 левой клавишей мыши, а затем обратитесь к окну Properties (рис. 6-38).

Рис. 6-38. Редактирование свойств компонента toolTip1

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

Свойства AutomaticDelay и AutoPopDelay задают, соответственно, задержку при появлении всплывающей подсказки и время, в течение которого эта подсказка остается видимой.

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

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

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

Программный код

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

Программный компонент toolTip1 создается при помощи конструктора как объект класса System.Windows.Forms.ToolTip:

this.toolTip1 = new System.Windows.Forms.ToolTip(this.components);

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

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

//
// toolTip1
//
this.toolTip1.AutomaticDelay = 300;

И, наконец, подключение того или иного текста подсказки к конкретному элементу управления выполняется с помощью метода toolTip1.SetToolTip, как это показано ниже:

//
// textBox6
//
this.textBox6.Location = new System.Drawing.Point(200, 96);
this.textBox6.Name = "textBox6";
this.textBox6.TabIndex = 9;
this.textBox6.Text = "";
this.toolTip1.SetToolTip(this.textBox6,
"Введите свой идентификатор");

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