Стандартные меню приложений

Файлы к лабораторной работе Вы можете скачать здесь.

В библиотеке .NET Framework 2.0 появились три новых класса для организации пользовательского интерфейса управления приложением ( Strip - полоса):

Наряду с этими новыми элементами существуют и поддерживаются прежние аналогичные классы, существующие в версиях .NET Framework 1.x:

По умолчанию эти старые классы не подключены к панели Toolbox, поэтому не видны в ней, хотя и находятся в GAC (Global Assembly Cache). Но их легко подключить в любой свиток панели, вызвав для этого свитка контекстное меню и выполнив команду Choose Items

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

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

Заготовка приложения со стартовой формой

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

Выполните команду File/New/Project и заполните мастер создания приложения в соответствии с рисунком

Через панель Solution Explorer переименуйте файл Form1.cs в Start.cs, а заголовку окна формы присвойте значение Text =" Lab48 - Имя студента "

Поместите на форму библиотечный компонент ListBox и настройте его в соответствии с таблицей свойств

Через панель Properties создайте обработчик для события SelectedIndexChanged объекта listBoxChoice, который заполните так

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;
                }
    
                this.AddOwnedForm(frm);     // Сделать новую frm подчиненной Start
                // frm.Owner = this;        // Алтернативный способ назначить владельца
                frm.ShowInTaskbar = false;  // Не отображать метку окна в панели задач
                frm.Show();                 // Показать новую форму
            }
            else
                frm.Focus();                // Передать фокус запущенной форме        
        }

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

Командой меню оболочки Project/Add Windows Form добавьте в проект еще три формы с именами Form1, Form2, Form3

Запустите приложение и убедитесь в работоспособности механизма вызова отдельных упражнений

Упражнение 1. Простое меню

Рассмотрим простую программу, имитирующую работу меню.

Откройте файл Form1.cs в режиме View Code и добавьте к конструктору класса код создания простого меню

public Form1()
        {
            InitializeComponent();
    
            this.Text = "Простое меню";
    
            // Главное меню
            MenuStrip menu = new MenuStrip();
            this.Controls.Add(menu);
    
            // Раздел File
            ToolStripMenuItem itemFile = new ToolStripMenuItem();
            itemFile.Text = "File";
            menu.Items.Add(itemFile);// Элемент верхнего уровня
    
            // Раздел Help
            ToolStripMenuItem itemHelp = new ToolStripMenuItem();
            itemHelp.Text = "Help";
            menu.Items.Add(itemHelp);
    
            // Заполнение раздела File
            // Команда Open...
            ToolStripMenuItem itemOpen = new ToolStripMenuItem();
            itemOpen.Text = "Open...";
            itemOpen.ShortcutKeys = Keys.Control | Keys.O; // Ctrl+O
            itemOpen.ShowShortcutKeys = true;// Отображать в команде
            // Регистрировать вручную!!!!!!!!!!!!!!
            itemOpen.Click += new EventHandler(itemOpen_Click);
            itemFile.DropDownItems.Add(itemOpen);
            // itemOpen.ShowShortcutKeys = false;// Скрыть комбинацию 
    
            // Разделитель
            ToolStripSeparator itemSep = new ToolStripSeparator();
            itemFile.DropDownItems.Add(itemSep);
    
            // Команда Exit
            ToolStripMenuItem itemExit = new ToolStripMenuItem();
            itemExit.Text = "Exit";
            // Регистрировать вручную!!!!!!!!!!!!!!
            itemExit.Click += new EventHandler(itemExit_Click);
            itemFile.DropDownItems.Add(itemExit);
    
            // Заполнение раздела Help
            // Команда About...
            ToolStripMenuItem itemAbout = new ToolStripMenuItem();
            itemAbout.Text = "About...";
            itemAbout.ShortcutKeys = Keys.Control | Keys.A; // Ctrl+A
            itemAbout.ShortcutKeyDisplayString = "Ctrl^A";// Свое отображение
            itemAbout.ShowShortcutKeys = true;// Отображать в команде
            // Регистрировать вручную!!!!!!!!!!!!!!
            itemAbout.Click += new EventHandler(itemAbout_Click);
            itemHelp.DropDownItems.Add(itemAbout);
        }

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

void itemAbout_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Заготовка опции \"About...\"", this.Text);
        }
    
        void itemExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    
        void itemOpen_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Заготовка опции \"Open\"", this.Text);
        }
    }

