Читать онлайн «Программирование мобильных устройств на платформе .NET Compact Framework». Страница 103

 System.Drawing.Brush myBrush;

 myBrush = new System.Drawing.SolidBrush(System.Drawing.Color.DarkGreen);

 //Заполнить прямоугольник

 myGfx.FillRectangle(myBrush, 4, 2, 60, 20);

 //-------------------------

 //Важно: Выполнить очистку!

 //-------------------------

 myBrush.Dispose();

 myGfx.Dispose();

}

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

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

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

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

■ Поместите на форму кнопку, которая выполняет вызов this.Update(). Заметьте, что, как правило, это не приводит к немедленному вызову функции OnPaint. Вызов Update() лишь требует, чтобы форма или элемент управления перерисовывались, если имеются области, ставшие недействительными. 

■ Поместите не форму кнопку, которая выполняет вызов this.Invalidate(). В результате этого вызова запросы OnPaint перемещаются в начало очереди и обрабатываются сразу же. как только у операционной системы появляется такая возможность, что обычно наступает очень быстро. Выполнение один за другим вызовов this.Invalidate(); this.Update(); приводит к немедленной перерисовке формы. 

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

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

//Кисти, которые мы хотим кэшировать, чтобы избавить себя

//от необходимости все время создавать их и уничтожать

System.Drawing.Brush m_brushBlue;

System.Drawing.Brush m_brushYellow;

//Ради интереса подсчитаем, сколько раз осуществлялся вызов

int m_paintCount;

//-----------------------------------------------------------------------------

//Мы перекрываем обработчики событий Paint наших базовых классов. Это означает,

//что каждый раз, когда форма вызывается для перерисовки самой себя, будет

//вызываться эта функция.

//-----------------------------------------------------------------------------

protected override void OnPaint(PaintEventArgs e) {

 //ВАЖНО: Вызвать базовый класс и дать ему возможность

 //выполнить всю необходимую работу по рисованию

 base.OnPaint(e);

 //Увеличить на 1 значение счетчика вызовов

 m_paintCount = m_paintCount + 1;

 //------------------------------------------------------------------------

 //Важно:

 //Вместо того чтобы создавать объект Graphics, мы получаем его на время

 //данного вызова. Это означает, что освобождать память путем вызова

 //метода .Dispose() объекта - не наша забота

 //------------------------------------------------------------------------

 System.Drawing.Graphics myGfx;

 myGfx = e.Graphics;

 //-------------------------------------------------------------------

 //Поскольку эту операцию рисования необходимо выполнить быстро,

 //кэшируем кисти, чтобы избавить себя от необходимости создавать их и

 //уничтожать при каждом вызове

 //-------------------------------------------------------------------

 if (m_brushBlue == null) {

  m_brushBlue = new System.Drawing.SolidBrush(System.Drawing.Color.Blue);

 }

 if (m_brushYellow == null) {

  m_brushYellow = new System.Drawing.SolidBrush(System.Drawing.Color.Yellow);

 }

 //-------------------

 //Выполнить рисование

 //-------------------

 myGfx.FillRectangle(m_brushBlue, 2, 2, 100, 100);

 myGfx.DrawString("PaintCount: " + m_paintCount.ToString(), this.Font, mbrushYellow, 3, 3);

 //Выход: Объекты, для которых мы должны были бы вызывать метод

 //.Dispose(), отсутствуют.

}

Существует еще один способ подключения к запросам Paint. В приведенном выше примере для этого использовался подход, основанный на механизме наследования. Однако обработку событий Paint можно осуществлять и при помощи обработчика событий. Это выполняется точно так же, как и подключение к обработчику событий Click; для получения запросов событий необходимо зарегистрировать функцию. Если вместо перекрытия метода OnPaint() использовать обработчик событий, то в приведенный выше код необходимо внести три вида изменений:

1. Следует изменить имя и сигнатуру метода таким образом, чтобы они соответствовали тому, что требуется для обработчика событий Paint (например, protected void PaintEventHandler(object sender, PaintEventArgs e) вместо protected override void OnPaint(PaintEventArgs e)).

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

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

this.Paint += new System.Windows.Forms.PaintEventHandler(this.PaintEventHandler);

InitializeComponent();

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

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