Windows forms контекстное меню

Последнее обновление: 31.10.2015

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

Новые элементы в контекстное меню можно добавить в режиме дизайнера:

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

Либо на панели свойств можно обратиться к свойству Items компонента ContextMenuStrip и в открывшемся окне добавить и настроить все элементы меню:

Картинка с сайта: metanit.com

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

public partial class Form1 : Form
{
    string buffer;
    public Form1()
    {
        InitializeComponent();

        textBox1.Multiline = true;
        textBox1.Dock = DockStyle.Fill;

        // создаем элементы меню
        ToolStripMenuItem copyMenuItem = new ToolStripMenuItem("Копировать");
        ToolStripMenuItem pasteMenuItem = new ToolStripMenuItem("Вставить");
        // добавляем элементы в меню
        contextMenuStrip1.Items.AddRange(new[] { copyMenuItem, pasteMenuItem });
        // ассоциируем контекстное меню с текстовым полем
        textBox1.ContextMenuStrip = contextMenuStrip1;
        // устанавливаем обработчики событий для меню
        copyMenuItem.Click += copyMenuItem_Click;
        pasteMenuItem.Click += pasteMenuItem_Click;
    }
	// вставка текста
    void pasteMenuItem_Click(object sender, EventArgs e)
    {
        textBox1.Paste(buffer);
    }
	// копирование текста
    void copyMenuItem_Click(object sender, EventArgs e)
    {
        // если выделен текст в текстовом поле, то копируем его в буфер
        buffer = textBox1.SelectedText;
    }
}

В данном случае выполнена простейшая реализация функциональности copy-paste. В меню добавляется два элемента. А у текстового поля устанавливается
многострочность, и оно растягивается по ширине контейнера.

У многих компонентов есть свойство ContextMenuStrip, которое позволяет ассоциировать контекстное меню с данным элементом.
В случае с TextBox ассоциация происходит следующим образом: textBox1.ContextMenuStrip = contextMenuStrip1.
И по нажатию на текстовое поле правой кнопкой мыши мы сможем вызвать ассоциированное контекстное меню.

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

ContextMenuStrip

By Tim-Bo Tolbert, posted on Dec 27, 2021

The ContextMenuStrip control component is found in the System.Windows.Forms namespace within the System.Windows.Forms.dll. In this blog post I am referring to the ContextMenuStrip control that is available in C# .NET-Core (.NET 6.0) with Visual Studio 2022 (although this code example might still work OK with older .NET versions).

The ContextMenuStrip component represents a shortcut menu, which appears as a temporary popup menu whenever a user right mouse clicks onto an object which is bound to a ContextMenuStrip component. The ContextMenuStrip component replaces its predecessor the ContextMenu component of previous versions, even though the ContextMenu object is still retained in .NET for both backward and forward compatibility. The ContextMenuStrip component inherits a lot from the ToolStrip object, and as such the definitions may refer to it often in an attempt to relate to specific components of the object.

The ContextMenuStrip component can be associated with and bound to any control, both at design time and at run time, including the Form itself, which will display the shortcut menu upon a right mouse click on that control. You can also show a ContextMenuStrip programmatically by using the Show method.

Cancelable Opening and Closing events to handle dynamic population and multiple-click scenarios are supported by the ContextMenuStrip component.

The ContextMenuStrip component also supports images, menu-item check states, text, access keys, shortcuts, and cascading menus.

Set the ContextMenuStrip’s ShowCheckMargin property to True to add space to the left of a MenuItem for a check mark that shows that the menu item is enabled or selected. The ShowImageMargin property is set to True by default, which adds a space to the left of the MenuItem to display an image for that menu item.

Example Source Code

This example uses a ContextMenuStrip component, along with a CheckBox control.

To add the ContextMenuStrip component to your form, you can double click on its name (i.e. ContextMenuStrip) as listed in the Toolbox window panel within the Form editor window. Alternatively, you can single click on it and then drag and drop it onto your form. Once it is added, it will appear in a window located below the form, since it has no user interface and will not actually appear on the form itself, except during design time.

Once it is added, then you can select it in the Form editor, and then either add menu items to it from the Form Editor window and/or by its Items property within the Property window. You can also view and adjust all of its other property values in the Properties window.

