C# GDI+ Programmierung (1)

Obwohl es in C++ ist, gibt es immer einige Ähnlichkeiten.

Wenn das Fenster aktualisiert wird, wird ein Paint-Ereignis generiert, daher fügen wir diesem Ereignis eine Handler-Funktion hinzu. Zeichnen Sie dann den Graphen in dieser Funktion. Dadurch wird sichergestellt, dass das gezeichnete Bild nicht aktualisiert wird,

und immer angezeigt werden kann. Der dem Paint-Ereignis entsprechende Delegat ist: public Delegate void PaintEventHandler(object sender, PaintEventArgs e);

Beginnen wir mit der einfachsten Zeichnung, dem Zeichnen einer Linie auf dem Fenster. (Erstellen einer WindowsForms-Anwendung)

öffentliche Teilklasse Form1: Form
{
public Form1()
InitializeComponent(); 🎜> //Paint-Ereignishandlerfunktion hinzufügen
this. Paint += formPaint;

}

private void formPaint(Object sender, PaintEventArgs e)
{
Graph icsgraphics = e.Graphics;
//Pinsel, Grün, 2 Pixel Breite
Pen Pen = New Pen (color.fromargb (0,255,0), 2);
// Zeichnen Sie eine Linie, zwei Punkte sind 0,0 und 100,100
GraphicsLine (pen, new Point (0 ,0), neuer Punkt (100,100));

Beispiel 2: Ein gefülltes Rechteck

Grafikgrafiken = e.Graphics;
//Blauer Pinsel

SolidBrush-Pinsel = new SolidBrush(Color.FromArgb(0, 0 , 255 ));

//Ein Rechteck

Rechteck rect = neues Rechteck(0, 0, 100, 100);

//Ein Rechteck füllen

graphics.FillRectangle(brush, rect); >

Beispiel 3: Zeichnen Sie ein PNG-Bild (PNG wird verwendet, weil es transparente Bilder anzeigen kann, GIF-Bilder haben diesen Effekt auch)

private void formPaint(Object sender, PaintEventArgs e)
{
           Grafikgraphics = e.Graphics; Bild zeigt Startposition );
}

Verwenden Sie DrawString, um Text anzuzeigen

DrawString in der Grahpics-Klasse Es gibt mehrere Überladungen, einige zeigen eine Zeichenfolge innerhalb eines Rechtecks ​​an, andere verwenden ein bestimmtes Anzeigeformat. Ich werde hier nicht auf Details eingehen.

Nur ​​die am häufigsten verwendeten werden besprochen.

Sehen Sie sich das Beispiel an, behandeln Sie das Tastatureingabezeichenereignis und zeigen Sie die eingegebenen Zeichen im Fenster an. Wie folgt:

öffentliche Teilklasse Form1: Form
{
public static String strText = "";
public Form1()
Initialize Component();
this.Paint += formPaint;
this.KeyPress += formKeyPress;

}
private void formPaint(Object sender, PaintEventArgs e)
{
Graphics Graphics = e.Graphics;
/ /Erstellen Sie ein Malpinsel Solidbrush Brush = Neuer Solidbrush (Color.fromargb (0,255,0)); // Schriftarten erstellen
FONT FONT = Neue Schriftart ("Song Style", 20F); /Zeige eine Zeichenfolge innerhalb eines Rechtecks ​​an
graphics.DrawString(strText, Schriftart, Pinsel, this.ClientRectangle);

}
private void formKeyPress(object sender, KeyPressEventArgs e)
{
strText += e.KeyChar;
//Das gesamte Fenster aktualisieren
this.Invalidate();
}
}

Es gibt auch eine Grafik s.DrawString( strText, Schriftart, Pinsel, neuer Punkt (100, 100)); Anzeigemodus, dies gibt lediglich die Startposition der Textanzeige an.

Siehe das folgende Beispiel für das Anzeigeformat:

//Zeichenfolge innerhalb eines Rechtecks ​​anzeigen

StringFormat strFormat = new StringFormat(StringFormatFlags.DirectionRightToLeft);

graphics.DrawString( strText, Schriftart, Pinsel, this.ClientRectangle,strFormat);

StringFormatFlags ist ein Aufzählungstyp. Probieren Sie es einzeln aus, um zu sehen, welches Format jedes Aufzählungsmitglied darstellt.

Als nächstes werfen wir einen Blick darauf. Welche Beziehung besteht zwischen der Standard-Ereignisbehandlungsmethode in der Form-Klasse und der von Ihnen hinzugefügten Ereignisbehandlungsmethode?