В программе мы создаем объект меню, как экземпляр класса MenuStrip, и привязали его к объекту формы . У класса MenuStrip есть свойство Items, которое является коллекцией элементов меню верхнего уровня. Мы создаем два таких объекта itemFile и itemHelp типа ToolStripMenuItem и добавляем их в свойство Items. У каждого объекта типа ToolStripMenuItem есть свойство DropDownItems, готовое хранить коллекцию команд и разделителей, в том числе вложенных для построения меню сложной иерархии. В эти свойства элементов верхнего уровня мы добавляем объекты команд.

Схематично такая процедура построения меню примера изображена на рисунке

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

Свойство ShortcutKeys объекта команды ожидает побитовую комбинацию элементов перечисления System.Windows.Forms. Keys, задающую клавиши быстрого вызова этой команды. Логическое свойство ShowShortcutKeys объекта команды включает или выключает отображение заданной комбинации быстрого вызова справа от команды. По умолчанию задано значение true и комбинация клавиш отображается в том случае, если она назначена в свойстве ShortcutKeys. Свойство ShortcutKeyDisplayString позволяет задать иную строку отображения установленной комбинации, чем принято по умолчанию (например, вместо Ctrl+A по умолчанию можно задать Ctrl^A ).

Событие Click объекта команды возникает при выборе соответствующей команды и вызывает выполнение закрепленного обработчика.

Следует иметь ввиду, что как в коллекции Items меню верхнего уровня, так и в коллекциях DropDownItems выпадающих меню элементы отображаются в порядке их добавления в коллекцию. Свойства Items и DropDownItems являются экземплярами класса ToolStripItemCollection, который имеет метод Add(). Именно этим методом мы добавляем в коллекции объекты элементов меню. Сами элементы меню, добавляемые в коллекции, являются экземплярами класса ToolStripMenuItem.

Однако можно использовать и метод коллекции AddRange(), который ожидает ссылку на массив объектов команд. Так, например, пусть объекты itemFile, itemOpen, itemSep, itemExit уже созданы. Тогда к объекту верхнего уровня можно присоединить сразу все подчиненные объекты команд такой строкой кода:

itemFile.DropDownItems.AddRange(new ToolStripMenuItem[]{
            itemOpen, itemSep, itemExit});

Перегрузки метода Add() позволяют добавить команду меню вместе с текстом, текстом и изображением, текстом + изображением + именем обработчика события Click.

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

Упражнение 2. Меню с флажками

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

Появление флажка слева от команды включается булевым свойством Checked объекта команды. В качестве альтернативы можно установить свойство CheckState в одно из значений одноименного перечисления. Например для объекта itemOpen это можно определить так

Опция Indeterminate позволяет отобразить неопределенное состояние, когда на месте флажка помещается точка.

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

В этом упражнении мы создадим меню Font, которое будет выводить список шрифтов, поддерживаемых компьютером. Обычно у современных операционных систем этот список большой и не помещается на экране, поэтому будем использовать объект класса ToolStripDropDownMenu. Этот класс отвечает за появление стрелок, позволяющих перемещаться по меню, не вмещающему команды. Здесь мы используем создание и настройку меню частично в декларативном, частично в программном режиме. Ну уж а управление логикой работы меню можно выполнить только в программном режиме.

Декларативное создание меню

Откройте форму Form2 в режиме View Designer и поместите из панели Toolbox на форму экземпляр компонента MenuStrip с именем menu

При выделенном элементе меню в панели Properties раскройте свойство Items

В окне редактора меню выберите из раскрывающегося списка элемент MenuItem и щелчком на кнопке Add добавьте в коллекцию Items узел верхнего уровня

Присвойте добавленному элементу через таблицу свойств редактора меню Name = itemFormat, Text = Format и щелчком на кнопке OK завершите редактирование

При выделенном элементе ItemFormat в панели Properties раскройте свойство DropDownItems

В окне редактора меню выберите из раскрывающегося списка элемент MenuItem и щелчком на кнопке Add добавьте в коллекцию DropDownItems объект команды меню

Присвойте добавленному элементу через таблицу свойств редактора меню Name = itemFont, Text = Font и щелчком на кнопке OK завершите редактирование

Выполните приложение и проверьте работоспособность Form2 на данном этапе

Поместите из панели Toolbox экземпляр элемента Panel и настройте его свойства так:

Name = panel, Dock = Fill

Выделите объект panel и через панель Properties в режиме Events зарегистрируйте для события Paint обработчик и именем PanelOnPaint

На этом декларативная часть работы закончена. Далее займемся программной частью.

