Краткое руководство по работе с классом TCanvas для начинающих

@NiTan · Регистрация: 29.01.2010

Студворк — интернет-сервис помощи студентам

Вступление

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

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

А теперь пара слов о структуре данного материала:

Эта статья состоит из 3 частей: Первая часть - это небольшое руководство для начинающих, в которой рассмотрены основные понятия, методы и свойства.

Вторая часть представляет из себя краткий справочник по свойствам и методам канвы.

Третья часть - небольшой FAQ по классу TCanvas.

Оглавление:

1. Первые шаги
1.1 Рисование линий
1.2 Как нарисовать квадрат, использую метод LineTo

2. Рисование простых фигур
2.1 Прямоугольник
2.2 Эллипс

3. Изменение внешнего вида фигур
3.1 Свойство Pen
3.2 Свойство Brush

4. Заливка областей
4.1 Заливка областей
4.2. Сложная заливка (Использование метода FloodFill)

5. Вывод текста
5.1 Внешний вид текста

6. Вывод изображений
6.1 Небольшое вступление
6.2 Вывод изображений на канву формы при помощи метода Draw()
6.3 Прозрачность выводимых изображений
6.4 Использование метода StretchDraw()
6.5 Копирование участков канвы

7. Заключение

Дополнительно:
1. Основные методы рисования на канве
2. Основные свойства канвы
3. Небольшой FAQ по Канве

1. Первые шаги

TCanvas (Канва) - это класс, предназначенный для вывода и хранения графических обьектов в C++ Builder. Канва входит в состав большинства визуальных компонентов, кроме стандартных оконных контролов (TButton, TMemo, TPanel и т.п.).
При помощи методов этого класса можно рисовать как и стандартные примитивы (линии, эллипсы, прямоугольники), так и графические обьекты, типа Graphics::TBitmap.

Доступ к канве любого обьекта происходит следующим образом:

C++
1
имя_обьекта->Canvas->Свойство/Метод;

Теперь давайте перейдем к практике. Для начала, необходимо понимать, что из себя представляет канва.
Канва, в ее графическом представлении, это двумерный массив пикселей. Каждый элемент этого массива хранит в себе информацию о цвете. Доступ к отдельно взятому пикселю можно получить из свойства Pixels, подробнее о котором будет написана ниже.
Точка (0,0) - эта верхний левый угол канвы. Значение по x-координате возрастает слево навправо от точки (0,0), а значение по y-координате сверху вниз.

1.1. Рисование линий

Теперь мы научимся рисовать простые обьекты на канве. Для начала, научимся чертить линии.

Создайте новый проект, затем разместите на форме компонент TButton из вкладки Standart и на обработчик события OnClick напишите следующий код:

C++
1
Form1->Canvas->LineTo(250,250);

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

Но теперь разберемся, почему эта линия была проведена именно из точки (0,0). Метод, при помощи которого мы нарисовали эту прямую, имеет два параметра:

X - положение конечной точки прямой по x-координате.
Y - положение конечной точки прямой по y-координате.

Начальная же точка прямой задается текущим положением пера на канве. По умолчанию (пока ничего не было нарисовано или положение пера не было изменено вручную), начальной точкой является точка (0,0), то есть левый верхний угол.
Но после того, как мы провели прямую, положение пера изменилось на координаты X и Y, указанные при вызове метода LineTo.
Теперь, если мы проведем еще одну прямую, скажем, в точку (500,100), то она будет проведена уже не из верхнего левого угла канвы, а из точки (250,250).

Пример:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form1->Canvas->LineTo(250,250); //Проводим первую прямую
Form1->Canvas->LineTo(500,100); //Теперь проводим другую прямую
}
//---------------------------------------------------------------------------

Результат:

Краткое руководство по работе с классом TCanvas для начинающих

Но текущее положение пера можно изменить и вручную, не проводя никаких лишних линий. Для этого следует воспользоваться методом MoveTo (x, y), где x - новое положение пера по горизонтали, а y - новое положение пера по вертикали.

Пример:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form1->Canvas->MoveTo(100,25); //Перемещаем перо в точку (100,25)
Form1->Canvas->LineTo(500,100); //Проводим прямую в точку (500,100)
}
//---------------------------------------------------------------------------

Результат:

Это важно знать: при обращение к свойствам формы из самой формы не обязательно писать:

C++
1
Form1->Свойство->и т.д..

Так как вызов происходит из самого класса формы, можно просто написать:

C++
1
Свойство->и т.д...

Допустим, если нужно изменить ширину формы при нажатии на кнопку, можно написать такой код:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form1->Width=1024;
}
//---------------------------------------------------------------------------

Но можно явно и не указывать, к какому обьекту происходит обращение и сделать так:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Width=1024;
}
//---------------------------------------------------------------------------

Так и к канве формы можно обращаться просто написав:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Метод/Свойство...;
}
//---------------------------------------------------------------------------

Эффект будет одинаков.

1.2. Как нарисовать квадрат, использую метод LineTo

При помощи методов LineTo и MoveTo можно рисовать не только простые линии, но и такие обьект, как, допустим, прямоугольник или квадрат. Приведенный ниже пример показывает, как это можно сделать:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form1->Canvas->MoveTo(25,25);// Перемещаем положение пера в точку (25,25),
                             // чтобы было лучше видно нарисованную нами фигуру
 
 Form1->Canvas->LineTo(25,200); //Опускаем вертикальную прямую
                              //в точку на 200 пикселей вниз - левая сторона прямоугольника
 
 //Так как положение пера теперь равно (25,200),
 //то нам не нужно вручную его менять и поэтому мы...
 
 Form1->Canvas->LineTo(200,200); //Проводим горизонтальную прямую в точку (200,200)
                                // - это у нас будет нижняя граница прямоугольника
 
 Form1->Canvas->LineTo(200,25); //Затем мы проводим прямую в точку (200,250),
                                // таким образом рисую правую сторону прямоугольника
 
 Form1->Canvas->LineTo(25,25);  //И наконец послдний штрих - проводим горизонтальную прямую
                                // в начальную точку, из которой начали рисовать,
                                //тем самым замыкая нашу фигуру
}
//---------------------------------------------------------------------------