Ein Beispiel: Umgang mit Ereignissen der linken Maustaste

öffentliche Teilklasse Form1 : Form
{
private Color prBackColor;
public Form1()
InitializeComponent();
                            //Standardhintergrundfarbe des Fensters
prBackColor = this.backcolor; .Button == MouseButtons.Right)
           {
Form1 form1 = (Form1)sender;
//Hintergrundfarbe ändern
form1.BackColor = Color.FromArgb(0, 255, 0);
}
                                                                                                                                 Ereignisbehandlungsmethode starten (freigeben)
private void formMouseUp(object sender, MouseEventArgs e)
{
if(e.Button==MouseButtons.Right)
{
Form1 form1 = ( Form1)sender; Es gibt Standardmethoden zur Ereignisbehandlung. Diese Methoden sind virtuelle Methoden, die Sie überschreiben können, z. B. das Überschreiben von

protected virtual void OnMouseDown(MouseEventArgs e); OnMouseUp(MouseEventArgs e);

Auf diese Weise können Sie Mausereignisse verarbeiten, ohne eine Ereignisbehandlungsmethode hinzuzufügen. Sie können das obige Beispiel implementieren, indem Sie die Standard-Ereignisbehandlungsmethode der übergeordneten Klasse überschreiben.

Bei der Überprüfung von MSDN können wir feststellen, dass der Aufruf dieser Standardmethoden zur Ereignisbehandlung entsprechende Ereignisse auslösen kann. Wenn ich beispielsweise OnMouseDown aufrufe, kann ich das Ereignis zum Drücken der linken Maustaste auslösen, das tatsächlich die von uns hinzugefügte Ereignisverarbeitungsmethode (Delegat) ausführt. Und wir verwenden immer noch die Multicast-Delegierung, weil wir „+=“ verwenden, um die Delegationsmethode hinzuzufügen.

Wenn Sie in diesem Fall OnMouseDown überschreiben, müssen Sie die OnMouseDown-Methode der darin enthaltenen Basisklasse aufrufen,

Andernfalls wird die von uns hinzugefügte MouseDown-Methode nicht ausgeführt (falls vorhanden)

Nachdem ich das oben Gesagte weiß, möchte ich Ihnen ein praktisches Beispiel geben. Überschreiben Sie die OnPaintBackground-Methode zum Zeichnen des Hintergrunds.

öffentliche Teilklasse Form1 : Form
{
public Form1()
{
InitializeComponent();
}
//Die OnPaintBackground-Methode neu schreiben
protected override void OnPaintBackground(PaintEventArgs e)
                                                                                                                                                       FillRectangle (Brush, This.ClientRectangle); Einen weiteren Kreis zeichnen Pen Pen = New Pen (Color.FromArgb(0, 255, 0),3);
e.Graphics.DrawEllipse(pen, this.ClientRectangle);
}
}

TextureBursh-Bildpinsel

Sie können Bilder verwenden, um eine Form zu füllen, z. B. ein Rechteck oder einen Kreis. Wenn das Bild nicht groß genug ist, wird es gekachelt angezeigt.

Beispiel:

private void formPaint(Object sender, PaintEventArgs e)

{

Graphics Graphics = e.Graphics;

//Bilder erstellen Pinsel

Rechteck rect = new Rechteck(10, 10, 70, 70);

TextureBrush brush = new TextureBrush(Image.FromFile("d:\Image\345.jpg"),rect);

graphics.FillEllipse(brush , 0, 0, 200, 200);

       }

Der letzte Parameter des Konstruktors, rect, stellt dar, welcher Teil des Bildes gefüllt werden soll, 10,10 stellt die Startposition des Bildes dar (oben links). Ecke), 70, 70 stellt die Breite und Höhe dar. Achten Sie darauf, den ursprünglichen Bereich des Bildes nicht zu überschreiten. Wenn das gesamte Bild ausgefüllt ist, ist die Angabe von rect nicht erforderlich. Füllen Sie einfach einen Parameter im Konstruktor aus.

LinearGradientBursh-Linearverlaufspinsel (diese Klasse existiert im System.Drawing.Drawing2D-Namespace)

Die LinearGradientBursh-Klasse verfügt über eine Konstruktorüberladung mit vier Parametern, nämlich zwei Punkten und zwei Farben .

Diese vier Parameter legen die Farbe des Startpunkts und die Farbe des Endpunkts fest. Und Standort.

Sehen Sie sich das folgende Beispiel an:

public partial class Form1 : Form