Программирование меню

Перейдите в режим View Code формы Form2 и добавьте перед конструктором класса Form2 объявление ссылки на элемент меню

public partial class Form2 : Form
    {
        // Объявили поле-ссылку на объект команды меню
        ToolStripMenuItem itemSelectedFont;
    
        public Form2()
        {
            InitializeComponent();
        }
    
        private void PanelOnPaint(object sender, PaintEventArgs e)
        {
        }
    }

Добавьте в конструктор класса Form2 после вызова функции инициализации компонентов код динамического заполнения списка команд в коллекцию команды Font

public Form2()
        {
            InitializeComponent();
    
            // Заполнение коллекции объекта itemFont 
            // списком доступных шрифтов стиля "Обычный"
            Graphics gr = CreateGraphics(); // Ссылка на контекст устройства
            // Читаем все шрифты 
            FontFamily[] fonts = FontFamily.GetFamilies(gr);
    
            // Перебираем шрифты и формируем команды меню Font
            foreach (FontFamily font in fonts)
            {
                // Выбираем шрифты одного стиля "Обычный"
                if (font.IsStyleAvailable(FontStyle.Regular))
                {
                    // Добавляем в коллекцию команды Font
                    ToolStripMenuItem item = 
                        (ToolStripMenuItem)itemFont.DropDownItems.Add(font.Name);
    
                    // Если встретился текущий шрифт формы, 
                    // запоминаем эту команду и отмечаем флажком
                    if (font.Name == this.Font.Name)
                    {
                        itemSelectedFont = item;
                        itemSelectedFont.Checked = true;
                    }
                }
            }
    
            gr.Dispose(); // Освобождаем ограниченный ресурс 
        }

Запустите приложение и удостоверьтесь, что при раскрытии команды меню Font она уже заполнена элементами названий шрифтов

Теперь обеспечим нужную функциональность выбора шрифтов и отображения их названия на клиентской области панели panel.

Подпишите добавленный в коллекцию команды Font элемент item на событие Click. Для этого наберите вручную!!!, чтобы правильно создать обработчик, следующий код в конце условия if

public Form2()
        {
            ....................................................
    
            // Перебираем шрифты и формируем команды меню Font
            foreach (FontFamily font in fonts)
            {
                // Выбираем шрифты одного стиля "Обычный"
                if (font.IsStyleAvailable(FontStyle.Regular))
                {
                    ...............................................
    
                    // Следующую строчку введите вручную!!!
                    item.Click += new EventHandler(item_Click);
                }
            }
    
            gr.Dispose(); // Освобождаем ограниченный ресурс 
        }

Заполните обработчик item_Click() следующим кодом, который будет сбрасывать флажок с выбранного ранее шрифта и устанавливать его на новом выбранном шрифте

void item_Click(object sender, EventArgs e)
        {
            // Повышаем полномочия ссылки для адресации к выделенной команде 
            ToolStripMenuItem item = (ToolStripMenuItem)sender;
            itemSelectedFont.Checked = false;   // Сбрасываем предыдущий флажок
            item.Checked = true;    // Поднимаем новый флажок
            itemSelectedFont = item;// Запоминаем отмеченную команду
            panel.Invalidate();     // Перерисовываем панель с новым шрифтом
        }

Найдите созданный ранее обработчик события Paint панели и заполните его кодом перерисовки панели с новым шрифтом

private void PanelOnPaint(object sender, PaintEventArgs e)
        {
            Graphics gr = e.Graphics;   // Получаем контекст устройства 
    
            // Создаем новый шрифт по выбранному в меню с заведомо
            // большим размером, чтобы потом подогнать уменьшением
            float emSize = 100.0F;
            System.Drawing.Font font = 
                new Font(itemSelectedFont.Text.Trim(), emSize); 
            String str = font.Name; // Строка для рисования
    
            // Подгоняем размер текстового блока под ширину формы 
            float widthText = gr.MeasureString(str, 
                font = new Font(itemSelectedFont.Text, emSize)).Width;
            while ((panel.ClientSize.Width - widthText) < 0.0F)
            {
                emSize -= 0.5F;
                widthText = gr.MeasureString(str, 
                    font = new Font(itemSelectedFont.Text, emSize)).Width;
            }
    
            // Настроим точку привязки текстового блока
            System.Drawing.StringFormat fmt = new StringFormat();
            fmt.Alignment = StringAlignment.Center; // По горизонтали
            fmt.LineAlignment = StringAlignment.Center;   // По вертикали
    
            // Настроим точку привязки клиентской области панели
            PointF point = new PointF(panel.ClientSize.Width / 2,
                panel.ClientSize.Height / 2);
    
            // Рисуем на панели название выбранного шрифта текущим цветом формы
            gr.DrawString(str, font, 
                new SolidBrush(this.ForeColor), point, fmt);
        }

