Благодарности 7 страница

Открытие существующего файла

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

Значок компонента OpenFileDialog будет показан в нижней части формы (рис. 4-13), причем этот компонент получит идентификатор openFileDialog1. Этот идентификатор будет использован нами в программном коде, открывающем исходный файл.

Рис. 4-13. Добавление компонента OpenFileDialog

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

/// < summary>
/// Открытие существующего файла
/// < /summary>
private void MenuFileOpen()
{
if(openFileDialog1.ShowDialog() ==
System.Windows.Forms.DialogResult.OK & &
openFileDialog1.FileName.Length > 0)
{
try
{
richTextBox1.LoadFile(openFileDialog1.FileName,
RichTextBoxStreamType.RichText);
}
catch (System.ArgumentException ex)
{
richTextBox1.LoadFile(openFileDialog1.FileName,
RichTextBoxStreamType.PlainText);
}

this.Text = " Файл [" + openFileDialog1.FileName + " ]";
}
}

Далее добавьте вызов этого метода в обработчик события menuFileOpen_Click, получающий управление при выборе строки Open из меню File:

private void menuFileOpen_Click(object sender, System.EventArgs e)
{
MenuFileOpen();
}

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

Как работает метод MenuFileOpen?

Получив управление, он вызывает метод openFileDialog1.ShowDialog, отображающий на экране стандартное диалоговое окно выбора файла (рис. 4-14).

Рис. 4-14. Стандартное диалоговое окно выбора файла

Настраивая свойства компонента openFileDialog1, можно изменять внешний вид этого окна.

Задайте фильтр имен открываемых файлов. Для этого выделите компонент openFileDialog1 в окне дизайнера форм левой клавишей мыши, а затем измените свойство Filter. Присвойте этому свойству следующую текстовую строку:

RTF files|*.rtf|Text files|*.txt|All files|*.*

Строка фильтра состоит из блоков, разделенных символом |. Первый блок задает название типа файла RTF files, отображаемое в поле Files of type диалогового окна выбора файла (рис. 4-14), а второе — маску для имен файлов. Таким образом, для открытия документов RTF используется маска *.rtf.

Далее следует название формата Text files, соответствующее обычным текстовым файлам. Для этого формата применяется маска *.txt.

И, наконец, чтобы приложение могло открывать файлы любых типов (All files), используется маска *.*.

Продолжим работу. Оттранслируйте и запустите наше приложение. Выбрав с помощью только что описанного окна текстовый файл или файл RTF, щелкните кнопку Open. Выбранный файл будет загружен в окно нашего редактора текста (рис. 4-15).

Рис. 4-15. Загружен файл для редактирования

Полный путь к редактируемому файлу будет отображен в заголовке главного окна нашего приложения.

Подробнее о диалоговых окнах мы расскажем в главе 5 с названием «Диалоговые окна». Сейчас же мы только отметим, что если в окне выбора файла пользователь щелкнул кнопку Open, метод ShowDialog возвращает значение System.Windows.Forms.DialogResult.OK. В этом случае мы также дополнительно проверяем, что файл был выбран. Для этого мы сравниваем длину строки полного пути к выбранному файлу openFileDialog1.FileName.Length с нулем:

if(openFileDialog1.ShowDialog() ==
System.Windows.Forms.DialogResult.OK & &
openFileDialog1.FileName.Length > 0)
{
…
}

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

try
{
richTextBox1.LoadFile(openFileDialog1.FileName,
RichTextBoxStreamType.RichText);
}
catch (System.ArgumentException ex)
{
richTextBox1.LoadFile(openFileDialog1.FileName,
RichTextBoxStreamType.PlainText);
}

В качестве первого параметра этому методу передается путь к файлу, а в качестве второго — тип файла RichTextBoxStreamType.RichText. Этот тип соответствует формату RTF.

В том случае, если выбранный файл имеет формат, отличный от RTF, в методе LoadFile возникает исключение System.ArgumentException. Наш обработчик этого исключения выполняет повторную попытку загрузить файл, но на этот раз уже как обычный текст. Для этого мы передаем в качестве второго параметра методу LoadFile значение RichTextBoxStreamType.PlainText.

Сохранение файла