In the example below, I added a ContextMenuStrip to the Form, then selected it and viewed its Items properties in the Property window to add three menu items to its Items collection, and set their Text property values to be «Checked», «Unchecked», and «Indeterminate». I then double clicked onto each of the menu items to auto create and link their Click events to callback methods. I then added a CheckBox control to the form, and altered its properties so that it can have three states (checked, unchecked, and indeterminate) instead of its default two (checked and unchecked), as well as its Text and position property values as shown below. I then set the CheckBox’s context menu strip property to bind it to the ContextMenuStrip component that I had added to the form. I then modified the source code for each of the three callback methods to set the CheckBox components checked state accordingly, based on which callback method is called:

Картинка с сайта: www.tjdivisions.com

Картинка с сайта: www.tjdivisions.com

Картинка с сайта: www.tjdivisions.com

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace TestProgram
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        void Form1_Load(object sender, EventArgs e)
        {
            // 
        }

        private void checkedToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // set CheckBox state to Checked
            checkBox1.CheckState = CheckState.Checked;
        }

        private void uncheckedToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // set CheckBox state to Unchecked
            checkBox1.CheckState = CheckState.Unchecked;
        }

        private void indeterminateToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // set CheckBox state to Indeterminate
            checkBox1.CheckState = CheckState.Indeterminate;
        }
    }
}

When you run the above example, and then if you Right Mouse Click onto the CheckBox’s text, then you should see a popup menu appear which will allow you to set the CheckBox’s checked state by clicking on one of its menu items, similar to the following:

Final Thoughts

Thank you for reading, I hope you found this blog post (tutorial) educational and helpful.

This page has been viewed a total of 3322 times.

Упражнение 5. Контекстное меню

Контекстное меню вызывается по щелчку правой кнопки мыши на
соответствующем элементе управления и зависит от конкретного
состояния этого элемента. Контекстное меню представлено классом System.Windows.Forms.ContextMenuStrip. Любой
визуальный элемент управления, производный от класса Control,
наследует общедоступное виртуальное свойство ContextMenuStrip,
к которому можно привязать объект контекстного меню.

Элементами контекстного меню ContextMenuStrip,
как и в случае с основным меню, порожденным классом MenuStrip,
являются объекты класса ToolStripMenuItem.
Эти объекты добавляются в коллекцию Items,
являющуюся свойством класса контекстного меню ContextMenuStrip.
Каждый из объектов-элементов контекстного меню имеет свойство-коллекцию DropDownItems,
в которую помещают элементы вложенного меню.

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

Рассмотрим Упражнение 5, в котором будем использовать объекты
контекстного меню. Мы создадим несколько контекстных меню,
часть динамическим способом, часть декларативным способом.
Объекты контекстных меню будем присоединять к различным элементам
управления через свойство этих элементов ContextMenuStrip.

Создание формы для Упражнения 5

Form frm;   // Объявили поле
        private void listBoxChoice_SelectedIndexChanged(object sender, EventArgs e)
        {
            // Привязали номер упражнения к индексу списка
            ListBox list = (ListBox)sender;
            string formName = "Form" + (list.SelectedIndex + 1);
    
            ///////////////////////////////////////////////////
            // Следующий код взят из лабораторной работы №47
            ///////////////////////////////////////////////////
            // Читаем коллекцию запущенных форм
            FormCollection fc = Application.OpenForms;
            bool IsRun = false;
            // Перебираем коллекцию
            foreach (Form form in fc)
            {
                // Имя очередной запущенной формы сравниваем с закрепленным за кнопкой
                if (form.Name == formName)
                {
                    IsRun = true;   // Нашли, что форма запущена, поднимаем флаг
                    frm = form;     // Сохраняем ссылку на запущенную форму для фокуса
                    break;          // Выходим из цикла
                }
            }
    
            // Если форма не запущена - запускаем
            if (!IsRun)
            {
                switch (formName)
                {
                    case "Form1":
                        frm = new Form1();
                        break;
                    case "Form2":
                        frm = new Form2();
                        break;
                    case "Form3":
                        frm = new Form3();
                        break;
                    case "Form4":
                        frm = new Form4();
                        break;
                    case "Form5":
                        frm = new Form5();
                        break;
                }
    
                this.AddOwnedForm(frm);     // Сделать новую frm подчиненной Start
                // frm.Owner = this;        // Алтернативный способ назначить владельца
                frm.ShowInTaskbar = false;  // Не отображать метку окна в панели задач
                frm.Show();                 // Показать новую форму
            }
            else
                frm.Focus();                // Передать фокус запущенной форме        
        }