В итоге у нас получится самый обычный квадрат:

На изображении красные линии указывают направление, в котором мы чертили линии.

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

2. Рисование простых фигур

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

2.1. Прямоугольник

Для рисования прямоугольников служит функция Rectangle, имеющая следующий вид:
Rectangle (x1,y1,x2,y2), где переменные x1,y1 отвечают за положение левого верхнего угла прямоугольника, а переменные x2,y2 за положение нижнего правого угла. Чтобы лучше понять, как это работает, взглянем на простой пример:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Rectangle(25,25,200,200);
}
//---------------------------------------------------------------------------

Название: fstep11.jpg
Просмотров: 31919

Размер: 5.2 Кб

Теперь запустите проект и вы увидите, что мы получили самый обычный квадрат, который до этого нарисовали при помощи 4-х линий. Как видите, рисовать в одну строку намного легче.

2.2. Эллипс

Для рисования эллипсов в канве предназначена функция Ellipse(x1,y1,x2,y2). Этот метод имеет точно такие же параметры, как и Rectangle, за исключением того, что здесь указываются координаты углов прямоугольника, описывающего эллипс.

Пример рисования эллипса:

C++
1
Canvas->Ellipse(25,25,200,200);

Как видите, эллипс рисуется точно также как и прямоугольник, то есть, очень просто.

3. Изменение внешнего вида фигур

За внешний вид рисуемых фигур отвечают два свойства, которые задают заливку и контур обьектов - это свойства Pen и Brush. Чтобы задать желаемый внешний вид обьектам, эти свойства нужно настроить перед использованием функций рисования. Нарисованные обьекты внешний вид не изменят, если изменить одно из этих свойств после. Теперь поговорим подробнее о каждом из них.

3.1. Pen

Свойство Pen (карандаш, перо) задает внешний вид рисуемых линий, а также контуров фигур. Допустим, мы хотим нарисовать красную линию, тогда мы поступим следующим образом:

C++
1
2
Canvas->Pen->Color=clRed; //Изменяем цвет пера на красный
Canvas->LineTo(200,200); //Проводим линию

Как вы, наверное, уже поняли, за цвет отвечает параметр Color. Значение для этого параметра задается при помощи цветовых констант (полный список которых можно посмотреть, например, во встроенной в C++ Builder справки, задав поиск по классу TColor), либо ввиде 16-ричного значения:

C++
1
2
Canvas->Pen->Color=clDkGray; //Меняем цвет линий на темно-серый
Canvas->Pen->Color=clGreen; //Или меняем цвет на зеленый

За ширину рисуемых линий и контуров отвечает параметр Width, задающийся в пикселях. По умолчанию его значение равно 1. Изменяется толщина пера очень просто:

C++
1
2
Canvas->Pen->Width=4; //Увеличиваем толщину до 4
Canvas->Rectangle(8,8,256,256); //Рисуем прямоугольник, который будет иметь достаточно толстый контур

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

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Pen->Style=psDot;
Canvas->LineTo(400,400);
}
//---------------------------------------------------------------------------

Данный пример проводит пунктирную линию. Следующий пример проводит прямую, состоящую из малых штрихов:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Pen->Style=psDash;
Canvas->LineTo(400,200);
}
//---------------------------------------------------------------------------

При рисовании фигур, их контур также будет изменять свой вид:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Pen->Style=psDashDot;
Canvas->Ellipse(25,25,325,325);
}
//---------------------------------------------------------------------------

Данный пример нарисует эллипс, состоящий из чередования точек и штрихов.

Полный список всех стилей пера можно посмотреть, например, здесь Основные свойства Канвы. Pen

3.2. Brush

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

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Brush->Color=clBlue; //clBlue - синий цвет
Canvas->Rectangle(25,25,225,225);
}
//---------------------------------------------------------------------------

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

К примеру, указав в качестве значения bsVertical, мы фон обьекта будет заполнен вертикальными линиями:

C++
1
2
3
4
5
6
7
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Brush->Color=clRed; 
Canvas->Brush->Style=bsVertical;
Canvas->Rectangle(25,25,225,225);
}
//---------------------------------------------------------------------------

Результат:
Название: cross.jpg
Просмотров: 31924

Размер: 15.8 Кб

А указав в качестве значения bsCross, обьект будет расчерчен в клеточку:

C++
1
2
3
4
5
6
7
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Brush->Color=clSkyBlue;;
Canvas->Brush->Style=bsCross;
Canvas->RoundRect(25,25,225,225,15,15);
}
//---------------------------------------------------------------------------

В итоге получится вот такой вот тетрадный лист

:

Название: cross2.jpg
Просмотров: 31981

Размер: 18.0 Кб

Если же в качестве значение указать bsClear, то рисуемые обьекты не будут иметь фона, то есть будут прозрачны. Данное значение следует устанавливать, например, при выводе текста на канву, либо если нужно начертить только контур фигуры.

Остальные значения, которые может принимать это свойство, можно посмотреть здесь: Основные свойства канвы. Brush

Также, в качестве фона обьекта мы можем указать любую картинку формата BMP. Но в таком случае, значения свойства Style будет игнорироваться. Данный параметр будет рассмотрен в следующей главе.

4. Заливка областей