Чтобы добавить в наше приложение возможность сохранения документов, перетащите из панели инструментов Toolbox в окно дизайнера форм компонент SaveFileDialog. Этот компонент получит идентификатор saveFileDialog1 (рис. 4-16).

Рис. 4-16. Добавление компонента SaveFileDialog

После добавления этого компонента отредактируйте его свойства Filter и FileName.

Свойство Filter должно иметь значение, обеспечивающее работу с документами RTF:

RTF files|*.rtf

Для свойства FileName задайте значение doc1.rtf. При этом по умолчанию документы будут сохраняться в файле с этим именем (рис. 4-17).

Рис. 4-17. Стандартное диалоговое окно сохранения файла

Для сохранения документов в файле добавьте в класс SimpleNotepadForm следующий метод с именем MenuFileSaveAs:

/// < summary>
/// Сохранение документа в новом файле
/// < /summary>
private void MenuFileSaveAs()
{
if(saveFileDialog1.ShowDialog() ==
System.Windows.Forms.DialogResult.OK & &
saveFileDialog1.FileName.Length > 0)
{
richTextBox1.SaveFile(saveFileDialog1.FileName);
this.Text = " Файл [" + saveFileDialog1.FileName + " ]";

}
}

Здесь метод saveFileDialog1.ShowDialog отображает стандартный диалог сохранения файлов, показанный на рис. 4-17. Если пользователь указал имя файла и щелкнул в этом диалоге кнопку Save, метод MenuFileSaveAs сохраняет документ в файле, вызывая для этого метод richTextBox1.SaveFile.

Далее этот метод отображает имя сохраненного файла в заголовке окна нашего приложения:

this.Text = " Файл [" + saveFileDialog1.FileName + " ]";

Заметим, что существует несколько перегруженных вариантов метода SaveFile.

Если методу SaveFile задан один параметр (путь к сохраняемому файлу), то документ будет сохранен в формате RTF.

Второй параметр позволяет выбрать тип сохраняемого файла.

Если передать через этот параметр значение RichTextBoxStreamType.PlainText, документ будет сохранен в виде текстового файла с потерей форматирования. В том случае, когда нужно сохранить документ в формате RTF, используйте значение RichTextBoxStreamType.RichText. Можно также сохранить документ и как текст Unicode, для чего нужно передать через второй параметр методу SaveFile значение RichTextBoxStreamType.UnicodePlainText.

Определив в исходном тексте нашего приложения метод MenuFileSaveAs, добавьте его вызов в обработчики событий от строк Save и Save As меню File:

private void menuFileSave_Click(object sender, System.EventArgs e)
{
MenuFileSaveAs();
}

private void menuFileSaveAs_Click(object sender, System.EventArgs e)
{
MenuFileSaveAs();
}

Для простоты мы сделаем функции этих строк меню одинаковыми.

Печать документа

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

Добавление программных компонентов для печати

Добавьте в окно дизайнера форм компоненты PrintDocument, PrintDialog, PrintPreviewDialog и PageSetupDialog, как это показано на рис. 4-18 (если все программные компоненты не помещаются в видимую часто окна, щелкните окно с компонентами правой клавишей мыши и выберите строку Line Up Icons, для того чтобы упорядочить значки компонентов).

Рис. 4-18. Добавлены компоненты для печати документов

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

Компонент PrintDocument предназначен для вывода данных документа на принтер. Сразу после добавления этот компонент получает идентификатор printDocument1.

Свойства компонента PrintDocument описывают, как именно нужно распечатывать документ. Запишите в свойство DocumentName компонента PrintDocument строку SimpleNotepad Document. Эта строка будет идентифицировать наш документ при отображении состояния очереди печати. Значения остальных свойств оставьте без изменения.

С помощью компонента PrintDialog наше приложение выведет на экран стандартное диалоговое окно печати документа (рис. 4-19).

Рис. 4-19. Стандартное диалоговое окно печати документа

Перед использованием компонента PrintDialog задайте значение его свойства Document, равным printDocument1. Этим Вы обеспечите связь компонента PrintDialog с компонентом PrintDocument, указав таким способом документ, который следует распечатать.

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

Окно предварительного просмотра документа перед печатью показано на рис. 4-20.

Рис. 4-20. Окно предварительного просмотра документа перед печатью

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

Что же касается окна настройки параметров страницы документа (рис. 4-21), то с его помощью пользователь сможет выбрать размер бумаги, расположение документа на бумаге, поля и т.д.

