Библиотека .NET Framework и библиотеки языка Java
Библиотека .NET Framework и библиотеки языка Java
Приложение
Приложение (an application) – программа для выполнения под управлением операционной системы определенного вида работ, например: редактирования текста, выдачи текущего времени и так далее. Каждое приложение является процессом и представлено на экране своим прикладным окном.
Прикладное или главное окно (an application или main window) – прямоугольная область на экране, выделяемая одному приложению для ввода и вывода данных и управления приложением. Операционная система Windows допускает параллельное одновременное выполнение нескольких приложений с возможной синхронизацией их работы, при этом каждое из них может быть представлено своим прикладным окном.
В свою очередь каждое прикладное окно может содержать так называемые дочерние окна (child windows). Имеется набор стандартных дочерних окон - интерфейсных элементов (elements of interface или controls), которые активно используются для связи пользователя с приложением. В качестве примера интерфейсных элементов можно привести кнопки (buttons), списки (list boxes), ползунки (sliders), редакторы (editors или text fields,или text boxes). Интерфейсные элементы размещаются в области клиента (client area или work area) окна. В область клиента приложение выдаёт различную текстовую и графическую информацию.
Классы, объекты и элементы приложения
Создание приложений (для Windows) требует знания объектно-ориентированного программирования. Разрабатывая приложения на С++, желательно использовать библиотеки классов .NET Framework, MFC, OWL, ATL или другие, которые существенно облегчают реализацию программ.
При разработке программ на языке C# применяется библиотека .NET Framework, а на языке Java – пакеты java.lang, java.awt, java.util, java.swing и другие. Все классы библиотеки .NET Framework и пакетов Java порождаются из класса Object.
C языком Visual J# можно использовать как пакеты языка Java так и библиотеку .NET Framework. В данной книге в программах на языке Visual J# будет применяться только пакеты языка Java. Наличие в среде разработки Visual Studio .NET как библиотеки .NET Framework, так и пакетов языка Java упрощает изучение как языка Java, аналогичному языку Visual J#, так и языка C# в одной среде разработки с родными для них библиотеками и пакетами.
При объектно-ориентированном программировании приложений следует различать такие понятия, как объект и элемент.
Объект – понятие языков С++, C# и Java. Вне модуля приложения объект размещается в памяти, будучи созданным из класса с помощью оператора new или gcnew. Из одного класса можно создать несколько объектов, которые, как правило, отличаться своим состоянием.
Элемент – это то, что представляет объект на экране, обеспечивая интерактивную связь пользователя с приложением. Обычно элемент представляется в виде специализированных дочерних окон – кнопок, панелей редактирования, ползунков и других. При применении библиотеки .NET Framework окна являются объектами класса Form и называются формами, а при применении пакетов java.awt языка Java окна являются объектами класса Frame и называются фреймами. Управляющие элементы – объекты, создаваемые из классов Control и UserControl.
Простейшие приложения
Создадим простейшее Windows-приложение, которое выдаёт на экран прикладное окно с именем “Hello”.
Рис.9.3.1. Прикладное окно приложения Hello примера 9.3.1
Пример 9.3.1. C#. Простое Windows-приложение. Два варианта.
///////////////
// C# Вариант 1
class MainClass
{
static void Main ( )
{
System.Windows.Forms.Form form=
new System.Windows.Forms.Form ( );
form.Size= new System.Drawing.Size (300, 100);
form.Text= "Hello";
System.Windows.Forms.Application.Run (form);
}
}
///////////////
// C# Вариант 2
using System.Windows.Forms;
using System.Drawing;
class MainClass
{
static void Main ( )
{
Form form= new Form ( );
form.Size= new Size (300, 100);
form.Text= "Hello";
Application.Run (form);
}
}
C#. Windows-приложение начинает выполнять главная функция Main(). Функция Main() примера 9.3.1 создаёт объект form прикладного окна из класса Form пространства имён System.Windows.Forms библиотеки .NET Framework. Затем она устанавливает свойство Size объекта form окна, присвоив этому свойству ссылку на объект класса Size пространства имён System.Drawing, содержащий ширину и высоту окна. Потом определяется свойство Text, указывающее заголовок объекта form окна. Сформировав прикладное окно, функция Main() запускает приложение, вызвав статическую функцию Run() класса Application пространства имён System.Windows.Forms и передав ей ссылку form на объект окна в качестве её аргумента. Аргументом функции Run() является ссылка на главное (прикладное) окно приложения. Получив ссылку на прикладное окно, функция Run() высвечивает его на экране. В дальнейшем будут рассмотрены и другие окна, но они отображаются на экране с помощью функции Show().
Для сокращения текста программы во втором варианте программы употреблён оператор using, указывающий на возможность применения в программе классов пространства имён System.Windows.Forms и пространства имён System.Drawing без указания их перед каждым классом, как это имело место в первом варианте программы.
Пример 9.3.2. Java. Простое оконное приложение.
///////////////
// Javaи J#
import java.awt.*;
class MainClass
{
public static void main ( )
{
Frame frame= new Frame ( );
frame.setSize (300, 100);
frame.setTitle ("Hello");
frame.show ( );
}
}
Java. В отличие от C# программы примера 9.3.1 функция main() Java программы примера 9.3.2 создаёт объект frame прикладного окна из класса Frame пакета java.awt. Затем функция main(), используя функцию-свойство setSize(), устанавливает ширину и высоту размер окна. Потом функция-свойство setTitle() определяет заголовок прикладного окна. Как видим, в случае языка Java не требуется явно вызывать функцию Run(), она вызывается неявно. Чтобы показать прикладное окно на экране, надлежит обязательно вызвать функцию show().
C# и Java. Примеры 9.3.1 и 9.3.2 показывают сходство и отличие C# и Java программ при написании простых приложений. Разные библиотеки содержат разноимённые классы и разноимённые свойства для создания сходных объектов и при использовании сходных свойств. В C# программе для подключения требуемых стандартных классов применяется оператор using, а в Java программе – оператор import. Функция Main() в C# программе пишется с большой буквы, а в Java программе – c маленькой. В C# программе используются непосредственно свойства Size и Text, а в Java программе – функции setSize() и setTitle() свойств. В C# программе явно применяется функция Run() и показывает прикладное окно, а в Java программе эта функция вызывается неявно и не показывает окно, так что приходится вызвать функцию show(). Надо заметить, что на языке C# принято писать имена функций с большой буквы, а на языке Java с маленькой.
Пример 9.3.3 иллюстрирует оконное приложение на языке C++/CLI.
Пример 9.3.3. C++/CLI. Простое Windows-приложение.
///////////////
// C++/CLI
#include "stdafx.h"
#using<System.dll>
#using<System.Windows.Forms.dll>
#using<System.Drawing.dll>
using namespace System;
using namespace System::Windows::Forms;
using namespace System::Drawing;
ref class MainClass : public Form
{
public:
MainClass (void)
{
this->Size = *gcnew Drawing::Size (300,300);
// или this->Size = Drawing::Size (300,300);
this->Text = "Hello";
}
};
void main ( )
{
Application::Run (gcnew MainClass ());
}
C++/CLI. Программа на языке C++/CLI требует не только указания об использовании требуемых пространств имен библиотек классов с помощью using, но и подключения этих библиотек с помощью операторов #using. Управляемый класс MainClass помечается словом ref. Используются двоеточия и стрелки. Функция main() пишется с маленькой буквы.
Как просто получается приложение с классом Form библиотеки .NET Framework, как просто создаётся порождением из этого базового класса наш класс MainClass прикладного окна в примере 9.3.3. Но сам класс Form сложен. Он содержит множество свойств, событий и интерфейсных функций, с некоторыми из которых мы познакомимся позднее. Взгляните на рис. 9.3.1.1. Оказывается, класс Form сам наследует множество других классов, каждый из которых обогащает его функциональность. Как любой другой класс библиотеки .NET Framework, класс Form наследует корневой базовый класс Object, позволяющий всем объектам в системе сравниваться друг с другом, воспользовавшись функцией Equals() этого класса, или получать описание любого объекта с помощью функции ToString(). Обратим особое внимание на класс Control, включающий богатый набор свойств, событий и функций, которые наследуются не только классом окна, но многими другими классами, объекты которых, как и объекты окна, должны обладать общим поведением управляющих элементов (controls). Потом мы рассмотрим такие управляющие элементы, как кнопки и редакторы, классы которых наследуют также класс Control. Мы скоро убедимся, что объекты окон, кнопок и редакторы содержат не только одноимённые свойства Size, Text, применённые в примерах 9.3.1 и 9.3.3, но и многие другие свойства, например, Location, Name, Visible и др.
Рис. 9.3.1.1. Наследование классов классом Form
Пакеты, содержащие классы языка Java, отличается от библиотеки .NET Framework языков C# и C++/CLI. Отличаются и наследования классов, в чём убеждает рис. 9.3.1.2. В языке Java классу Control библиотеки .NET Framework соответствует класс Component. Этот класс Component включает свойства setSize(), getSize(), setLocation(), getLocation(), setVizible(), setName, getName() и др., используемых при создании интерфейсных элементов. Но в отличие от класса Component языка Java, класс Component библиотеки .NET Framework используется иначе – он применяется при разработке так называемых объектов компонентов, из которых создаются многокомпонентные программы в соответствиями с рекомендациями компонентно-ориентированного программирования. Посему необходимо отличать эти одноимённые, но функционально разные классы.
Рис. 9.3.1.2. Наследование классов классом Frame
Обсуждение.
C#.
Читатель.
Хорошо бы оживить простое приложение?
Автор.
Воспользуемся потоком, который будет изменять одно из свойств объекта окна – его заголовок. Имя заголовка окна определяется свойством Text.
// Пример 9.3.4. Обсуждение. Простое C#приложение
using System;
using System.Threading;
using System.Windows.Forms;
class Window: Form // Класс прикладного окна
{
Thread t; // Ссылка на поток
bool life; // Признак жизни потока
bool key; // Переключатель
public Window ( ) // Конструктор
{
key= true;
// Создать и запустить поток
life= true;
t= new Thread (new ThreadStart (Change));
t.Start ( );
}
// Выполнить поток
private void Change ( )
{
while(life)
{
if(key) this.Text= "university";
else this.Text="student";
key= !key;
Thread.Sleep (1000);
}
}
// Закрыть прикладное окно
protected override void OnClosed (EventArgs e)
{
life= false;
}
static void Main ( )
{
// Создать окно и запустить приложение
Application.Run (new Window());
}
}
Java.
Читатель.
Интересно, а как же это приложение выглядело бы на языке Java?
Автор.
На языке Java применяется другая библиотека классов, в которой имена классов, функций и свойств иные. Имя заголовка окна задается свойством setTitle(). Но в Java программе в отличие от C# программы, в которой размер окна и его видимость уже установлены по умолчанию, необходимо явно с помощью свойств setSize() и setVisible() установить их, иначе прикладное окно не появится на экране. И еще надо осуществить закрытие прикладного окна, которое здесь реализуется, но о котором сейчас не хотелось бы говорить, поскольку об этом будет подробно рассказано дальше.
// Пример 9.3.5. Обсуждение. Простое Java приложение
import java.awt.*;
import java.awt.event.*;
class Window extends Frame implements Runnable // Класс прикладного окна
{
Thread t; // Ссылка на поток
boolean life; // Признак жизни потока
boolean key; // Переключатель
public Window ( ) // Конструктор
{
this.setSize (300, 100);
this.setVisible (true);
// Закрыть прикладное окно
this.addWindowListener (new WindowAdapter ( )
{
public void windowClosing (WindowEvent wE)
{
life= false;
System.exit (0);
}
});
key= true;
// Создать и запустить поток
life= true;
t= new Thread (this);
t.start ( );
}
// Выполнить поток
public void run ( )
{
while(life)
{
if(key) this.setTitle ("university");
else this.setTitle ("student");
key= !key;
try
{
Thread.sleep(1000);
}
catch (InterruptedException ex) { }
}
}
public static void main ( )
{
// Создать окно и запустить приложение
new Window ( );
}
}
Пример 9.4.1. Программа обработки события мыши на C#.
Приложение создаёт прикладное окно и ожидает нажатия клавиши мыши в этом окне (точнее, в области клиента окна). При нажатии на клавишу в консольное окно выдаётся строка с координатами носика курсора мыши.
Рис. 9.4.1. При нажатии на клавишу мыши появилась очередная строка на консоли
Ниже приводятся три варианта реализации этого приложения на языке C#.
///////////////
// C# Вариант 1
using System;
using System.Drawing;
using System.Windows.Forms;
class MainClass : Form // Класс прикладного окна
{
// Использовать предопределённый обработчик OnMouseDown мыши
Пример 9.4.3. Программа обработки события мыши на Java.
///////////////
// Java Вариант 1(Другие варианты в примере 10.5.2)
import java.awt.*;
import java.awt.event.*;
class MainClass extends Frame // Класс прикладного окна
{
// Выполнить предопределённый обработчик mouseDown мыши
Пример 9.4.4. Связь события с несколькими объектами.
///////////////
// C#
using System;
using System.Windows.Forms;
class CObj1 // Класс со статической функцией обработки события MouseDown
{
static public void MouseDownObj1 (object sender, MouseEventArgs e)
{
MessageBox.Show ("CObj1:x=" + (e.X).ToString( ) +
" y=" + (e.Y).ToString( ));
}
}
class CObj2 // Класс с обычной функцией обработки события MouseDown
{
public void MouseDownObj2 (object sender, MouseEventArgs e)
{
MessageBox.Show ("CObj2:x=" + (e.X).ToString( ) +
" y=" + (e.Y).ToString( ));
}
}
class MainClass : Form // Класс прикладного окна
{
public MainClass ( ) // Конструктор
{
// Инициализация события MouseDown
this.MouseDown += new MouseEventHandler (CObj1.MouseDownObj1);
CObj2 obj2= new CObj2( );
this.MouseDown += new MouseEventHandler (obj2.MouseDownObj2);
this.MouseDown += new MouseEventHandler (OurMouseDown);
}
// Обработать событие MouseDown
private void OurMouseDown (object sender, MouseEventArgs e)
{
// Выдать блок сообщений типа MessageBox
MessageBox.Show ("CMainClass:x=" + (e.X).ToString ( ) + " y="
+ (e.Y).ToString ( ));
}
static void Main ( ) // Главная функция
{
Application.Run (new MainClass ( )); // Выполнить приложение
}
}
C#. Программа примера 9.4.4 иллюстрирует применение и подписку обработчиков на событие мыши статического обработчика и обычных обработчиков, принадлежащих объектам различных классов. Статический обработчик MouseDownObj1() описан в классе CObj1. Обычный обработчик OurMouseDown() описан в классе прикладного окна, а обычный обработчик MouseDownObj2() – в классе CObj2. Следует обратить внимание на отличие в подписке на событие обычных и статических обработчиков. При подписке обычного обработчика в аргументе конструктора делегата указывается обработчик через ссылку на объект, а при подписке статического обработчика в аргументе конструктора делегата указывается обработчик через ссылку на класс.
Рис. 9.4.4. При нажатии на клавишу мыши появился блок сообщений очередного обработчика
Пример 9.5.2. Обработка событий мыши на Java, используя интерфейс MouseListener.
///////////////
// Javaи J# Вариант 2(Вариант 1 смотрите в примере 10.4.3)
import java.awt.*;
import java.awt.event.*;
// Класс прикладного окна
public class MainClass extends Frame implements MouseListener
{
// Предопределённые обработчики интерфейса MouseListener
public void mouseClicked (MouseEvent mE){}
public void mouseEntered (MouseEvent mE){}
public void mouseExited (MouseEvent mE){}
public void mouseReleased (MouseEvent mE){}
// Выполнить предопределённый обработчик mousePressed мыши
Пример 9.5.3.1. Обработка событий мыши на Java, используя классы адаптеров.
///////////////
// Javaи J# Вариант 5
import java.awt.*;
import java.awt.event.*;
class Listener extends MouseAdapter
{
// Выполнить предопределённый обработчик mousePressed мыши
Пример 9.5.4.1. Обработка событий мыши на Java, используя внутренние классы адаптеров.
///////////////
// Javaи J# Вариант 7
import java.awt.*;
import java.awt.event.*;
// Класс прикладного окна
public class MainClass extends Frame
{
public MainClass ( )
{
this.setSize (new Dimension (400, 200));
this.setTitle ("Hello");
this.addMouseListener(new Listener ( ));
}
// Внутренний класс Listener приемника событий мыши
Пример 9.5.4.2. Обработка событий мыши на Java, используя внутренний анонимный класс.
///////////////
// Javaи J# Вариант 8
import java.awt.*;
import java.awt.event.*;
// Класс прикладного окна
class MainClass extends Frame
{
public MainClass ( )
{
this.setSize (400, 200);
this.setTitle ("Hello");
// Примененить внутренний анонимный класс
this.addMouseListener (new MouseAdapter ( )
{
public void mousePressed (MouseEvent mE)
{
System.out.println ("Mouse: x= " + mE.getX ( )
+ " y= " + mE.getY( ));
}
});
}
public static void main ( ) // Главная функция
{
MainClass mC= new MainClass ( );
mC.show ( );
}
}
/*
Result:
При каждом нажатии на клавишу мыши в прикладном окне выдаётся на консоль строка вида
Mouse: x= 10 y= 55, где x, y - координаты носика мыши
*/
Пример 9.5.5.1. Обработка события закрытия окна.
///////////////
// Javaи J# Вариант 9
import java.awt.*;
import java.awt.event.*;
// Класс прикладного окна
class MainClass extends Frame
{
public MainClass ( )
{
this.setSize (400, 200);
this.setTitle ("Hello");
// Примененить внутренний анонимный класс
this.addMouseListener (new MouseAdapter ( )
{
public void mousePressed (MouseEvent mE)
{
System.out.println ("Mouse: x= " + mE.getX ( )
+ " y= " + mE.getY ( ));
}
});
this.addWindowListener (new OurWindowAdapter ());
}
public static void main ( ) // Главная функция
{
MainClass mC= new MainClass ( );
mC.show ( );
}
}
// Класс адаптера окна
Графика
Рассмотрим классы .NET Framework, обеспечивающие рисование и вывод рисунков в область клиента окон (форм) и соответствующие им классы библиотеки языка Java. Множество этих классов представляют графический интерфейс устройства GDI++ (Graphic Device Interface).
Графические объекты
Графический интерфейс использует для рисования такие объекты как цвет (color), перья (pens), кисти (brushes), изображения (images) и шрифты (fonts).
Прежде чем рисовать фигуру или линию, надо создать графический объект класса Graphics. Графический объект связан с конкретным окном (формой, фреймом) и его функции выполняют рисование в этом окне, включая при необходимости в качестве аргументов перья, кисти, шрифты и т.д. Таким образом, вспомогательные объекты типа Color, Pen, SolidBrush, Image и Font обеспечивают функционирование объектов класса Graphics, занимающих центральное место в создании графического интерфейса. Объекты вспомогательных типов хранят необходимую для рисования информацию, а графический объект её использует.
При рисовании необходимо связать графический объект с контекстом устройства, на которое отображается информация. Обычно им является дисплей или принтер. Может выводиться не только текстовая информация, но и геометрические фигуры, залитые цветом, и изображения. Объект типа Graphics, например, на языках C# и C++/CLI связывается с устройством с помощью функции CreateGraphics(), а в языке Java(J#) – getGraphics().
.
Точка
C# и C++/CLI. Наиболее часто употребляемый тип – это тип Point, используемый для создания объекта – одиночной точки, обычно в области клиента окна.
Тип Point содержит открытые свойства – X и Y , определяющие координаты точки, конструктор, функцию Offset(dx, dy) смещения точки с приращениями dx и dy, операторы, позволяющие сравнивать объекты-точки и присваивать им значения.
Тип Point имеет конструктор следующего формата:
Point (int X, int Y);
Нижеследующие примеры понятны без пояснений:
C++/CLI.
Point *pP1= new Point (1, 2); // Создать в неуправляемой куче
// точку с pP1->X= 1 и pP1->Y= 2
pP1 -> Offset (1, 1); // Сдвинуть точку pP1
// pP1->X= 2 и pP1->Y= 3
Point p2 (3, 4); // Создать точку p2 в стеке
// с p2.X= 3 и p2.Y= 4
p2.Offset (5, 5); // Сдвинуть точку p2
// p2.X= 8 и p2.Y= 9
if (p2 != *pP1) p2= *pP1; // Неравные точки стали одинаковыми
Point ^pP3= gcnew Point (10, 20); // Создать точку в управляемой куче
// с pP3->X= 10 и pP3->Y= 20
if (p2 != *pP3) p2= *pP3; // Неравные точки стали одинаковыми
C#.
Point p1= new Point (1, 2); // Создать точку p1 с p1.X= 1 и p1.Y= 2
p1.Offset (1, 10); // p1.X= 2 и p1.Y= 12
Point p2= new Point ( ); // Создать точку p2 с p2.X= 0 и p2.Y= 0
p2.X= 30; p2.Y=50;
Java. Точки являются объектами класса Point. Конструктор класса Point имеет формат:
Point (int X, int Y);
Класс Point включает свойства x и y.
Point p= new Point (10, 20 ); // Создать точку p2 с p2.X= 10 и p2.Y= 20
p.x= 30; p.y=50;
Прямоугольник
C# и C++/CLI. Также часто употребляется тип Rectangle, используемый для создания объекта-прямоугольника с горизонтальными и вертикальными сторонами. Этот прямоугольник можно применять для рисования его пером (pen) или как область, подлежащую заливке некоторым цветом с помощью кисти (brush), или для указания области, занимаемой окном, и так далее.
Тип Rectangle содержит одиннадцать свойств и много функций. Свойство Location, включающее координаты левого верхнего угла (X и Y или Left и Top), определяет положение прямоугольника в окне или на экране, свойства Width и Height задают ширину и высоту прямоугольника, а свойства Right и Bottom - координаты правой нижней точки прямоугольника
Из множества функций нам понадобятся следующие: конструктор Rectangle , функция Offset() смещения, и функция Contains() выявления вхождения точки в прямоугольник. Они понятны из нижеследующих примеров:
C++/CLI.
Rectangle r1; // Создать прямоугольник в стеке
r1.X= 1; r1.Y=2; r1.Width= 10; r1.Height= 20;
Rectangle *r2= new Rectangle (21, 22, 210, 220); // Создать прямоугольник
// в неуправляемой куче
r2->Offset (100, 100);
Point ^p= gcnew Point (3, 4); // Создать точку p2 с p2.X= 3 и p2.Y= 4
if (r1.Contains (*p)) r1=*r2; // Если р2 в r1, то прямоугольник г1
// становится равным прямоугольнику г2
// r1.X= 121 r1.Y= 122 r1.Width= 210 r1.Height= 220;
C#.
Rectangle r1= new Rectangle (1, 2, 4, 5); // r1.X= 1, r1.Y= 2,
// r1.Left= 1, r1.Top= 2, r1.Right= 5, r1.Bottom= 7, r1. Width = 4, r1. Height = 5
r1.Offset (2, 1); // Теперь r1.X= 3, r1.Y= 3,
// r1.Left= 3, r1.Top= 3, r1.Right= 6, r1.Bottom= 8, r1. Width = 4, r1. Height = 5
Point p2= new Point (3, 4); // Создать точку p2 с p2.X= 3 и p2.Y= 4 [JScript] public function Point(int, int);
if (r1.Contains (p2)) { что-либо делаем}; // Если р2 в r1, то что-либо делаем
Java. Прямоугольники представляются объектами класса Rectangle. Конструктор класса Rectangle имеет различные форматы:
Rectangle ();
Rectangle (int x, int y, int w, int h );
Rectangle (Point p, Dimension d );
где х, у – координаты верхнего левого угла прямоугольника;
w, h – ширина и высота прямоугольника;
d – ссылка на объект класса Dimension, задающий размеры прямоугольника.
Среди свойств класса Rectangle выделим свойства x и y, определяющие координаты левого верхнего угла прямоугольника, свойства width и height, определяющие ширину и высоту прямоугольника.
Цвет
C# и C++/CLI.Типом Color представляется цвет. Среди конструкторов структуры Color имеется конструктор
Color (int tr, int r, int g, int b);
который создаёт объект с указанной прозрачностью tr (transparency of a color) и основными составляющими цвета: красный r (red), зелёный g (green) и синий b (blue). Значения прозрачности и составляющих цвета лежат в границах от 0 до 255. Большее их значение означает более плотный цвет и меньшую прозрачность.
Структура Color имеет огромный набор предопределённых цветов, представленных свойствами, например: Brown, Chocolate, Gold, Gray и т.д. Имеется статическая функция FromArgb(), позволяющая получить цвет по значениям трёх составляющих цвета и его интенсивности:
static Color FromArgb (int tr, int r, int g, int b);
Она создаёт структуру Color из компонентов ARGB цвета: прозрачности tr и основных цветов – красного r, зелёного g и синего b.
А другая перегруженная статическая функция
static Color FromArgb (int r, int g, int b);
создаёт структуру Color из компонентов ARGB цвета: прозрачности tr= 255 (непрозрачный цвет) и основных цветов – красного r, зелёного g и синего b. Примеры:
C++/CLI.
Color col (System::Drawing::Color::Gold); // Золотой цвет
Color col1 (Color::Gold); // Золотой цвет
Color col2 (Color::FromArgb (0, 0, 255)); // Синий непрозрачный цвет
Color col3;
col3= Color::FromArgb (0, 0, 255); // Синий цвет
Color col4;
col4= Color::Gold; // Золотой цвет
Color col5 (Color::FromArgb (100, 0, 0, 250)); // Синий полупрозрачный цвет
C#.
Color col3;
col3= Color.FromArgb (0, 0, 255); // Синий цвет
Color col4;
col4= Color.Gold; // Золотой цвет
Color col5= Color.Silver; // Серебренный цвет
Java. Цвет является объектом класса Color. Конструктор класса Color имеет формат:
Color (int r, int g, int b);
Color c= new Color (0, 200, 0); // c – синий цвет
Color c1=c; // c1 – тоже синий цвет
Color c2= new Color (0, 0, 255); // c2 – зелёный цвет
c2= с1; // c2 – теперь синий цвет
c1= Color.yellow; // c1- теперь жёлтый цвет
Класс Pen
C# и C++/CLI.Управляемый класс Pen используется для создания объектов-перьев (pens), определяющих стиль, толщину и цвет линий для рисования линий и кривых.
Конструкторы класса Pen
Pen (Color color); // C++/CLI и C#
Pen (Color color, float width)); // C++/CLI и C#
Pen ( Brush ^brush, float width, )); // C++/CLI
Pen ( Brush brush, float width, )); // C#
создают перья с заданным цветом color, шириной width (по умолчанию ширина равна 1). Цвет color может быть задействован из кисти brush - объекта класса Brush (Brush - базовый класс для кистей).
Класс Pen имеет ряд свойств, например, Color для установки или получения цвета пера и Width для установки и получения ширины пера.
Объекты класса Pen широко применяются в качестве аргументов функций рисования класса Graphics, например, в функции DrawEllipse().
Создать и модифицировать перо можно следующим образом:
С++/CLI
Pen ^pPen1= gcnew Pen (Color::Black); // Создать чёрное перо с шириной 1
pPen1 -> Color= Color::Green; // Перо стало зелёным
pPen1 -> Width= 5; // и с шириной, равной 5
Pen ^pPen2= gcnew Pen (Color::Green, 5);// Создать зелёное перо с шириной 5
Pen ^pPen3= gcnew Pen (gcnew SolidBrush(Color::Green), 5); // Создать
// зелёное перо с шириной 5
Color color= Color::Red;
Pen ^pPen4= gcnew Pen (color, 5); // Создать красное перо с шириной 5
С#.
Pen pen1= new Pen (Color.Black); // Создано чёрное перо с шириной 1
pen1.Color= Color.Green; // Перо стало зелёным
pen1.Width= 5; // и с шириной, равной 5
Pen pen2= new Pen (Color.Green, 5); // Создать зелёное перо с шириной 5
Класс имеет много свойств и функций.
Java. В языке Java перо не используется.
Класс SolidBrush
C++/CLI и C#.Управляемый класс SolidBrush, порождённый из базового класса Brush, используется для создания объектов-кистей, применяемых при закрашивании фона окон или внутри фигур.
Конструктор класса
SolidBrush (Color color);
имеет единственный параметр color типа Color, определяющий цвет созданной кисти.
Класс SolidBrush имеет свойство Color, позволяющее установить и получить цвет кисти:
C++/CLI.
SolidBrush ^pBrush= gcnew SolidBrush (Color::Black); // Создать чёрную кисть
pBrush -> Color= Color::Red; // и сделать красной
Pen ^pPen5= gcnew Pen (pBrush, 5); // Создать красное перо с шириной 5
C#.
SolidBrush brush= new SolidBrush (Color.Black); // Создать чёрную кисть
brush.Color= Color.Red; // и сделать красной
Java. В языке Java кисть не используется.
Класс Font
Объектами класса Font представляются шрифты с указанными названиями, размерами и стилями.
Класс Font содержит перегруженные конструкторы и, в частности:
C++/CLI.
Font (String ^name, float size);
Font (String ^name, float size, FontStyle style);
C#.
Font (string name, float size);
Font (string name, float size, FontStyle style);
Java.
Font (String name, int style, int size);
где
name - название шрифта,
size - размер шрифта,
style - стиль шрифта ( Bold -жирный, Italic– курсив и др.)
Шрифт можно задать так:
C++/CLI.
Font ^pFont= gcnew Font (“Verdana”, 15);
C#.
Font font= new Font (“Ariel”, 20, FontStyle.Italic);
Java.
Font f1= new Font ("Courier", Font.BOLD, 50);
Замечание: Обратите внимание на отличия в списке аргументов конструкторов языков C# (C++/CLI) и Java.
Класс Graphics
C++/CLI и C#.Объект класса Graphics является контекстом рисования, связанным с конкретным контекстом устройства и чаще всего с окном (формой). Класс Graphics предоставляет множество функций для рисования в этом окне строк (strings), прямоугольников (rectangles), эллипсов (ellipses) и т.д. Например:
C++/CLI.
void DrawString (String ^pS, Font ^pF, Brush ^pB, float x, float y);
void DrawRectangle (Pen ^pP, Rectangle r);
void FillEllipse (Brush ^pB, Rectangle r);
C#.
void DrawString (string s, Font f, Brush b, float x, float y);
void DrawRectangle (Pen p, Rectangle r);
void FillEllipse (Brush b, Rectangle r);
Можно создать графический объект класса Graphics непосредственно, используя функцию CreateGraphics().
Graphics graphics= CreateGraphics ( );
Но чаще всего используют параметр функции перерисовки OnPaint(). Это параметр типа структуры PaintEventArgs, которая одним из своих элементов содержит свойство Graphics.
C#.
Graphics gr= this.CreateGraphics ( ); // Непосредственное использование gr.DrawString (“Drawing”, Font, new SolidBrush (Color.Blue), 10, 10);
C++/CLI.
protected:
virtual void OnPaint (PaintEventArgs ^arg) override // Использование через
// аргумент arg
{
Color col (Color::FromArgb (250, 0, 250, 250));
Drawing::Font ^pFont= gcnew Drawing::Font ("Verdana", 20,
FontStyle::Italic);
arg ->Graphics ->DrawString ("Drawing", pFont, gcnew SolidBrush (col),
10, 30);
}
Java.ЯзыкJava использует пакет AWT, который содержит множество графических классов и функций. Среди классов есть и класс Graphics, содержащий, например, такие функции рисования как
void drawLine (int x1, int y1, int x2, int y2); // Рисовать линию
void drawOval (int x, inty, int w, int h); // Рисовать овал (эллипс)
void drawRect (int x, int y, int w, int h); // Рисовать прямоугольник
void drawString (String str, int x, int y); // Рисовать строку
void fillOval (int x, inty, int w, int h); // Залить овал (эллипс) цветом
void fillRect (int x, int y, int w, int h); // Залить прямоугольник цветом
void setColor (Color color); // Установить цвет
void setFont (Font font); // Установить шрифт
На языке Java также можно создать графический объект с помощью функции getGraphics() и затем воспользоваться функциями рисования, но рисование обычно осуществляется в теле предопределённой функции paint(), аргумент которой является ссылкой на объект графического класса Graphics.
Java.
public void paint (Graphics g) // Использование через аргумент arg
{
g.setColor(Color.magenta);
Font font= new Font ("Verdana", Font.ITALIC, 30);
g.setFont(font);
g.drawString ("Drawing", 10, 70);
}
Пример 9.6.1 иллюстрирует применение графики на языках C#, C++/CLI и Java(J#). В программах на языках C# и C++/CLI использовано пространство имён System.Drawing (System::Drawing), включающее графические классы. Прикладное окно программы представлено на рис. 9.6.1. Программа на языке Java(J#) применяет пакет java.awt.
Пример 9.6.1. Использование графического объекта.
///////////////
// C#
using System;
using System.Drawing;
using System.Windows.Forms;
class MainClass : Form
{
public MainClass ( )
{
Text= "Drawing"; // Заголовок прикладного окна
Show ( );// Показать окно
Graphics gr= this.CreateGraphics ( ); // Создать графический объект
gr.DrawString ("Drawing", Font, // Нарисовать строку
new SolidBrush (Color.Blue), 10, 50);
gr.DrawString ("Drawing", new Font ("Arial", 25), // Нарис-ть строку new SolidBrush (Color.FromArgb (100, 255, 0, 0)), 5, 40);
String drawStr = "Drawing"; // Создать строку
Font drawFnt = new Font ("Arial", 30);// Создать шрифт
SolidBrush drawBr = new SolidBrush (Color.Green);// и кисть
float x= 10.0F; // Координаты начала строки
float y= 40.0F;
gr.DrawString (drawStr, drawFnt, drawBr, x, y); // Нарис-ть строку
gr.DrawEllipse (new Pen(new SolidBrush (Color.DarkViolet), 2),
15, 15, 60, 70); // Нарисовать эллипс
}
static void Main ( )
{
Application.Run (new MainClass ( )); // Запустить программу
}
}
////////////////
// C++/CLI
#include "stdafx.h"
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
ref class MainClass : Form
{
public: MainClass ( )
{
Text= "Drawing"; // Заголовок прикладного окна
Show ( ); // Показать окно
Graphics ^gr= this->CreateGraphics ( ); // Создать графический
// объект
// Нарисовать строки
gr->DrawString ("Drawing", Font,
gcnew SolidBrush (Color::Blue), 10, 50);
gr->DrawString ("Drawing", gcnew Drawing::Font ("Arial", 25), gcnew SolidBrush (Color::FromArgb (100, 255, 0, 0)), 5, 40);
String ^drawStr = "Drawing";
Drawing::Font ^drawFnt = gcnew Drawing::Font ("Arial", 30);
SolidBrush ^drawBr = gcnew SolidBrush (Color::Green);
float x= 10.0F;
float y= 40.0F;
gr->DrawString (drawStr, drawFnt, drawBr, x, y);
// Нарисовать эллипс
gr->DrawEllipse (gcnew Pen (gcnew SolidBrush (Color::DarkViolet),
2), 15, 5, 60, 70);
}
};
void main ( )
{
Application::Run (gcnew MainClass ( ));
}
///////////////
// Java и J#
import java.awt.*;
class MainClass extends Frame
{
public MainClass ( )
{
this.setTitle ("Drawing"); // Заголовок прикладного окна
setSize (300, 200);
show ( ); // Показать окно
Graphics gr= this.getGraphics ( ); // Создать графический объект
// Нарисовать строку
gr.setColor (Color.blue);
gr.drawString ("Drawing",10, 80);
// Нарисовать ещё строку
gr.setFont(new Font ("Arial", Font.BOLD,25));
gr.drawString ("Drawing", 5, 70);
// Нарисовать еще строку
String drawStr = "Drawing"; // Создать строку
gr.setFont(new Font ("Arial", Font.BOLD, 30));
gr.setColor (Color.green);
int x= 10; // Координаты начала строки
int y= 40;
gr.drawString (drawStr, x, y); // Нарис-ть строку
gr.setColor (Color.darkGray);
gr.drawOval (15, 45, 60, 100); // Нарисовать эллипс
}
public static void main ( )
{
MainClass m= new MainClass ( );
}
}
Рис.9.6.1. Прикладное окно с графической информацией
C#.
protected override void OnPaint (PaintEventArgs e);
Функция реагирует на событие, определённое как
C++/CLI.
public: event PaintEventHandler ^Paint;
C#.
public event PaintEventHandler Paint;
Событие Paint использует делегат:
C++/CLI.
public: delegate void PaintEventHandler (Object ^sender, PaintEventArgs ^e);
C#.
public delegate void PaintEventHandler (object sender, PaintEventArgs e);
Для языка Java(J#) функция перерисовки имеет формат:
Java(J#).
public void paint (Graphics g);
[C++]
Пример 9.7.1 иллюстрирует использование событий, возникающих при нажатии на клавишу мыши и при перерисовке области клиента прикладного окна.
Пример 9.7.1. Программа рисования ломаной линии.
Приложение создаёт главное окно и ожидает нажатия левой клавиши мыши. При нажатии на клавишу рисуется линия из текущей точки в точку носика указателя мыши. После этого текущая точка переносится в точку носика указателя мыши, и приложение снова ждёт нажатия левой клавиши мыши. Прикладное окно с нарисованной ломаной линией изображено на рис. 10.7.1.
Рис.9.7.1. Прикладное окно программы рисования ломаной линии
Ниже приводится программа:
///////////////
// C#
using System;
using System.Drawing;
using System.Windows.Forms;
class CLine : Form // Класс прикладного окна
{
Point [ ] points; // Массив точек носика курсора мыши
int len; // Текущая длина массива points