Теперь, когда мы научились рисовать простые фигуры и изменять их внешний вид, мы научимся заливать (закрашивать) области на канве. Для этого предназначены две функции, это методы FillRect (TRect* Rect) и FloodFill (x,y, Color, Style). Теперь разберем эти методы более подробно.

4.1. Заливка прямоугольных областей

При помощи функции FillRect происходит простая заливка указанной прямоугольной области на канве. Вид заливки определяет свойство Brush. В качестве единственного параметра у данного метода идет простая структура TRect& Rect, представляющая из себя всего лишь набор из 4 переменных, определяющих границы этой области:

Рассмотрим простой пример заливки области:

C++
1
2
3
4
5
6
7
8
9
10
11
void __fastcall TForm1::Button1Click(TObject *Sender)
{
TRect r; //Создаем структуру, типа TRect
r.Left=0; //Задаем левую границу области
r.right=600; //Задаем правую границу
r.Bottom=600; //Задаем нижнюю границу
r.Top=0; //Задаем верхнюю границу области
Canvas->Brush->Color=clMoneyGreen;  //Определяем цвет заливки
Canvas->FillRect(r); //Заполняем указанную область
}
//---------------------------------------------------------------------------

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

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Brush->Color=clMoneyGreen;
Canvas->FillRect(Rect(0,0,600,600));
}
//---------------------------------------------------------------------------

Как видите, результат будет тот же.

Здесь у меня возникла проблемка с кодом:

C++
1
2
3
4
5
6
7
8
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Brush->Color=clWhite;
Canvas->Pen->Color=clRed;
Canvas->Brush->Style=bsCross;
Canvas->FillRect(Rect(0,0,200,200));
}
//---------------------------------------------------------------------------

4.2. Сложная заливка (Использование метода FloodFill)

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

Функция FloodFill имеет следующий вид: FloodFill ( int x, int y, TColor Color, TFillStyle FillStyle), где:

x,y - координаты начальной точки заливки
Color - цвет, определяющий область заливки
FillStyle - стиль заливки, о котором я расскажу несколько позже

Заливка области происходит текущей кистью, как и у метода FillRect().

Теперь рассмотрим пример заливки при помощи метода FloodFill. Для начала, возьмем какое-нибудь простое изображение, что-то вроде этого:

Название: fillrectshow.jpg
Просмотров: 38397

Размер: 2.5 Кб

Название: fillrectshow.jpg
Просмотров: 38397

Размер: 2.5 Кб

Затем, добавьте на форму один TImage, загрузите туда это изображение и пропишите следующий код на событие OnClick кнопки:

C++
1
2
3
4
5
6
7
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Image1->Canvas->Brush->Color=clRed; //Устанавливаем цвет кисти
Image1->Canvas->FloodFill(8,8,clWhite,fsSurface);  //Заливаем
}
//---------------------------------------------------------------------------

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

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

C++
1
2
3
4
5
6
7
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Image1->Canvas->Brush->Color=clRed;
Image1->Canvas->FloodFill(8,8,Image1->Canvas->Pixels[8][8],fsSurface);
}
//---------------------------------------------------------------------------

Результат будет тот же. Подробнее о свойстве Pixels можно прочитать здесь Основные свойства канвы. Pixels

Кроме этого, мы можем произвести заливку и текстурой:

C++
1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *b=new Graphics::TBitmap;
b->LoadFromFile("C:\\brush.bmp");
Image1->Canvas->Brush->Bitmap=b;
Image1->Canvas->FloodFill(8,8,Image1->Canvas->Pixels[8][8],fsSurface);
delete b;
b=NULL;
}
//---------------------------------------------------------------------------

Теперь, разберемся, что чего же нужен параметр TFillStyle.

Этот параметр отвечает за стиль (тип) заливки. Если значение этого параметра равно fsSurface, то произойдет заливка замкнутой области, определенной цветом Color.

А если значение этого параметра равно fsBorder, то произойдет заливка области, где параметр Color выполнит роль "границы". Чувствуете разницу? Нет? Тогда вот вам пример:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Image1->Canvas->Brush->Color=clRed;
Image1->Canvas->FloodFill(8,8,clBlue,fsBorder);
}
//---------------------------------------------------------------------------

А теперь сравните результат с первым примером - произошло заполнение всего изображения, кроме той области, которая была синей (clBlue), потому что именно этот цвет мы указали в качестве "границы".

Если бы мы указали в качестве параметра Color цвет, который не присутствовал бы на изображении, то произошла полная заливка всей картинки.

5. Вывод текста

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

Это функции TextOut(x, y, Text) и TextRect(Rect, x, y, Text). Разница между ними лишь в том, что в первом случае мы указываем только координаты текста и, собственно, сам текст, а во втором случае, мы также и указываем прямоугольную область, которая обрезает текст, если тот выходит за ее пределы.

Теперь рассмотрим простой пример вывода текста:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->TextOut(25,25,"This is text!");  //Выводим фразу 'This is text' на канву формы в координаты (25,25)
}
//---------------------------------------------------------------------------

Как вы видите, все очень просто. Функция TextOut принимает всего 3 аргумента:

int x - положение текста по оси x
int y - положение текста по оси y
String Text - собственно, сам текст

В качестве выводимого текста мы можем задать любую переменную, которую можно привести к типу String. К примеру, мы можем вывести значение из Edit1 на форму при помощи следующего кода:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->TextOut(100,25,Edit1->Text);
}
//---------------------------------------------------------------------------

Но не стоит пытаться выводить многострочный текст из компонетов, типа TMemo при помощи этой функции - не получится, потому что вывод все равно произойдет в одну строчку. Но так как вам непременно захочется это сделать, показываю пример:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->TextOut(25,25,Memo1->Text);
}
//---------------------------------------------------------------------------

В результате мы получим следующее:

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