В классе Form2 переопределите унаследованный виртуальный метод диспетчеризации OnResize() (ввод начните с ключевого слова override ) и заполните его следующим кодом

protected override void OnResize(EventArgs e)
        {
            panel.Invalidate();
            base.OnResize(e);
        }

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

Запустите Form2 и удостовертесь в ее работоспособности, результат будет таким

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

Упражнение 3. Меню с изображениями

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

Если распаковать этот архив, то используемые в меню изображения хранятся в папке bitmaps/commands, рассортированные по разной глубине цвета. Если в Вашей системе нет этих пиктограмм, то их можно найти в прилагаемом к данной лабораторной работе каталоге Source.

Служебные изображения в программе удобнее использовать как ресурсы, внедренные в исполнимую сборку и переносимые вместе с этой сборкой. Файл изображения добавляется к проекту командой Project/Add Existing Item, после чего оболочка физически скопирует его в каталог размещения проекта и он появится в панели Solution Explorer.

Далее можно использовать один из способов превращения этого файла в ресурс приложения: выделить этот файл и через панель Properties установить для него опцию Build Action равной Embedded Resource. Это заставит оболочку при компиляции внедрять указанный файл как ресурс в сборку приложения. Внутри самого кода приложения мы можем адресоваться к этому файлу.

Пусть, например, мы хотим использовать пиктограмму Open.bmp и добавили этот файл в проект. Доступ к изображению из кода программы можно осуществить разными способа, например, с помощью следующего кода

Bitmap bmCut = new Bitmap(this.GetType(), "path.Open.bmp");

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

Присоединить изображение к элементу меню можно присвоением ссылки свойству Image соответствующей команды, например

itemCut.Image = bmCut;

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

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

Откройте файл Form3.cs в режиме View Designer и задайте свойству Text формы значение " Простой редактор изображений "

Поместите на форму компонент PictureBox и настройте его так: Name = pictureBox, Dock = Fill

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

Декларативная часть создания меню

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

Поместите на форму компонент MenuStrip с именем menu и настройте его декларативно в соответствии с приведенным ниже деревом свойств

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

Дерево свойств для создания и настройки меню упражнения

На схеме свойство ( Name ) взято в скобки, поскольку это не свойство элемента меню, а имя ссылки, адресующейся к объекту. Хотя у элементов управления все же есть свойство Name типа String, но его чаще всего используют как метку элемента для его узнаваемости в коллекции, но не как адресную ссылку.

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

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

Добавление пиктограмм к объектам команд

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

Изображения мы планируем добавить к следующим объектам команд:

Большинство современных компьютеров поддерживают глубину цвета 24 бита, поэтому готовые рисунки будем копировать из соответствующей папки с именем 24bitcolor, которую можно найти в прилагаемом каталоге Source (или в архиве C:\Program Files\Microsoft Visual Studio 8\Common7\VS2005ImageLibrary\VS2005ImageLibrary.zip ).

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

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

Способ 1. Загрузка рисунков через локальный файл ресурсов

В панели Solution Explorer двойным щелчком на локальном XML -файле разметки Form3.resx вызовите редактор ресурсов и через первый узел меню установите режим Images

Выполните команду Add Resource/Add Existing File меню редактора ресурсов и, удерживая клавишу Ctrl, добавьте в ресурс файлы Cut.bmp и Copy.bmp глубиной 24bitcolor из прилагаемого к работе каталога Source

Выполните команду View Details меню View редактора ресурсов, чтобы отобразить представление ресурсов в виде таблицы

Откройте панель Solution Explorer и убедитесь, что оболочка создала каталог Resources, в который скопировала отмеченные файлы

Оболочка автоматически присвоила ресурсам подходящие имена, которые мы можем изменить в панели Properties, выделяя соответствующие ресурсы. Здесь же мы можем указать, где физически до компиляции будут располагаться рисунки: в XML -файле ресурсов Form3.resx или в отдельных BMP -файлах, на которые в XML -файле разметки будут помещены только ссылки.