• Поместите
  на форму Form5 компонент SplitContainer,
  присвойте его экземпляру имя splitContainer и
  установите свойства: Orientation= Horizontal, BorderStyle=Fixed3D, Dock=Fill

Создание контекстного меню динамическим
способом

• Откройте
  файл Form5.cs в режиме View Code и
  откорректируйте код, чтобы он стал таким

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Reflection;
    
namespace StripControls
{
    public partial class Form5 : Form
    {
        // Поле для сохранения выбранного элемента меню
        ToolStripMenuItem itemChecked = new ToolStripMenuItem();
    
        // Конструктор
        public Form5()
        {
            InitializeComponent();
    
            splitContainer.Panel1.BackColor = Color.White;// Начальный цвет верхней панели
    
            // Разделение цветов на алфавитные группы, представленные подменю
            //             A, B, C, D, E, F, G, H, I, J, K, L, M,           
            int[] iMenu ={ 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 3, 4,  
                5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6 };
            //  N, O, P, Q, R, S, T, U, V, W, X, Y, Z
    
            // Создание контекстного меню и присоединение к объекту формы
            System.Windows.Forms.ContextMenuStrip menu =
                new System.Windows.Forms.ContextMenuStrip();
            // Будет вызываться для верхней панели
            splitContainer.Panel1.ContextMenuStrip = menu;
    
            // Формируем пункты подменю в контекстном меню
            for (int i = 0; i <= 6; i++)
            {
                // Индекс первого вхождения образца соответствует коду ASCII для буквы 
                char first = Convert.ToChar(Array.IndexOf(iMenu, i) + 'A');   // Позиция в массиве
                // Индекс последнего вхождения образца соответствует ASCII латинской буквы 
                char last = Convert.ToChar(Array.LastIndexOf(iMenu, i) + 'A');// Позиция в массиве
    
                // Создали, настроили и добавили в коллекцию элемент меню
                ToolStripMenuItem item = new ToolStripMenuItem();
                item.Text = String.Format("Цвета от {0} до {1}", first, last);
                menu.Items.Add(item);
                // Включили в подменю столбец с флажками в 
                // дополнение к столбцу с изображениями
                ((ToolStripDropDownMenu)item.DropDown).ShowCheckMargin = true;
            }
    
            // Применяем рефлексию к структуре, представляющей цвета
            PropertyInfo[] api = typeof(Color).GetProperties();
            // Перебор цветов
            foreach (PropertyInfo pi in api)
            {
                if (pi.CanRead && pi.PropertyType == typeof(Color)
                    && pi.Name!="Transparent")
                {
                    // Извлекаем очередной цвет
                    Color color = (Color)pi.GetValue(null, null);
    
                    // Создаем очередной элемент подменю
                    ToolStripMenuItem item = new ToolStripMenuItem();
                    // По букве цвета определяем подменю, в котором разместим цвет
                    int i = iMenu[color.Name[0] - 'A'];// Любой букве - своя позиция
                    ((ToolStripMenuItem)menu.Items[i]).DropDownItems.Add(item);
    
                    // Продолжаем настраивать команду
                    item.Text = InsertSpaceOut(color.Name);// Пробелы перед заглавными буквами цвета
                    item.Name = color.Name;// Сохраняем название цвета для обработчика ColorOnClick
                    item.Image = CreateBitmap(color);// Тонкой ссылке присваиваем толстый объект
                    item.Click += new EventHandler(ColorOnClick);// Регистрация обработчика
                    if (color.Equals(this.BackColor))// Отметить флажком текущий цвет и сохранить ссылку
                        (itemChecked = item).Checked = true;
                }
            }
        }
    