5.1. Внешний вид текста

За внешний вид выводимого текста отвечает свойство Font канвы. При помощи него мы можем задать шрифт текста, его размер, цвет и стиль. Для этого нужно будет изменить всего лишь несколько параметров. Например, за шрифт отвечает параметр Name - он задает основной внешний облик (способ начертания) текста.
Указать в качестве значения этого параметра мы можем имя любого шрифта, установленного в системе (Arial, MS Sans Serif, Calibri и т.д.). Хотелось бы также предупредить, что если указанного шрифта не окажется в системе, то Windows автоматически подберет наиболее похожий шрифт сама.
Следующий пример выводит на форму три строки, написанные разным шрифтом:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void __fastcall TForm1::Button1Click(TObject *Sender)
{
//Первая строка, написанная при помощи шрифта MS Sans Serif
Canvas->Font->Name="MS Sans Serif";
Canvas->TextOut(25,25,"MS Sans Serif");
 
//Вторая строка
Canvas->Font->Name="Comic Sans MS";
Canvas->TextOut(25,50,"Comic Sans MS");
 
//Третья строка
Canvas->Font->Name="Roman";
Canvas->TextOut(25,75,"Roman");
}
//---------------------------------------------------------------------------

Это полезно знать:

Как узнать список всех шрифтов, установленных в системе?

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

C++
1
2
3
4
5
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Memo1->Lines=Screen->Fonts;
}
//---------------------------------------------------------------------------

На форме расположена кнопка (TButton) и компонент Memo1 (TMemo), куда выводится список всех шрифтов.

За цвет текста отвечает параметр Color. Значение задается при помощи цветовых констант (clRed - красный, clGreen - зеленый, clBlue - синий/голубой и т.д.) или некоторыми другими способами, которые будут рассмотрены позже.
Пример:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Canvas->Font->Color=clRed; //Меняем цвет текста на красный
Canvas->TextOut(25,25,"Red Red Red!!!"); //Выводим текст
}
//---------------------------------------------------------------------------

За размер текста отвечает два свойства - это Size и Height.
Параметр Size задает размер текста в кеглях:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Font->Size=25;  //Задаме размер (25 - эт очень много)
Canvas->TextOut(25,50,"Big big Text :)");  //Выводим большой текст
}
//---------------------------------------------------------------------------

А параметр Height, в отличи от предыдущего параметра, задает размер в пикселях:

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Font->Height=25;
Canvas->TextOut(25,50,"Big big Text :)");
}
//---------------------------------------------------------------------------

Как именно менять размер - разницы нет. Делайте так, как вам будет удобнее. Лично мне, задавать размер в кеглях намного удобнее и привычнее.

6. Вывод изображений

6.1. Небольшое вступление

Для вывода изображений на канву у класса TCanvas предназначено всего два метода:

Draw(int x,int y, TGraphic *Graphic) - выводит обьект, типа TGraphic на канву, начиная рисовать от точки (x,y)
StretchDraw(TRect& Rect, TGraphic *Graphic) - выводит обьект, типа TGraphic, автоматически подгоняя изображение под заданную область Rect.

В качестве обьекта TGraphic может выступать один из трех классов потомков. Это классы TBitmap, TIcon и TMetafile. В данной статье мы будем работать только с классом TBitmap, так как он представляет наибольший интерес
при работе с графикой в C++ Builder.

Сразу бы хотелось бы заметить, что в C++ Builder существует два класса с подобным названием, но обьявленные в разных модулях и совершенно друг на друга не похожие. Это Graphics::TBitmap и Windows::TBitmap.
Работать мы будем с первым классом, а второй трогать не будем.

Теперь познакомимся с этим классом поближе.
TBitmap - класс, предназначенный для хранения и модификации стандартных графических файлов, формата BMP. Он обладает свойством Canvas, поэтому мы легко можем
модифицировать загруженные изображения, применяя все описаные в данной статье методы.

6.2. Вывод изображений на канву формы при помощи метода Draw()

Рассмотрим простой пример вывода графического изображения на канву. Возьмем обычное изображение, формата BMP:

Теперь выведем его на канву формы, используя метод Draw:

C++
1
2
3
4
Graphics::TBitmap *bitmap=new Graphics::TBitmap; //Создали экземпляр класса Graphics::TBitmap
bitmap->LoadFromFile("F:\\drawgraphic.bmp"); //Загрузили в него изображение
Canvas->Draw(0,0,bitmap); //Вывели на канву формы в точке (0,0)
delete bitmap; //Освободили память

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

C++
1
2
3
4
5
6
7
8
9
10
11
12
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *bitmap=new Graphics::TBitmap; //Создали обьект класса TBitmap
     bitmap->Width=140;         // Устанавливаем ширину
     bitmap->Height=140;        //и высоту нашего изображения
     bitmap->Canvas->Rectangle(25,25,125,125);  //Рисуем прямоугольник
     Canvas->Draw(0,0,bitmap);  //Выводим на канву формы
delete bitmap; //Очищаем память
 
 
}
//---------------------------------------------------------------------------

Результат:

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

Теперь попробуем загрузить изображение из файла, нарисовать на нем что-нибудь, затем вывести на канву и сохранить обратно в файл.

C++
1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *bitmap=new Graphics::TBitmap; //Создали экземпляр класса Graphics::TBitmap
bitmap->LoadFromFile("F:\\drawgraphic.bmp"); //Загрузили в него изображение
bitmap->Canvas->Rectangle(25,25,125,125);  //Нарисовали прямоугольник
Canvas->Draw(0,0,bitmap); //Вывели на канву формы в точке (0,0)
bitmap->SaveToFile("F:\\drawgraphic_modified.bmp"); // Сохранили в файл
delete bitmap; //Освободили память
}
//---------------------------------------------------------------------------