Пока у нас рисунки имеют состояние Linked at compile time, что означает, что при компиляции их код будет внедрен в исполнимую сборку прямо из BMP -файлов по ссылкам, помещенным в XML -файл Form3.resx. Поэтому присутствие BMP -файлов в проекте обязательно при каждой компиляции. При установке для любого рисунка опции Embedded in .resx оболочка уже на этапе проектирования сразу же физически разместит его код в файле Form3.resx. После чего мы можем удалить соответствующий BMP -файл из проекта.

Чтобы убедиться в сказанном, выполните следующее:

В панели Solution Explorer вызовите контекстное меню для узла Form3.resx и выполните команду View Em, чтобы открыть XML -файл ресурсов в режиме разметки

Убедитесь, что в конце XML -файла прописаны только ссылки на добавленные в проект файлы рисунков

<data name="Copy" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>Resources\Copy.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>
  <data name="Cut" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>Resources\Cut.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>

В панели Solution Explorer вызовите контекстное меню для узла Form3.resx и выполните команду View Designer, чтобы открыть файл ресурсов в режиме визуального конструктора

Выделите ресурс Cut и через панель Properties установите для него свойство Persistence в значение Embedded in .resx

Вновь откройте Form3.resx в режиме View Em и убедитесь, что вместо ссылки на файл Cut.bmp оболочка включила в ресурс сам код этого рисунка

<data name="Copy" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>Resources\Copy.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>
  <data name="Cut" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        Qk02AwAAAAAAADYAAAAoAAAAEAAAABAAAAABABgAAAAAAAAAAAASCwAAEgsAAAAAAAAAAAAA/wD//wD/
        /wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD/u6GUl19FY0Iy
        oo2C/wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD/zYZjq2I/ilAzYkU3vb2+uZ+SZkM0
        Xj8wqJGG/wD//wD//wD//wD//wD//wD//wD/3YNVw7KquJyOhU4zwMDAxYJhqmI+YzwpLyUj/wD//wD/
        /wD//wD//wD//wD//wD/4YVXxbOqva6ojFI1vLi21HxSwrKqrpSGa0It/wD//wD//wD//wD//wD//wD/
        /wD/2ph25YZWsGZBj1U4nHJdyXVNwbm1up6Qj1U2/wD//wD//wD//wD//wD//wD//wD/yLWs645d24JW
        n19AlGBHvnRP1XtPuWtFrYd0/wD//wD//wD//wD//wD//wD//wD//wD/yLau3pl234RWxo1wzHhN0nxR
        xpF3vaec/wD//wD//wD//wD//wD//wD//wD//wD//wD//wD/iHNmcWBWhmdVq56Z/wD//wD//wD//wD/
        /wD//wD//wD//wD//wD//wD//wD/uLSxjoB0fm5jaV1VdnJu/wD//wD//wD//wD//wD//wD//wD//wD/
        /wD//wD//wD/urCqopSLqKCZjoF3Y1tV/wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD/vrGq
        oZSLyMbEzcXAa19Wra2u/wD//wD//wD//wD//wD//wD//wD//wD//wD//wD/qZuSsqijw8PD6OTifG9m
        qKmq/wD//wD//wD//wD//wD//wD//wD//wD//wD/u7i2o5aMvLq5/wD/3dzcvLKrpqGe/wD//wD//wD/
        /wD//wD//wD//wD//wD//wD/v7izs6ie/wD//wD/y8vL4t3aoZeQ/wD//wD//wD//wD//wD//wD//wD/
        /wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD//wD/
    </value>
  </data>

Выделите ресурс Cut и через панель Properties верните свойство Persistence в прежнее значение Linked at compile time

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

Добавим к проекту файл рисунка Paste.bmp и сообщим компилятору о необходимости включать его код в исполнимую сборку.

В панели Solution Explorer вызовите контекстное меню для папки Resources, в которой уже должны находиться файлы Cut.bmp и Copy.bmp с глубиной цвета 24bitcolor, и командой Add/Existing Item добавьте к проекту из каталога Source файл Paste.bmp с такой же глубиной цвета, предварительно установив для диалогового окна соответствующий фильтр

Выделите файл Paste.bmp и в панели Properties установите для него Build Action = Embedded Resource

При такой настройке при компиляции код файла будет копироваться в исполнимую сборку.

Способ 3. Присоединение рисунка к свойству Image элемента меню через стандартный файл глобальных ресурсов проекта

Присоединим к свойству Image элемента меню itemDelete файл с рисунком Delete.bmp через стандартный файл глобальных ресурсов. Этот файл может хранить в себе множественные ресурсы, которые доступны в любом месте кода программы.