        void ColorOnClick(object sender, EventArgs e)
        {
            // Для выбранного устанавливаем новый флажок
            // и меняем цвет клиентской области формы
            ToolStripMenuItem item = (ToolStripMenuItem)sender;
            itemChecked.Checked = false;// Сбрасываем старое
            (itemChecked = item).Checked = true;// Устанавливаем флажок и запоминаем элемент
            splitContainer.Panel1.BackColor = Color.FromName(item.Name);// Красим верхнюю панель
        }
    
        Bitmap CreateBitmap(Color color)
        {
            // Генерируем изображение в виде цветного прямоугольника
            Bitmap bm = new Bitmap(16, 16);
            Graphics gr = Graphics.FromImage(bm);
            gr.FillRectangle(new SolidBrush(color), 0, 0, 16, 16);
            gr.Dispose();   // Освобождаем контекст устройства
            return bm;
        }
    
        string InsertSpaceOut(string str)
        {
            // Вставляем пробелы перед заглавными буквами названия цвета
            for (int i = str.Length - 1; i > 1; i--)
                if (Char.IsUpper(str[i]))
                    str = str.Insert(i, " ");
            return str;
        }
    }
}

• Запустите
  приложение и для верхней панели сплиттера испытайте работу
  контекстного меню

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

Картинка с сайта: intuit.ru

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

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

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

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

• Выделите
  на форме Form5 все три радиокнопки одновременно
  и через панель Properties в режиме Events для
  события CheckedChanged создайте обработчик
  с именем radioButton_CheckedChanged(),
  который заполните следующим кодом

private void radioButton_CheckedChanged(object sender, EventArgs e)
        {
                if (radioButton1.Checked)
                    splitContainer1.Panel2.ContextMenuStrip = contextMenuStrip1;
                else if (radioButton2.Checked)
                    splitContainer1.Panel2.ContextMenuStrip = contextMenuStrip2;
                else
                    splitContainer1.Panel2.ContextMenuStrip = contextMenuStrip3;
        }

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

• Выделите
  элемент splitContainer1.Panel2 и через панель Properties в
  режиме Events создайте для события BindingContextChanged обработчик splitContainer1_Panel2_BindingContextChanged(),
  который заполните так

private void splitContainer1_Panel2_BindingContextChanged(object sender, EventArgs e)
        {
            if (radioButton1.Checked)
                splitContainer1.Panel2.ContextMenuStrip = contextMenuStrip1;
            else if (radioButton2.Checked)
                splitContainer1.Panel2.ContextMenuStrip = contextMenuStrip2;
            else
                splitContainer1.Panel2.ContextMenuStrip = contextMenuStrip3;
        }

• Запустите
  приложение и убедитесь в работоспособности всех 4-х контекстных
  меню, первое из которых создано динамически, а три остальных
  — декларативно

Картинка с сайта: intuit.ru

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

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

Компоненты, которые мы будем рассматривать далее, находятся в разделе Menus & Toolbars панели Toolbox, поэтому если не сказано другого, то ищите компонент именно в этом разделе.

5.9.1. MenuStrip

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

Если выделить компонент, то слева появятся светлый прямоугольник и серая надпись внутри Type Here (Напечатайте здесь). Если щелкнуть по этому прямоугольнику, то в нем появится маленькое поле ввода, в которое можно ввести имя нового пункта меню. Введите Файл и нажмите клавишу . Обратите внимание, что теперь и снизу от нашего пункта меню и справа снова появились прямоугольники с надписью Type Here (рис. 5.22).

Щелкнув на прямоугольнике снизу, можно создать пункт подменю, а если щелкнуть справа, то можно создать еще один раздел меню. Так можно создавать структуру программного меню. Попробуйте навести мышь на прямоугольник, но не щелкать по нему. В прямоугольнике появится кнопка выпадающего списка, по нажатию на которую появится всплывающее меню с элементами, которые вы можете добавить в компонент меню. Здесь у нас есть возможность работать со следующими компонентами:

• MenuItem — элемент меню, который создается по умолчанию;
• ComboBox — выпадающий список. Да, вы можете добавлять в качестве элементов меню даже выпадающий список, хотя это делается очень редко;
• Separator — полоса, которая разделяет подменю на группы. Тут нужно сделать акцент на подменю, потому что разделитель невозможно создать для основных разделов меню;
• TextBox — поле ввода тоже может быть внедрено прямо в меню.

Рис. 5.22. Редактор меню

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

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

   private void ToolStripMenuItem_Click(object sender, EventArgs e)
   {
     Close();
   }

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