Результат:

6.3. Прозрачность выводимых изображений

Также класс Graphics::TBitmap обладает очень полезным свойством, которое называется Transparent (прозрачность). При положительном значение данного параметра, все пиксели цвета, который является "прозрачным", не будут отрисовываться на канве.
Прозрачный цвет либо задается автоматически (равен цвету нижнего левого пикселя изображения), либо устанавливаются вручную при помощи свойства TranparentColor.
Теперь слегка модифицируем наш первый пример, включив прозрачность у выводимого изображения:

C++
1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *bitmap=new Graphics::TBitmap;
     bitmap->LoadFromFile("F:\\drawgraphic.bmp"); //Загружаем изображение из файла
     bitmap->Transparent=true; //Включаем прозрачность
     bitmap->TransparentColor=clWhite; //Устанавливаем цвет прозрачности (белый)
     Canvas->Draw(0,0,bitmap);//Выводим изображение
delete bitmap;
}
//---------------------------------------------------------------------------

Итог:

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

Тоже самое можно проделать и со вторым примером:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *bitmap=new Graphics::TBitmap; //Создали обьект класса TBitmap
     bitmap->Width=140;         // Устанавливаем ширину
     bitmap->Height=140;        //и высоту нашего изображения
     bitmap->Canvas->Rectangle(25,25,125,125);  //Рисуем прямоугольник
     bitmap->Transparent=true; //Включаем прозрачность
     //Устанавливать цвет прозрачности вручную нет необходимости, так как левый нижний пиксель и так является цветом фона, от которого мы хотим избавится
     Canvas->Draw(0,0,bitmap);  //Выводим на канву формы
delete bitmap; //Очищаем память
 
 
}
//---------------------------------------------------------------------------

Теперь совместим первый и второй пример:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *bitmap1=new Graphics::TBitmap; 
     bitmap1->LoadFromFile("F:\\drawgraphic.bmp"); //Загружаем изображение
     bitmap1->Transparent=true; //Включаем прозрачность
     bitmap1->TransparentColor=clWhite; //Устанавливаем цвет прозрачности
 
Graphics::TBitmap *bitmap2=new Graphics::TBitmap; //Создаем второй экземпляр класса, в котором выведем текст
 //Задаем размеры
     bitmap2->Width=200;
     bitmap2->Height=200;
     bitmap2->Canvas->TextOutA(0,0,"12323123321132312312"); //Выводим текст
     bitmap2->Transparent=true; //Включаем прозрачность
 
     bitmap1->Canvas->Draw(50,0,bitmap2);  //Рисуем второе изображение поверх первого
 
Canvas->Draw(0,0,bitmap1); //Выводим на канву формы
delete bitmap1,bitmap2; //Освобождаем память
}
//---------------------------------------------------------------------------

6.4. Использование метода StretchDraw()

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

C++
1
2
3
4
5
6
7
8
9
10
11
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap *bitmap1=new Graphics::TBitmap;
     bitmap1->LoadFromFile("F:\\drawgraphic.bmp");
     bitmap1->Transparent=true;
     bitmap1->TransparentColor=clWhite;
 
Canvas->StretchDraw(Rect(0,0,800,600),bitmap1);
delete bitmap1;
}
//---------------------------------------------------------------------------

В методе StretchDraw в качестве первого передаваемого параметра идет структура, типа TRect, в которой задается требуема область вывода. Значение параметров Left и Top задают координаты левого верхнего угла прямоугольной области, в которую должно быть помещено изображение, а параметры Right и Bottom - правого нижнего. Ширина будет равна: (значение Right - значение Left), а высота соответственно (значение Bottom - значение Top).

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

C++
1
2
3
4
5
6
7
8
9
10
11
12
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 
Graphics::TBitmap *bitmap1=new Graphics::TBitmap;
     bitmap1->LoadFromFile("F:\\drawgraphic.bmp");
     bitmap1->Transparent=true;
     bitmap1->TransparentColor=clWhite;
 
Canvas->StretchDraw(Form1->Canvas->ClipRect,bitmap1);
delete bitmap1;
}
//---------------------------------------------------------------------------

6.5 Копирование участков канвы

Бывают случаи, когда необходимо скопировать определенный участок одного изображения и поместить во второе. Для вот таких подобных случаев в классе TCanvas предназначен специальный метод. Называется он CopyRect и имеет следующий вид:

CopyRect(TRect& Dest, TCanvas& Canvas, TRect& Source)

Здесь Source - область канвы Canvas, которая копируется (помещается) в область Dest канвы, у которой мы вызвали этот метод.

Для примера, скопируем область Rect1 исходного изображения в область Rect2 канвы формы:

C++
1
2
3
4
5
6
7
Graphics::TBitmap *bitmap1=new Graphics::TBitmap;
     bitmap1->LoadFromFile("F:\\drawgraphic.bmp");
     bitmap1->Transparent=true;
     bitmap1->TransparentColor=clWhite;
 
Canvas->CopyRect(Rect(0,0,200,200),bitmap1->Canvas,Rect(0,0,400,280));
delete bitmap1;

При этом нужно знать, что прозрачность работает только при использовании методов Draw() и StretchDraw(), и при копировании подобным способом она работать не будет.

7. Заключение

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

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

Всем тем, кто это все прочитал, спасибо и удачи!

@NiTan · 04.04.2011, 18:11 **[ТС]**

Основные методы рисования на канве

Ellipse

Ellipse (x1,y1,x2,y2) - данная функция рисует эллипс по заданным координатам. Свойство Pen Канвы задает контур фигуры, а свойство Brush определяет цвет или текстуру заливки.