Откройте файл Form3.cs в режиме View Designer, выделите через раскрывающийся список панели Properties элемент itemDelete, раскройте его свойство Image и для режима Project resource file загрузите в элемент кнопкой Import файл Delete.bmp из прилагаемого к работе каталога Source

Загруженная пиктограмма немедленно появится слева от команды Delete на меню формы

Откройте в каталоге Properties проекта стандартный файл глобальных ресурсов Resources проекта в режиме View Em и убедитесь, что оболочка поместила относительную ссылку на Delete.bmp в этот файл

<data name="Delete" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>..\Resources\Delete.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>

Откройте файл Form3.Designer.cs и в секции #region убедитесь, что оболочка сразу прописала код присоединения рисунка к элементу меню

// 
            // itemDelete
            // 
            this.itemDelete.Image = global::StripControls.Properties.Resources.Delete;

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

Замечание. Если пытаться немедленно присоединить к элементу файл рисунка через локальный ресурс в использованном нами окне Select Resource, то оболочка выкинет все ранее присоединенные файлы из этого ресурса (В нашем случае Cut и Copy ) и оставит только один непосредственно присоединяемый к элементу управления ресурс.

Способ 4. Размещение рисунка в пользовательском файле глобальных ресурсов

Загрузим рисунок Open.bmp в файл пользовательский глобальных ресурсов MyResources.resx, который нужно создать и добавить к проекту в любое место.

В панели Solution Explorer вызовите контекстное меню для папки Resources и добавьте в нее командой Add/New Item новый файл глобальных ресурсов с именем MyResources.resx

В панели Solution Explorer двойным щелчком на файле Resources.resx откройте его в режиме View Designer

Переведите редактор в режим Images и командой Add Resource/Add Existing File добавьте к проекту файл Open.bmp глубиной цвета 24bitcolor из прилагаемого каталога Source точно также, как мы это делали ранее при загрузке файлов Cut.bmp и Copy.bmp в локальный ресурс Form3.resx

Оболочка физически скопирует файл Open.bmp в каталог Resources проекта и пропишет относительную ссылку на него в пользовательском XML -файле разметки MyResources.resx глобальных ресурсов

<data name="Open" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>..\Resources\Open.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, 
      Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>

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

Способ 5. Загрузка пиктограммы из файла рисунка во время выполнения

Файл Save.bmp мы будем загружать в элемент itemSaveAs непосредственно во время выполнения программы. Поэтому нужно присоединить его к проекту и настроить свойства так, чтобы оболочка при компиляции копировала этот файл в место размещения исполнимой сборки.

В панели Solution Explorer вызовите контекстное меню для папки Resources и командой Add/Existing Item добавьте в проект файл Save.bmp ( 24bitcolor ) из прилагаемого каталога Source

Выделите скопированный файл Save.bmp и через панель Properties установите свойство Copy to Output Directory в значение Copy if newer, чтобы оболочка скопировала файл в каталог размещения исполнимой сборки

Динамическое присоединение пиктограмм к элементам меню

Итак, на предудущих этапах работы мы загрузили все нужные файлы с пиктограммами в файлы ресурсов проекта или просто в каталог Resources проекта. Ресурс файла Delete.bmp мы сразу присоединили к свойству Image элемента меню itemDelete, поэтому дальнейших действий для этого элемента никаких не требуется. Ресурсы остальных пиктограмм пропишем в коде и они будут присоединяться к элементам меню на этапе выполнения программы.

Откройте файл Form3.cs в режиме View Em и добавьте в класс Form3 следующую функцию с именем LoadImages() для присоединения рисунков к элементам меню

// Загрузка изображений в элементы меню
        void LoadImages()
        {
            // Присоединяем 2 пиктограммы из 
            // файла локальных ресурсов Form3.resx 
            ResourceManager resources =
                new ResourceManager(typeof(Form3));//или (this.GetType())
            itemCopy.Image = (Image)resources.GetObject("Copy");
            itemCut.Image = (Image)resources.GetObject("Cut");
    
            // Присоединяем пиктограмму из файла,
            // помеченного как Embedded Resource 
            itemPaste.Image = new Bitmap(this.GetType(),    // или (typeof(Form3)
                "Resources.Paste.bmp");
    
            ///////////////////////////////
            // Пиктограмма для Delete внедрена декларативно
            // через стандартный файл глобальных ресурсов,
            // поэтому для нее ничего не делаем 
            ///////////////////////////////
    
            // Присоединяем пиктограмму из пользовательского 
            // файла глобальных ресурсов MyResources.resx 
            itemOpen.Image = Resources.MyResources.Open;
    
            // Присоединяем пиктограмму непосредственно из файла рисунка
            itemSaveAs.Image = new Bitmap("Resources\\Save.bmp");
        }