Рис. 4-21. Окно настройки параметров страницы документа

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

Редактирование меню File

Прежде чем продолжить создание приложения SimpleNotepad, отредактируйте меню File. В этом меню должны быть строки PageSetup, Print Preview и Print.

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

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

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

using System.IO;
using System.Drawing.Printing;

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

Настройка параметров страницы документа

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

Добавьте в класс SimpleNotepadForm метод MenuFilePageSetup, предназначенный для вывода на экран диалогового окна настройки параметров страницы документа, показанного на рис. 4-21:

/// < summary>
/// Настройка параметров страницы
/// < /summary>
private void MenuFilePageSetup()
{
pageSetupDialog1.ShowDialog();
}

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

private void menuFilePageSetup_Click(object sender,
System.EventArgs e)
{
MenuFilePageSetup();
}

После трансляции и запуска приложения строка Page Setup меню File начнет выполнять свои функции.

Предварительный просмотр документа перед печатью

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

Прежде всего, добавьте в класс SimpleNotepadForm поля m_myReader и m_PrintPageNumber, как это показано ниже:

/// < summary>
/// StringReader для печати содержимого редактора текста
/// < /summary>
private StringReader m_myReader;

/// < summary>
/// Номер текущей распечатываемой страницы документа
/// < /summary>
private uint m_PrintPageNumber;

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

Добавьте в класс SimpleNotepadForm метод MenuFilePrintPreview, предназначенный для вывода на экран окна предварительного просмотра документа, показанного на рис. 4-20:

/// < summary>
/// Предварительный просмотр перед печатью документа
/// < /summary>
private void MenuFilePrintPreview()
{
m_PrintPageNumber = 1;

string strText = this.richTextBox1.Text;
m_myReader = new StringReader(strText);
Margins margins = new Margins(100, 50, 50, 50);

printDocument1.DefaultPageSettings.Margins = margins;
printPreviewDialog1.ShowDialog();

m_myReader.Close();
}

Кроме того, добавьте вызов метода MenuFilePrintPreview в тело обработчика события строки Print Preview меню File:

private void menuFilePrintPreview_Click(object sender,
System.EventArgs e)
{
MenuFilePrintPreview();
}

Как работает метод MenuFilePrintPreview?

Прежде всего, этот метод записывает в поле m_PrintPageNumber значение 1, т.к. просмотр начнется с первой страницы документа:

m_PrintPageNumber = 1;

Далее метод читает текущее содержимое окна редактирования в поток m_myReader класса StringReader:

string strText = this.richTextBox1.Text;
m_myReader = new StringReader(strText);

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

Margins margins = new Margins(100, 50, 50, 50);
printDocument1.DefaultPageSettings.Margins = margins;
printPreviewDialog1.ShowDialog();

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

Отобразив панель предварительного просмотра, метод MenuFilePrintPreview закрывает поток m_myReader:

m_myReader.Close();

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

Отображение окна печати документа

Для отображения стандартного диалогового окна печати документов (рис. 4-19) добавьте в класс SimpleNotepadForm метод MenuFilePrint:

/// < summary>
/// Печать документа
/// < /summary>
private void MenuFilePrint()
{
m_PrintPageNumber = 1;

string strText = this.richTextBox1.Text;
m_myReader = new StringReader(strText);

Margins margins = new Margins(100, 50, 50, 50);
printDocument1.DefaultPageSettings.Margins = margins;

if (printDialog1.ShowDialog() == DialogResult.OK)
{
this.printDocument1.Print();
}
m_myReader.Close();
}

Вызов этого метода должен осуществляться в обработчике событий строки Print меню File:

private void menuFilePrint_Click(object sender, System.EventArgs e)
{
MenuFilePrint();
}

Расскажем о том, как работает метод MenuFilePrint.

Печать нашего документа будет начинаться с первой страницы, поэтому в поле m_PrintPageNumber мы записываем значение 1:

m_PrintPageNumber = 1;

Далее мы читаем текущее содержимое окна редактирования текста в поток m_myReader класса StringReader:

string strText = this.richTextBox1.Text;
m_myReader = new StringReader(strText);

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

Далее мы задаем границы отступов на распечатываемой странице и отображаем диалоговое окно печати документа. Если пользователь щелкает в этом окне кнопку OK, документ printDocument1 отправляется на печать методом Print:

Margins margins = new Margins(100, 50, 50, 50);
printDocument1.DefaultPageSettings.Margins = margins;

if (printDialog1.ShowDialog() == DialogResult.OK)
{
this.printDocument1.Print();
}

Далее ненужный более поток m_myReader закрывается методом Close:

m_myReader.Close();

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

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

Чтобы в нашем приложении заработали функции предварительного просмотра документа перед печатью и функция печати, необходимо создать обработчик события PrintPageEventHandler. Для этого нужно дважды щелкнуть левой клавишей мыши значок компонента printDocument1 (рис. 4-18). После этого дизайнер форм создаст пустое тело этого обработчика событий.

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

/// < summary>
/// Обработка события PrintPage
/// < /summary>
private void PrintPageEventHandler(object sender,
System.Drawing.Printing.PrintPageEventArgs e)
{
int lineCount = 0; // счетчик строк
float linesPerPage = 0; // количество строк на одной странице
float yLinePosition = 0; // текущая позиция при печати по
// вертикальной оси
string currentLine = null; // текст текущей строки

// Шрифт для печати текста
Font printFont = this.richTextBox1.Font;

// Кисть для печати текста
SolidBrush printBrush = new SolidBrush(Color.Black);

// Размер отступа слева
float leftMargin = e.MarginBounds.Left;

// Размер отступа сверху
float topMargin = e.MarginBounds.Top +
3*printFont.GetHeight(e.Graphics);

// Вычисляем количество строк на одной странице с учетом отступа
linesPerPage = (e.MarginBounds.Height -
6*printFont.GetHeight(e.Graphics)) /
printFont.GetHeight(e.Graphics);

// Цикл печати всех строк страницы
while(lineCount < linesPerPage & &
((currentLine=m_myReader.ReadLine())! = null))
{
// Вычисляем позицию очередной распечатываемой строки
yLinePosition = topMargin + (lineCount *
printFont.GetHeight(e.Graphics));

// Печатаем очередную строку
e.Graphics.DrawString(currentLine, printFont, printBrush,
leftMargin, yLinePosition, new StringFormat());

// Переходим к следующей строке
lineCount++;
}

// Печать колонтитулов страницы

// Номер текущей страницы
string sPageNumber = " Page " + m_PrintPageNumber.ToString();

// Вычисляем размеры прямоугольной области, занимаемой верхним
// колонтитулом страницы
SizeF stringSize = new SizeF();
stringSize = e.Graphics.MeasureString(sPageNumber, printFont,
e.MarginBounds.Right - e.MarginBounds.Left);

// Печатаем номер страницы
e.Graphics.DrawString(sPageNumber, printFont, printBrush,
e.MarginBounds.Right - stringSize.Width, e.MarginBounds.Top,
new StringFormat());

// Печатаем имя файла документа
e.Graphics.DrawString(this.Text, printFont, printBrush,
e.MarginBounds.Left, e.MarginBounds.Top, new StringFormat());

// Кисть для рисования горизонтальной линии,
// отделяющей верхний колонтитул
Pen colontitulPen = new Pen(Color.Black);
colontitulPen.Width = 2;

// Рисуем верхнюю линию
e.Graphics.DrawLine(colontitulPen,
leftMargin,
e.MarginBounds.Top + printFont.GetHeight(e.Graphics) + 3,
e.MarginBounds.Right, e.MarginBounds.Top +
printFont.GetHeight(e.Graphics) + 3);

// Рисуем линию, отделяющую нижний колонтитул документа
e.Graphics.DrawLine(colontitulPen,
leftMargin, e.MarginBounds.Bottom - 3,
e.MarginBounds.Right, e.MarginBounds.Bottom - 3);

// Печатаем текст нижнего колонтитула
e.Graphics.DrawString(
" SimpleNotepad, (c) Александр Фролов, https://www.frolov.pp.ru",
printFont, printBrush,
e.MarginBounds.Left, e.MarginBounds.Bottom, new StringFormat());

// Если напечатаны не все строки документа,
// переходим к следующей странице
if(currentLine! = null)
{
e.HasMorePages = true;
m_PrintPageNumber++;
}

// Иначе завершаем печать страницы
else
e.HasMorePages = false;

// Освобождаем ненужные более ресурсы
printBrush.Dispose();
colontitulPen.Dispose();
}

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