{

public Form1()

InitializeComponent();

this.Paint += formPaint;

}
private void formPaint(Object sender, PaintEventArgs e)
{
Graphics Graphics = e.Graphics;
Linear GradientBrush lineBrush = new LinearGradientBrush(new Point(0, 0), new Punkt (50, 0),
                                                                                       Brush,this .ClientRectangle);
}
}

Der Startpunkt ist 0,0 und Der Endpunkt liegt bei 0,50. Farbverlaufssegment von Weiß nach Schwarz. Der Teil, der 50 überschreitet, beginnt wieder zu verblassen.

Genau wie bei der Verwendung von PS reicht die Verlaufsfarbe von Weiß nach Schwarz und dann wird eine Linie gezogen. Der Startpunkt ist 0,0 und der Endpunkt ist 0,50.

Wie wird es also aussehen, wenn ich den Verlaufspinsel mit diesem Attribut verwende, um ein Rechteck im Fenster zu zeichnen? Sie können es erkennen, indem Sie sich die Darstellung oben ansehen.

Zum Beispiel Graphics.FillRectangle(lineBrush, 0, 0, 100, 100);

Die Pinselfüllung dieses Rechtecks ​​ist dieselbe wie die des entsprechenden rechteckigen Bereichs des ersten Effekts .

Sie können dies auch sehen, wenn Sie die Werte des Startpunkts und Endpunkts ändern. Auf welche Weise ist es gefüllt?

Zum Beispiel wird der Startpunkt auf 0,0 und der Endpunkt auf 50,50 geändert.

private void formPaint(Object sender, PaintEventArgs e)

{

Graphics = e.Graphics;
LineBrush = new LinearGradientBrush dientBrush(new Point(0, 0), new Point( 50 , 50),
                           Color.FromArgb(255, 255, 255), Color.FromArgb(0, 0, 0)); window
graphics.FillRectangle(lineBrush, this. ClientRectangle) ;
Stift pen = new Pen(Color.FromArgb(0, 255,0));
graphics.DrawRectangle(pen, 0, 0, 50, 50);
}

Zeichnen Sie eine gefüllte Form hinein und sie wird gemäß den oben genannten Regeln angezeigt. Dieses Fenster deaktiviert die Maximierungsfunktion nicht und die Fenstergröße kann zur weiteren Beobachtung geändert werden.

Mehrere Farbverläufe

Die Klasse LinearGradientBrush verfügt über ein InterpolationColors-Attributmitglied, das mehrere Farbverläufe angeben kann. Wie die vorherigen Verläufe können sie nur auf zwei Farben beschränkt werden . Farbverlauf: Nach der Verwendung von InterpolationColors können Sie verschiedene Farbverläufe verwenden, z. B. einen Farbverlauf von Rot nach Grün und dann von Grün nach Blau.

Siehe Beispiel:

private void formPaint(Object sender, PaintEventArgs e)
{
//Erstellen Sie ein ColorBlend-Objekt und geben Sie mehrere Farbverlaufsinformationen an
ColorBlend color_blend=new ColorBlend();
//Geben Sie ein an wenige A-Farbe
            color_blend.Colors=new Color[]{Color.Red,Color.Green,Color.Blue}; 3f,2/3f,3/3f};
Rechteck rect=new Rechteck(0, 0,200,100);
//Verlaufspinsel erstellen
LinearGradientBrush brush=
new LinearGradientBrush(new Point(0 ,0),new Point(200,0),Color.White,Color.White);
 
 brush.InterpolationColors=color_blend;
 e.Graphics.FillRectangle(brush,rect);
}

Das Array color_blend.Colors gibt beispielsweise an, wie viele Farbverläufe es gibt , das Obige ist Rot, Grün und Blau, dann sollte der Farbverlauf so sein: Farbverlauf von Rot nach Grün und dann Farbverlauf von Grün nach Blau.

color_blend.Positions gibt den Farbbereich an. Wenn die Breite des obigen Rechtecks ​​​​als Ganzes 1 betrachtet wird, wird der Farbverlauf von Rot nach Grün von 0/3f bis 2/3f, also in, vervollständigt Dies

abgeschlossen, dann beträgt der Bereich des Farbverlaufs von Grün nach Blau 2/3f bis 3/3f.

Wenn Sie die Hälfte davon teilen möchten, ist es color_blend.Positions=new float[]{0/2f,1/2f,2/2f};

Weitere Artikel zum Thema C# GDI+-Programmierung (1) finden Sie auf der chinesischen PHP-Website!