Вставьте в конструктор класса Form3 после вызова метода InitializeComponent() следующий код, выполняющий присоединение

public Form3()
        {
            InitializeComponent();
    
            LoadImages();// Присоединяем пиктограммы 
        }

Запустите Упражнение 3 на выполнение и убедитесь в наличии пиктограмм для назначенных элементов меню

Обратите внимание на то, что для меню View заготовлен только узел itemView, а его коллекция DropDownItems пока пуста, поскольку ранее мы договорились наполнить ее программным способом. Вот это сейчас мы и выполним.

Создание элементов меню программным способом

Меню View будет управлять формой представления рисунков элементом pictureBox, который мы добавили на Form3 ранее. Через общий обработчик элементов меню View мы будем передавать в pictureBox требуемые значения его свойства SizeMode из библиотечного перечисления PictureBoxSizeMode. Закрепленное за элементом меню значение перечисления PictureBoxSizeMode будем сохранять в свойстве Tag элемента и извлекать его в обработчике с последующей распаковкой ссылочного типа Object в значимый тип PictureBoxSizeMode.

Схема свойств меню View

Здесь свойство Name - это свойство элемента типа String, а не имя ссылки с адресом объекта. При настройке элементов меню по приведенному ниже коду не забудьте начать набор строки регистрации обработчика события Click для первого элемента DropDownItems[0] вручную - с применением клавиши Tab. Это позволит создать обработчик с правильной сигнатурой. После правильного создания общего обработчика для подписки события Click последующих элементов можно воспользоваться упрощенным синтаксисом.

Добавьте в класс Form3 функцию с именем CreateView() для создания и настройки элементов меню View. Код функции соответствует приведенной выше схеме и представлен ниже

// Функция создания элементов меню View программным способом
        void CreateView()
        {
            // Имя элемента меню на верхнем уровне для возможности 
            // адресации в коллекции Items по его имени 
            itemView.Name = "View";
    
            ToolStripMenuItem item=new ToolStripMenuItem("Normal");
            item.Tag = PictureBoxSizeMode.Normal;
            // Создайте вручную!!!!!!!
            item.Click += new EventHandler(ViewOnClick);
            itemView.DropDownItems.Add(item);// Добавили в коллекцию View 
            // Имя элемента меню View для возможности адресации
            // в коллекции DropDownItems по его имени
            item.Name = "Normal";
            // Отмечаем флажок, поскольку в начальном состоянии 
            // свойство SizeMode элемента PictureBox именно Normal
            item.Checked = true;
    
            item = new ToolStripMenuItem();
            item.Text = "Center";
            item.Tag = PictureBoxSizeMode.CenterImage;
            item.Click += ViewOnClick;
            itemView.DropDownItems.Add(item);
            item.Name = "Center";
    
            item = new ToolStripMenuItem("Stretch");
            item.Tag = PictureBoxSizeMode.StretchImage;
            item.Click += ViewOnClick;
            itemView.DropDownItems.Add(item);
            item.Name = "Stretch";
    
            item = new ToolStripMenuItem();
            item.Text = "Zoom";
            item.Tag = PictureBoxSizeMode.Zoom;
            item.Click += ViewOnClick;
            itemView.DropDownItems.Add(item);
            item.Name = "Zoom";
    
            item = new ToolStripMenuItem("AutoSize");
            item.Tag = PictureBoxSizeMode.AutoSize;
            item.Click += ViewOnClick;
            itemView.DropDownItems.Add(item);
            item.Name = "AutoSize";
        }

Еще раз вспомним, что порядок следования кода добавления элементов в коллекцию определяет их порядок прорисовки в работающем приложении. При создании элементов меню View мы поочередно используем разные перегрузки конструктора класса ToolStripMenuItem. Мы задаем свойству Tag типа Object упакованное значение перечисления PictureBoxSizeMode, чтобы затем в обработчике распаковать его. Помечая элемент значением свойства Name мы перестраховываемся на тот случай, если вдруг далее нам придется к нему адресоваться в коллекции по синтаксису ассоциативного массива (адресация в массиве по индексу или по имени).

Вставьте в конец конструктора Form3() одноименного класса код вызова функции CreateView()