C++
1
2
Canvas->Brush->Color=clRed; //Задаем цвет заливки (clRed - красный)
Canvas->Ellipse(25,25,125,125);     //Рисуем эллипс

Получится вот такая вот фигура:
Название: ellipse.jpg
Просмотров: 38722

Размер: 3.3 Кб

Rectangle

Rectangle (x1,y1,x2,y2) - данная функция рисует прямоугольник по заданным координатам. Свойство Pen Канвы задает контур фигуры, а свойство Brush определяет цвет или текстуру заливки.

C++
1
2
Canvas->Brush->Color=clGreen; //Задаем цвет заливки (clGreen - зеленый)
Canvas->Rectangle(25,25,250,150);     //Рисуем прямоугольник

Получится вот такая вот фигура:
Название: rectangle.jpg
Просмотров: 31966

Размер: 3.6 Кб

RoundRect

RoundRect (x1,y1,x2,y2,x3,y3) - данная функция рисует прямоугольник с закругленными углами по заданным координатам. Переменные x1,x2,y1,y2 явлеются координатами фигуры на канве, а переменные x3 и y3 определяют ширину и высоту эллипсов, формирующих углы. Чем больше значение этих переменных, тем сильнее углы будут "закруглены".

C++
1
2
3
4
5
6
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Brush->Color=clYellow; // Меняем цвет кисти на clYellow - желтый
Canvas->RoundRect(25,25,125,125,20,20);  //Рисуем прямоугольник с закругленными углами.
}
//---------------------------------------------------------------------------

Получится фигура, следующиего вида:

Название: round_rect.jpg
Просмотров: 38841

Размер: 2.7 Кб

FillRect

FillRect (Rect) - данная функция заполняет указанную прямоугольную область цветом или текстурой, указаными в свойстве Brush.

Заполнение цветом:

C++
1
2
Canvas->Brush->Color=clBlue; //Задаем цвет заливки (clBlue - синий)
Canvas->FillRect(Rect(0,0,250,250)); //Указываем прямоугольную область и заполняем ее синим цветом

Заполнение изображением (текстурой):

C++
1
2
3
4
5
6
7
8
9
Graphics::TBitmap *bBitmap=new Graphics::TBitmap;
bBitmap->LoadFromFile("F:\\bitmap.bmp");
 
Canvas->Brush->Bitmap=bBitmap;
 
Canvas->FillRect(Rect(0,0,250,250));
 
Canvas->Brush->Bitmap=NULL;
delete bBitmap;

Эффект будет следующий:

LineTo

LineTo (int x,int y) - данная функция проводит прямую из текущего положения пера в точку x, y. Также эта функция автоматически меняет значение PenPos подставляя текущии значение x и y. То есть, если первый раз отрезок был проведен из точки x1, y1 в точку x2,y2, то во второй раз он будет проведен из точки x2,y2 и т.д, если положение пера не будет изменено вручную пользователем.
Цвет и тип линии зависит от свойства Pen.

Пример:

C++
1
2
3
4
5
6
7
8
void __fastcall TForm1::Button1Click(TObject *Sender)
{
//Проводим прямую линию из точки 0,0   в точку 250, 250
Canvas->LineTo(250,250);
//Теперь проводим прямую из точки 250, 250 в точку 600, 250
Canvas->LineTo(600,250);
}
//---------------------------------------------------------------------------

C++
1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Button1Click(TObject *Sender)
{
//Проводим прямую линию из точки 0,0   в точку 250, 250
Canvas->LineTo(250,250);
//Перемещаем перо в точку 250, 600
Canvas->MoveTo(250,600);
//Проводим прямую в точку 600, 600 из точки 250, 600
Canvas->LineTo(600,600);
}
//---------------------------------------------------------------------------

Arc

Arc (x1,y1,x2,y2,x3,y3,x4,y4) - данный метод рисует дугу на канве. Переменные x1,y1,x2,y2 - определяют эллипс, частью которого является дуга. Переменные x3,y3 - определяют начальную точку дуги, а x4,y4 - конечную точку дуги. Дуга вычерчивается против часовой стрелки из начальной в конечную точку.
Внешний вид дуги определяет свойство Pen канвы.

Для того, чтобы было легче понять, как работает этот метод, привожу несколько примеров:

Пример №1:

C++
1
2
3
4
5
6
7
8
9
10
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Pen->Width=3; //Устанавливаем ширину пера
 
//Теперь рисуем дугу
Canvas->Arc(0,0,200,200,  //Координаты прямоугольника, описывающего эллипс, частью которого явлется дуга
100,200,       //Начальная точка дуги
200,100);      //Конечная точка дуги
}
//---------------------------------------------------------------------------

Draw

Draw(int x,int y,TGraphic* Graphic) - данная функция рисует обьект, типа TGraphic на Канве в точке x, y.
Пример:

C++
1
2
3
4
5
6
7
8
9
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap* bit=new Graphics::TBitmap;     //Создаем обьек, класса Graphics::TBitmap
bit->LoadFromFile("F:\\bitmap.bmp");             //Загружаем в него изображение
Canvas->Draw(25,25,bit);                         //Рисуем на Канве
delete bit;                                     //Освобождаем память
bit=NULL;
}
//---------------------------------------------------------------------------

Результат будет следующий:

StretchDraw

StretchDraw(Rect, TGraphic* Graphic) - данная функция рисует на Канве обьект, типа TGraphic, автоматически подгоняя его под указанную прямоугольную область.

C++
1
2
3
4
5
6
7
8
9
10
  
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Graphics::TBitmap* bit=new Graphics::TBitmap;     //Создаем обьек, класса Graphics::TBitmap
bit->LoadFromFile("F:\\bitmap.bmp");             //Загружаем в него изображение
Canvas->StretchDraw(Rect(25,25,600,600),bit);        //Рисуем на Канве
delete bit;                                     //Освобождаем память
bit=NULL;
}
//---------------------------------------------------------------------------