Что интересного есть у пунктов меню? Во-первых, нужно понимать, что они происходят от класса ToolStripMenuItem и наследуют его свойства и методы. Наиболее интересные свойства следующие:

• Checked — булево значение, которое указывает, поставлен ли флажок Check
  у меню. Если меню отмечено, то слева от имени появляется флажок, как у CheckBox;
• CheckOnClick — это свойство указывает на то, что при выборе меню значение параметра Checked будет меняться на противоположное;
• CheckState — идентично по назначению с одноименным свойством у CheckBox;
• DisplayStyle — стиль отображения пункта меню. Здесь можно выбрать одно из значений:
• ImageAndText — картинка и текст;
• Image — картинка;
• Text — текст;
• None — ничего;
• DropDownItems — коллекция, в которой находятся элементы подменю для текущего пункта. Вы можете редактировать меню не только визуально, но и вызвав редактор этого свойства;
• Image — картинка для пункта меню;
• ImageAlign — определяет, в какую сторону должна быть выровнена картинка;
• ImageScaling — определяет, нужно ли растягивать картинку, чтобы она заполнила все пространство, выделенное под нее, если картинка меньше или больше;
• ImageTransparent — цвет прозрачности. Чаще всего среда разработки сама правильно определяет цвет, который должен быть прозрачным;
• ShortcutKeys — в этом свойстве вы можете задать сочетание клавиш, которые будут вызывать пункт меню. Вы можете написать сочетание клавиш руками
  в поле ввода свойства или щелкнуть по кнопке вызова выпадающего окна и в нем выбрать букву и кнопку модификатора;
• ShowShotcutKeys — определяет, нужно ли отображать в меню назначенное сочетание клавиш.

Для всех пунктов меню, в том числе и контекстных, которые мы будем рассматривать в разд. 5.9.2, самым интересным событием, конечно же, является Click, которое возникает, когда пользователь щелкнул по элементу меню. Помимо этого вам могут пригодиться события CheckedChanged и CheckStateChanged, которые возникают, когда пользователь поставил флажок (изменил свойство Changed) или изменил свойство CheckState соответственно.

5.9.2. ContextMenuStrip

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

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



Картинка с сайта: www.flenov.info

Рис. 5.23. Контекстное меню

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

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

5.9.3. ToolStrip

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

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

Рис. 5.24. Редактор панели

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

• Button — кнопка;
• Label — метка;
• SplitButton — кнопка, которая имеет дополнительную кнопку для вызова всплывающего меню. Основная и дополнительная кнопки работают независимо;
• DropDownButton — кнопка, которая вызывает всплывающее меню. Всплывающее меню появится именно по нажатию кнопки, без нажатия каких-либо дополнительных кнопок;
• Separator — разделитель, который позволяет логически разделять группы кнопок;
• ComboBox — выпадающий список;
• TextBox — текстовое поле ввода;
• ProgressBar — индикатор процесса.

Создаваемая кнопка ToolStripButton (кнопки такого класса создаются на панели ToolStrip) очень схожа по свойствам с кнопкой Button, которую мы уже рассматривали, только у нее есть свойства Checked, CheckOnClick и CheckState, как у пункта меню и у компонента CheckBox, чтобы кнопку можно было не просто нажимать, но и изменять состояние — утапливать и отпускать. Когда свойство CheckOnClick равно true, то при нажатии кнопка залипает, меняя состояние Checked на true, а при повторном нажатии кнопка отпускается, меняя Checked на false. В противном случае при нажатии кнопка нажимается и тут же отпускается.

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

Компоненты ComboBox, TextBox и ProgressBar идентичны стандартным компонентам, которые мы рассматривали в разд. 5.7.

5.9.4. StatusStrip

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

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

• StatusLabel — метка;
• ProgressBar — индикатор процесса;
• SplitButton — кнопка, которая имеет дополнительную кнопку для вызова всплывающего меню. Основная и дополнительная кнопки работают независимо;
• DropDownButton — кнопка, которая вызывает всплывающее меню. Всплывающее меню появится именно по нажатию кнопки, без нажатия на какие-либо дополнительные кнопки.

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

Все исходные коды главы 5 Библии C#