public partial class Form3 : Form
    {
        public Form3()
        {
            InitializeComponent();
    
            LoadImages();// Присоединяем пиктограммы 
    
            CreateView();// Динамически заполняем меню View
        }

В созданный обработчик ViewOnClick() внесите следующий код

void ViewOnClick(object sender, EventArgs e)
        {
            // Приводим ссылку на элемент меню View, сгенерировавший событие 
            ToolStripMenuItem item = (ToolStripMenuItem)sender;
    
            // Распаковываем объект и используем сохраненную 
            // в нем информацию для управления контейнером рисунков
            pictureBox.SizeMode = (PictureBoxSizeMode)item.Tag;
    
            ////////////////////////////////////////////////////////
            // Управление флажками выполним в обработчике события
            // DropDownOpening, которое информирует о раскрытия узла View
            ////////////////////////////////////////////////////////
            //////////// Следующий код закомментирован /////////////
            ////////////      Жалко выбрасывать!!!     /////////////
            /*//////////////////////////////////////////////////////
            // Сбрасываем флажки всех элементов 
            foreach (ToolStripMenuItem it in itemView.DropDownItems)
                it.Checked = false;
            // Устанавливаем флажок на выделенном элементе,
            // адресуясь к коллекции по имени элемента
            ((ToolStripMenuItem)itemView.DropDownItems[item.Name]).Checked = true;
            //item.Checked = true;  // Альтернативный вариант
            //*/////////////////////////////////////////////////////
        }

Запустите Упражнение 3 и убедитесь, что команды узла View динамически формируются

Программирование узлов меню верхнего уровня

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

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

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

Узел File:

Найдите обработчик FileOnDropDown() события DropDownOpening, которое генерируется при раскрытии элемента File, и запрограммируйте его следующим образом

private void FileOnDropDown(object sender, EventArgs e)
        {
            // Сделать недоступным команду SaveAs, если контейнер пустой 
            itemSaveAs.Enabled = pictureBox.Image != null;
        }

Узел Edit:

Найдите обработчик EditOnDropDown() события DropDownOpening узла Edit и запрограммируйте его так

private void EditOnDropDown(object sender, EventArgs e)
        {
            /////////////////////////////////////////////////
            // Регулируем доступность команд Copy, Cut, Delete
            /////////////////////////////////////////////////
            // Нечего редактировать - контейнер пустой 
            itemCopy.Enabled = itemCut.Enabled = itemDelete.Enabled =
                pictureBox.Image != null;
    
            /////////////////////////////////////////////////
            // Регулируем доступность команды Paste
            /////////////////////////////////////////////////
            // Ивлекаем адрес системного буфера обмена, 
            // используя интерфейсную ссылку базового типа
            IDataObject data = Clipboard.GetDataObject();
            // Если системный буфер не содержит рисунков 
            // подходящего типа, то вставлять тоже нечего 
            itemPaste.Enabled = data.GetDataPresent(typeof(Bitmap))
                || data.GetDataPresent(typeof(System.Drawing.Imaging.Metafile));
        }

Узел View:

Найдите обработчик ViewOnDropDown() для узла View и внесите в него следующий код

private void ViewOnDropDown(object sender, EventArgs e)
        {
            // При раскрытии узла View перебираем коллекцию 
            // и управляем флажками с помощью состояния pictureBox
            foreach (ToolStripMenuItem item in itemView.DropDownItems)
            {
                item.Checked = 
                    (PictureBoxSizeMode)item.Tag == pictureBox.SizeMode;
            }
        }

Программирование команд

Приступим к программированию самих команд всплывающих меню.

Команда Exit:

Найдите обработчик ExitOnClick() для команды Exit и закодируйте его так

private void ExitOnClick(object sender, EventArgs e)
        {
            this.Close();
        }

Команда Delete:

Найдите обработчик DeleteOnClick() для команды Delete и внесите в него следующий код

private void DeleteOnClick(object sender, EventArgs e)
        {
            pictureBox.Image = null;
        }

В этом обработчике мы просто обнуляем ссылку на рисунок и изображение исчезает из контейнера pictureBox.

Команда Copy:

Найдите обработчик CopyOnClick() для команды Copy и заполните его так

private void CopyOnClick(object sender, EventArgs e)
        {
            // Заполняем системный буфер обмена рисунком контейнера
            // Если при раскрытии узла Edit текущий 
            // рисунок есть, то команда Copy доступна
            Clipboard.SetDataObject(pictureBox.Image, true);
        }

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