В отличии от предыдущего раза, картинка будет растянута:

CopyRect

CopyRect (TRect &Dest, TCanvas* Canvas, TRect &Source) - данная функция копирует прямоугольную область Source указанной Канвы Canvas в прямоугольную область Dest Канвы, у которой данный метод был вызван. При этом происходит автоматический подгон размера копируемой части Канвы под новую область.
Пример:
На форме размещен обьект, типа TImage, в который загружено изображение. При нажатии на кнопку, часть этого изображения будет скопировано на форму:

C++
1
2
3
4
5
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->CopyRect(Rect(0,0,250,250),Image1->Canvas,Rect(350,0,600,250)); //Копируем наше изображение
}
//---------------------------------------------------------------------------

Результат:

TextOut

TextOut (int x, int y, String Text) - этот метод выводит текст на канву в заданных координатах. Переменные x и y отвечают за позицию текста, а Text за выводимую строку. Шрифт выводимого текста зависит от свойства Font канвы.

Пример:

C++
1
2
3
4
5
6
7
8
9
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Font->Style=Canvas->Font->Style<<fsBold;  //Делаем шрифт полужирным
Canvas->Font->Size=24;         //Изменяем размер шрифта
Canvas->Font->Color=clRed;   //Меняем цвет шрифта
Canvas->Font->Name="Garamond Premr Pro Smbd"; //Меняем имя шрифта
Canvas->TextOut(25,25,"Hello, World");   //Выводим строку
}
//---------------------------------------------------------------------------

TextRect

TextRect (TRect& Rect,int x, int y, String Text) - эта функция делает тоже самое, что и метод TextOut, с разницей лишь в том, что здесь, кроме позиции текста на канве, указывается также прямоугольная область вывода текста (Rect) и, если текст выдет за пределы этой области, он будет обрезан.

Пример:

C++
1
2
3
4
5
6
7
8
9
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Canvas->Font->Style=Canvas->Font->Style<<fsBold<<fsUnderline;  //Делаем шрифт полужирным и подчеркнутым
Canvas->Font->Size=16;         //Изменяем размер шрифта
Canvas->Font->Color=clGray;   //Меняем цвет шрифта  (clGray - серый)
Canvas->Font->Name="Magneto"; //Меняем имя шрифта
Canvas->TextRect(Rect(0,0,250,250),25,25,"Fight With Blood, Fight With Steel, Die With Honor Never Yield...");
}
//---------------------------------------------------------------------------

Результат будет следующий:

@NiTan · 04.04.2011, 18:14 **[ТС]**

Основные свойства канвы

Brush

Кисть - определяет цвет или текстуру заливки при рисовании фигур, типа Ellipse, Rectangle, RoundRect и т.п.
Класс TBrush имеет следующие свойства:

● Handle - дескриптор кисти.

● Color - цвет заливки.

● Style - стиль заливки. Это свойство может принимать следующие значения:

● Bitmap - своего рода, текстура кисти. Если это свойство определено, то фон фигур будет закрашиваться указанным изображением.
Небольшой пример:

C++
1
2
3
4
5
6
7
8
9
10
11
12
Graphics::TBitmap *BrushBitmap = new Graphics::TBitmap;   //Создаем обьект, класса Graphics::TBitmap
 
BrushBitmap->LoadFromFile("F:\\bitmap.bmp");    //Загружаем в него изображение
 
Canvas->Brush->Bitmap=BrushBitmap;             //Указываем в качестве кисти созданный ранее Битмап
 
Canvas->Rectangle(0,0,250,250);              //Для проверки
 
 
 
Canvas->Brush->Bitmap = NULL;                //Освобождаем память
delete BrushBitmap;

Pen

Перо - это свойство определяет вид линий и обводки фигур, нарисованных на канве.
Класс TPen имеет следующие свойства:

● Handle - дескриптор пера.

● Width - толщина линии, рисуемой пером. Значение по умолчанию равно 1.

● Color - цвет линии, рисуемой пером. По умолчанию это значение равно clBlack (черный).

● Style - стиль линии, рисуемой пером. Может принимать следующие значения:

Название: pen_styles.jpg
Просмотров: 32726

Размер: 24.6 Кб

Название: pen_styles.jpg
Просмотров: 32726

Размер: 24.6 Кб

Font

Шрифт - определяет шрифт выводимого на Канву текста. Класс TFont включает в себя следующие свойства:

● Name - название шрифта (Arial, MS Sans Serif, Calibri и т.д.)

● Size - размер шрифта, который задается в кеглях.

● Height - тоже размер шрифта, но в отличии от Size задается уже в пикселях.

● Color - цвет шрифта.

● Style - стиль шрифта. Это свойство принимает следующие значения:

fsBold - полужирный
fsItalic - курсив
fsUnderline - подчеркнутый
fsStrikeout - перечеркнутый

Задать стиль шрифта можно следующим образом:

C++
1
2
3
4
5
6
7
8
9
10
11
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Label1->Font->Style=Label1->Font->Style<<fsBold; //Делаем шрифт полужирным
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Label1->Font->Style=Label1->Font->Style>>fsBold;  //Убираем полужирность
}
//---------------------------------------------------------------------------

Вот так можно делать, если нужно указать сразу несколько стилей:

C++
1
2
3
4
5
6
7
8
9
10
11
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Label1->Font->Style=Label1->Font->Style<<fsBold<<fsItalic; //Теперь шрифт полужирный и написан курсивом
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Label1->Font->Style=Label1->Font->Style>>fsItalic; //Убираем курсив, оставив только полужирность
}
//---------------------------------------------------------------------------

PenPos