Рис. 4-22. Внешний вид распечатанной страницы документа

Комментарии в тексте обработчика событий PrintPageEventHandler поясняют назначение отдельных программных строк. Заметим, что для полного понимания действий, выполняемых нашим обработчиком событий, требуется предварительное знакомство с графической подсистемой Graphics Device Interface Plus (GDI+), реализованной компанией Microsoft в рамках библиотеки классов.NET Framework. Мы посвятим этой теме 10 главу нашей книги.

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

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

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

Закрытие главного окна редактора текста

Окно нашего редактора текста должно быть закрыто, когда пользователь выбирает из меню File строку Exit. Это легко достигается добавлением метода Close в тело обработчика сообщения menuFileExit_Click:

private void menuFileExit_Click(object sender, System.EventArgs e)
{
this.Close(); // изменения в документе будут потеряны!
}

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

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

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

private bool m_DocumentChanged = false;

В новом или только что загруженном документе изменений нет, поэтому начальное значение этого флага равно false.

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

Вам остается только обеспечить изменение состояния флага m_DocumentChanged внутри этого обработчика:

private void richTextBox1_TextChanged(object sender,
System.EventArgs e)
{
m_DocumentChanged = true;
}

Если пользователь редактировал документ, а потом решил создать новый, выбрав из меню File строку New, изменения, внесенные в старый документ, могут быть потеряны. Чтобы избежать этого, проверьте флаг m_DocumentChanged перед тем как очищать содержимое редактора текста. Если в редакторе есть не сохраненные изменения, необходимо вызвать метод MenuFileSaveAs, предназначенный для сохранения документа:

private void menuFileNew_Click(object sender, System.EventArgs e)
{
if(m_DocumentChanged)
MenuFileSaveAs();
richTextBox1.Clear();
}

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

private void MenuFileSaveAs()
{
if(saveFileDialog1.ShowDialog() ==
System.Windows.Forms.DialogResult.OK & &
saveFileDialog1.FileName.Length > 0)
{
richTextBox1.SaveFile(saveFileDialog1.FileName);
m_DocumentChanged = false;
}
}

Теперь подготовьте обработчик события menuFileExit_Click следующим образом:

private void menuFileExit_Click(object sender, System.EventArgs e)
{
if(m_DocumentChanged)
MenuFileSaveAs();
this.Close();
}

И, наконец, надо выполнить еще одну проверку флага m_DocumentChanged — в методе Dispose, который вызывается при закрытии окна приложения:

/// < summary>
/// Clean up any resources being used.
/// < /summary>
protected override void Dispose(bool disposing)
{
if(m_DocumentChanged)
MenuFileSaveAs();

if(disposing)
{
if (components! = null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}

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

Реализация функций меню Edit

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

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

Добавьте в меню Edit нашего редактора текста строку Redo. Затем подготовьте обработчики событий от всех строк меню Edit следующим образом:

private void menuEditUndo_Click(object sender, System.EventArgs e)
{
richTextBox1.Undo();
}

private void menuItem1_Click(object sender, System.EventArgs e)
{
richTextBox1.Redo();
}

private void menuEditCut_Click(object sender, System.EventArgs e)
{
richTextBox1.Cut();
}

private void menuEditCopy_Click(object sender, System.EventArgs e)
{
richTextBox1.Copy();
}

private void menuEditPaste_Click(object sender, System.EventArgs e)
{
richTextBox1.Paste();
}

private void menuEditDelete_Click(object sender, System.EventArgs e)
{
richTextBox1.Cut();
}

private void menuEditSelectAll_Click(object sender,
System.EventArgs e)
{
richTextBox1.SelectAll();
}

Теперь наше приложение Simple Notepad сможет обмениваться текстовыми и графическими данными с другими приложениями Microsoft Windows через универсальный буфер обмена Clipboard.

Рис. 4-23. Мы вставили в документ текст и графическое изображение

Реализация функций меню Format

Прежде чем продолжить работу над нашим приложением, модифицируйте меню Format, добавив в него строку Color, а также два меню второго уровня — Character Style (рис. 4-24) и Paragraph Alignment (рис. 4-25).

Рис. 4-24. Меню второго уровня Characters Style