PenPos - переменная, типа TPoint, в которой хранится текущее положение пера на канве. Начальное значение x=0, y=0. Изменять положение пера можно при помощи функции MoveTo:

C++
1
Canvas->MoveTo(x,y);

или следующим образом:

C++
1
Canvas->PenPos=TPoint(x,y);

Pixels
Свойство Pixels предоставляет доступ к отдельно взятому пикселю канвы. Цвет левого верхнего пикселя канвы имеет координаты (0,0).
Чтобы получить доступ к этому пикселю достаточно прописать следующий код:

C++
1
Canvas->Pixels[0][0];

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

C++
1
Canvas->Pixels[X][Y];

Где (X,Y) - координаты нужно пикселя.

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

C++
1
Canvas->Pixels[X][Y]=Color;

Где Color - цвет, который мы хотим задать этому пикселю (допустим, clRed, clGreen, clBlue и т.п.).

@NiTan · 04.04.2011, 18:20 **[ТС]**

Небольшой FAQ по классу TCanvas

Как вывести текст на канву под заданным углом?

C++
1
2
3
4
5
6
7
TLogFont f;
f.lfEscapement=90*10; //Угол вывода
 
 Canvas->Font->Handle = CreateFontIndirect(&f);
 
 
 Canvas->TextOutA(25,100,"Test----");  //Что за текст и в каком месте канвы его мы выводим

Как очистить канву?

Существует не один способ очистить канву. Если Вам нужно очистить канву формы, то можете воспользоваться следующими функциями:

C++
1
2
 PatBlt(Canvas->Handle,0,0,Width,Height, WHITENESS); // Закрашивает всю форму в белый цвет
   InvalidateRect(Handle,NULL,1); // Полностью очищает канву формы

Также можно закрашивать канву каким-то определенным цветом, тем самым очищая ее (если, допустим, нужно очистить канву компонента TImage):

C++
1
Image1->Canvas->FillRect(Image1->Canvas->ClipRect);

Как загрузить нестандартный шрифт из файла?

Сообщение от sh4d°_°ff

C++
1
2
3
4
5
6
7
8
int i = AddFontResourceEx("EccentricStd.ttf", FR_PRIVATE, NULL); //EccentricStd.ttf - мой шрифт
 //нестандартный, красивый
        if (i!=0)
{
        SendMessage(HWND_BROADCAST, WM_FONTCHANGE, 0, 0); // сообщить о шрифте
        AnsiString i = "EccentricStd"; //название шрифта
        Edit1->Font->Name=i;
        Edit1->Text="Test Sting"; //тест

Как повернуть изображение?

Повернуть Image

Как вывести многострочный текст на канву?

Способ №1:

C++
1
2
for(int i=0;i<RichEdit1->Lines->Count;i++)
        Form1->Canvas->TextOut(10,i*20,Memo1->Lines->Strings[i]);

Способ №2:

C++
1
2
3
HDC hdc = GetDC(Form1->Handle);
DrawText(hdc, RichEdit1->Text.c_str(), RichEdit1->Text.Length(), &TRect(0,0,Form1->Width,Form1->Height), DT_LEFT);
ReleaseDC(Form1->Handle,hdc);

cpp_developer · 11.05.2013, 20:46

Иллюстрированный самоучитель по C++ Builder - Графика. Canvas.

Комментарий модератора

19.07.2023 Ссылка за 10 лет, увы, стала неактуальной

Новые блоги и статьи Все статьи Все блоги /
Модель микоризы: классовый агентный подход 3 anaschu 06.01.2026 aa0a7f55b50dd51c5ec569d2d10c54f6/ O1rJuneU_ls https:/ / vkvideo. ru/ video-115721503_456239114	Owen Logic: О недопустимости использования связки «аналоговый ПИД» + RegKZR ФедосеевПавел 06.01.2026 Owen Logic: О недопустимости использования связки «аналоговый ПИД» + RegKZR ВВЕДЕНИЕ Введу сокращения: аналоговый ПИД — ПИД регулятор с управляющим выходом в виде числа в диапазоне от 0% до. . .	Модель микоризы: классовый агентный подход 2 anaschu 06.01.2026 репозиторий https:/ / github. com/ shumilovas/ fungi ветка по-частям. коммит Create переделка под биомассу. txt вход sc, но sm считается внутри мицелия. кстати, обьем тоже должен там считаться. . . .	Расчёт токов в цепи постоянного тока igorrr37 05.01.2026 / * Дана цепь постоянного тока с сопротивлениями и напряжениями. Надо найти токи в ветвях. Программа составляет систему уравнений по 1 и 2 законам Кирхгофа и решает её. Последовательность действий:. . .
Новый CodeBlocs. Версия 25.03 palva 04.01.2026 Оказывается, недавно вышла новая версия CodeBlocks за номером 25. 03. Когда-то давно я возился с только что вышедшей тогда версией 20. 03. С тех пор я давно снёс всё с компьютера и забыл. Теперь. . .	Модель микоризы: классовый агентный подход anaschu 02.01.2026 Раньше это было два гриба и бактерия. Теперь три гриба, растение. И на уровне агентов добавится между грибами или бактериями взаимодействий. До того я пробовал подход через многомерные массивы,. . .	Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Programma_Boinc 28.12.2025 Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Налог на собак: https:/ / ********/ gallery/ V06K53e Финансовый отчет в Excel: https:/ / ********/ gallery/ bKBkQFf Пост отсюда. . .	Кто-нибудь знает, где можно бесплатно получить настольный компьютер или ноутбук? США. Programma_Boinc 26.12.2025 Нашел на реддите интересную статью под названием Anyone know where to get a free Desktop or Laptop? Ниже её машинный перевод. После долгих разбирательств я наконец-то вернула себе. . .