Home

Les Outils GDI+

 

Le Pen

 

Introduction

L'outil le plus simple que vous pouvez utiliser est la plume. La bibliothèque de GDI + fournit un stylet via la classe Pen.

  

La Création d'une plume

Pour obtenir une plume, vous pouvez déclarer une variable de type Pen utilisant les constructeurs de sa classe.

Les Caractéristiques d'une plume

 

La couleur d'une plume

Le principal élément d'information que vous devez spécifier sur un stylet est sa couleur. Pour le faire, vous pouvez utiliser le constructeur suivant :

public Pen(Color color);

Voici un exemple :

using System;  
using System.Drawing;  
using System.Windows.Forms;    
 
 
public class Exercise : Form  
{      
	 public Exercise()      
	 {          
		 InitializeComponent();      
	 }        
 
 
	 void InitializeComponent()      
	 {          
		Paint += new PaintEventHandler(Exercise_Paint);      
	 }        
 
 
	 private void Exercise_Paint(object sender, PaintEventArgs e)      
	 {          
		 Pen pnBorder;          
		 Color clr = Color.Violet;          
		 pnBorder = new Pen(clr);      
	 }  
}    
 
 
public class Program  
{      
	 public static int Main()      
	 {          
		 Application.Run(new Exercise());            
 
 
		 return 0;      
	 }  
}

Au lieu de la première déclaration d'une variable de couleur, vous pouvez définir directement la couleur dans le constructeur.

Si vous souhaitez simplement créer une plume régulière dont la seule caractéristique connue serait sa couleur, l'espace de noms System.Drawing fournit la classe Pens. Le principal et en fait seulement, le ròle de la classe Pens consiste à définir un stylo simple et de ne spécifier que sa couleur. Pour rendre cela possible, la classe Pens est dotée uniquement de propriétés statiques qui représente chacun le nom d'une couleur. Les noms sont ceux de couleurs courantes (telles que rouge, vert, bleu, jaune, violet, etc), les couleurs utilisées dans les pages web (comme LightBlue ou DarkGreen), les couleurs définies dans Microsoft Windows (telles que ActiveBorder, AppWorkspace ou ButtonFace, etc.) et bien d'autres. Lorsque vous accédez à une propriété de plumes, elle produit un objet Pen. Cela signifie que vous pouvez accéder à un stylet pour initialiser une variable de plume. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		 pnBorder = Pens.Lavender;  
}

Si vous avez déjà créé un stylo, pour modifier sa couleur, vous pouvez affecter le nom de la couleur souhaitée ou la valeur de la couleur à la propriété Pen.Color.

La largeur d'une plume

La plus simple des plume est destinée à tracer une ligne métallique. Voici un exemple d'une ligne tracée avec un stylet simple :

Line


Un stylo est dit simple s'il a une largeur de 1 pixel. Pour vous donner la possibilité de soutenir ou de modifier la largeur d'un stylo, la classe de plume est équipée d'une propriété width.

Lors de la création d'un stylo, pour spécifier width, vous pouvez utiliser le constructeur suivant :

public Pen(Color color, float width);

Tandis que le premier argument représente la couleur, comme nous l'avons vu dans la section précédente, le second argument spécifie la largeur, qui doit être une valeur en virgule flottante. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		 Pen pnBorder = new Pen(Color.Tomato, 5.0F);  
}

Si vous avez déjà défini un stylo et que vous souhaitez modifier sa largeur, la classe Pen fournit la propriété Width. L'utilisation de cette propriété, pour modifier la largeur d'un stylo, attribuer un nombre à virgule flottante a sa propriété width. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		 Pen pnBorder = new Pen(Color.Brown);          
		 // Do something, if necessary          
		 pnBorder.Width = 3.00F;          
		 // Do something, if necessary  
}

De la même façon, vous pouvez modifier, augmenter ou diminuer la largeur d'une plume aussi souvent que vous le souhaitez. Voici des exemples :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		Pen pnBorder = new Pen(Color.Brown);          
		// Do something, if necessary          
		pnBorder.Width = 3.00F;          
		// Do something, if necessary          
		pnBorder.Width = 6.00F;          
		// Do something, if necessary          
		pnBorder.Width = 12.00F;          
		// Do something, if necessary          
		pnBorder.Width = 26.00F;          
		// Do something, if necessary          
		pnBorder.Width = 44.00F;          
		// Do something, if necessary  
}

Nous pouvons obtenir le résultat suivant :


Si un stylo a déjà été défini et vous souhaitez connaìtre sa largeur, obtenez la valeur de sa propriété Width.

Le début et la fin en capitales

Si vous utilisez un stylet avec une petite largeur, comme 1 pixel, vous ne remarquerez peut-être pas comment une ligne tracée avec elle démarre mais avec un stylet considérablement large, vous remarquerez qu'elle commence par une plate forme. Une alternative consiste à démarrer rond, carré ou triangle. Cela est dénommé le cap de départ.

Pour prendre en charge la forme d'une ligne de départ, la classe de plume est équipée d'une propriété nommée StartCap. La propriété Pen.StartCap est basée sur l'énumération LineCap dont les membres sont : AnchorMask, ArrowAnchor, personnalisée, DiamondAnchor, écran plat, NoAnchor, cycle, RoundAnchor, Square, SquareAnchor et triangle. Pour spécifier le chapeau de début, affectez le membre souhaité de LineCap à la propriété StartCap de la plume. Voici des exemples :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		Pen pnBorder = new Pen(Color.Brown);          
		pnBorder.Width = 12.00F;          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.AnchorMask;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.DiamondAnchor;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.Flat;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.NoAnchor;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.Round;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.Square;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.SquareAnchor;          
		// Do something, if necessary          
		pnBorder.StartCap = System.Drawing.Drawing2D.LineCap.Triangle;          
		// Do something, if necessary  
}

Ceux-ci peuvent produire les résultats suivants :


Si aucun des membres de l'énumération LineCap disponible ne vous convient, vous pouvez définir une casquette personnalisée à l'aide de la classe CustomStartCap.

Vous pouvez également contrôler le cap de la fin d'une ligne. Pour cela, la classe Pen est équipée d'une propriété nommée EndCap qui est également basée sur l'énumération LineCap avec la même valeur. à l'aide d'une combinaison des caps de début et de fin, vous pouvez contrôler comment une ligne commence et comment elle se termine. Si aucun des membres de l'énumération LineCap disponible ne vous convient, vous pouvez définir une casquette personnalisée à l'aide de la classe CustomEndCap.

Les Formes régulières

 

Les Rectangles et les carrés

Un rectangle est une figure géométrique faite des quatre còtés qui composent les quatre angles droits. Pour dessiner un rectangle, vous pouvez spécifier la valeur de rectangle qui l'entoure, ou vous pouvez définir son emplacement et ses dimensions. Pour dessiner un rectangle qui est entouré d'une valeur de Rectangle, vous pouvez utiliser la version suivante de la méthode Graphics.DrawRectangle() :

public void DrawRectangle(Pen pen, Rectangle rect);

N'oubliez pas qu'un tel objet rectangle peut être illustré comme suit :

Après avoir défini une variable rectangle, vous pouvez la transmettre à la méthode. Voici un exemple :

using System;  
using System.Drawing;  
using System.Windows.Forms;    
 
 
public class Exercise : Form  
{      
 
 
	public Exercise()      
	{          
		InitializeComponent();      
	
	}        
 
 
	void InitializeComponent()      
	{          
		Paint += new PaintEventHandler(Exercise_Paint);      
	}        
 
 
	private void Exercise_Paint(object sender, PaintEventArgs e)      
	{          
		Pen penCurrent = new Pen(Color.Red);          
		Rectangle Rect = new Rectangle(20, 20, 248, 162);            
 
 
		e.Graphics.DrawRectangle(penCurrent, Rect);      
	}  
}    
 
 
public class Program  
{      
	public static int Main()      
	{          
		Application.Run(new Exercise());            
 
 
		return 0;      
	}  
}

N'oubliez pas que vous pouvez également définir Pen ou un objet Rectangle dans les parenthèses de la méthode :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		e.Graphics.DrawRectangle(new Pen(Color.Red),                     
				   new Rectangle(20, 20, 248, 162));  
}

Cela donnerait :

A Rectangle Drawn From a Rectangle Value


Il est (très) important de se rappeler que le troisième argument du Rectangle représente sa valeur width (et non sa droite) et le quatrième argument représente sa valeur height (et pas son bas). C'est un fait déroutant pour ceux qui ont programmé dans GDI : GDI + définit un Rectangle différemment de GDI. En fait, pour déterminer l'emplacement et les dimensions d'un rectangle pour dessiner, la classe Graphics fournit les versions suivantes de la méthode DrawRectangle() :

public      
	void DrawRectangle(Pen pen,  		      
			   int x,  		      
			   int y,  		      
			   int width,  		      
			   int height);     
	void DrawRectangle(Pen pen,  		      
			   float x,  		      
			   float y,  		      
			   float width,  		      
			   float height);

Cette fois, le rectangle est représenté par son emplacement avec un point (x, y) et ses dimensions avec l'argument de la Largeur et la hauteur. Cela peut être illustré dans un repère de Windows comme suit :

Rectangle


Sur cette base, le rectangle antérieur peut également être tiré avec les éléments suivants :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		 e.Graphics.DrawRectangle(new Pen(Color.Red), 20, 20, 248, 162);  }

Un carré est un rectangle dont les quatre còtés sont égaux.

ApplicationApplication : Dessin d'un rectangle

  1. Démarrez Microsoft Visual c#
  2. Créez une nouvelle Application Windows Forms nommée WeeklySales1
  3. Concevez le formulaire comme suit :
     

    Weekly Sales

    contrôle

    Nom

    Texte

    étiquette

    Label

     

    Lundi

    étiquette

    Label

     

    Mardi

    étiquette

    Label

     

    Mercredi

    étiquette

    Label

     

    Jeudi

    étiquette

    Label

     

    Vendredi

    TextBox

    TextBox

    txtMonday

    0

    TextBox

    TextBox

    txtTuesday

    0

    TextBox

    TextBox

    txtWednesday

    0

    TextBox

    TextBox

    txtThursday

    0

    TextBox

    TextBox

    txtFriday

    0

    Bouton

    Button

    Générer

    btnGenerate

  4. Double-cliquez sur une zone libre de l'écran et modifiez le fichier comme suit :
    using System;
        using System.Collections.Generic;
        using System.ComponentModel;
        using System.Data;
        using System.Drawing;
        using System.Linq;
        using System.Text;
        using System.Windows.Forms;
    
        namespace WeeklySales1
        {
      	public partial class Form1 : Form      
    	{          
    		private Graphics graphDrawingArea;          
    		private Bitmap bmpDrawingArea;            
     
    		public Form1()          
    		{              
    			InitializeComponent();          
    		}            
     
    		private void Form1_Load(object sender, EventArgs e)          
    		{              
    			bmpDrawingArea = new Bitmap(Width, Height);              
    			graphDrawingArea = Graphics.FromImage(bmpDrawingArea);          
    		}      
    	}  
    }
  5. Retournez à l'écran et cliquez sur une zone vide dessus. Dans la fenêtre Propriétés, cliquez sur le bouton événements Events
  6. Double-cliquez sur le champ de la peinture et exécutez son événement comme suit :
    private void Form1_Paint(object sender, PaintEventArgs e)  
    {              
    	e.Graphics.DrawImage(bmpDrawingArea, 0, 0);  
    }
  7. Retournez à l'écran et cliquez deux fois sur le bouton générer
  8. Mettez en œuvre l'événement comme suit :
    private void btnGenerate_Click(object sender, EventArgs e)  
    {          
    	int monday= 0,               
    		tuesday   = 0,               
    		wednesday = 0,               
    		thursday  = 0,               
    	    friday    = 0;            
     
    	try          
    	{                 
     		monday = int.Parse(txtMonday.Text) / 100;          
    	}          
    	catch (FormatException)          
    	{                  
    		MessageBox.Show("Invalid sales on Monday");                  
    				txtMonday.Text = "0";          
    	} 
    			           
    	try          
    	{                  
    		tuesday = int.Parse(txtTuesday.Text) / 100;          
    	}          
    	catch (FormatException)          
    	{                  
    		MessageBox.Show("Invalid sales on Tuesday");                  
    				txtTuesday.Text = "0";          
    	}            
     
    	try          
    	{                  
    		wednesday = int.Parse(txtWednesday.Text) / 100;          
    	}          
    	catch (FormatException)          
    	{                  
    		MessageBox.Show("Invalid sales on Wednesday");                  
    		txtWednesday.Text = "0";          
    	}            
     
    	try          
    	{                  
    		thursday = int.Parse(txtThursday.Text) / 100;          
    	}          
    	catch (FormatException)          
    	{                  
    		MessageBox.Show("Invalid sales on Thursday");                  
    		txtThursday.Text = "0";          
    	}            
     
    	try          
    	{                  
    		friday = int.Parse(txtFriday.Text) / 100;          
    	}          
    	catch (FormatException)          
    	{                  
    		MessageBox.Show("Invalid sales on Friday");                  
    		txtFriday.Text = "0";          
    	}            
     
    	graphDrawingArea.Clear(this.BackColor);            
     
    	graphDrawingArea.DrawRectangle(new Pen(Color.Red),                              
    					this.txtMonday.Left + 10,                              
    					300 - monday,                              
    					40, monday);          
    			graphDrawingArea.DrawRectangle(new Pen(Color.Blue),                              
    					this.txtTuesday.Left + 10,                              
    					300 - tuesday,                              
    					40, tuesday);          
    			graphDrawingArea.DrawRectangle(new Pen(Color.Fuchsia),                              
    					this.txtWednesday.Left + 5,                              
    					300 - wednesday,                              
    					40, wednesday);          
    			graphDrawingArea.DrawRectangle(new Pen(Color.Brown),                              
    					this.txtThursday.Left + 5,                              
    					300 - thursday,                              
    					40, thursday);          
    			graphDrawingArea.DrawRectangle(new Pen(Color.Turquoise),                              
    					this.txtFriday.Left + 5,                              
    					300 - friday, 40, friday);            
    			
    			graphDrawingArea.DrawRectangle(new Pen(Color.Black),                              
    					10, 300, Width - 30, 1);          
    			Invalidate();  
    }
  9. Exécutez l'application et testez le formulaire
     
  10. Après utilisation, fermez le formulaire.

Une série de rectangles

La méthode DrawRectangle() est utilisée pour dessiner un rectangle. Si vous prévoyez d'attirer de nombreux rectangles, vous pouvez procéder en une seule étape à l'aide de la méthode Rectangles() Graphics.Draw. Il existe deux versions dont les syntaxes sont :

public void DrawRectangles(Pen pen,  Rectangle[] rects);
public void DrawRectangles(Pen pen,  RectangleF[] rects);

Cette méthode nécessite un tableau de valeurs de Rectangle ou RectangleF. Lors de l'exécution, il dessine les rectangles individuels à l'aide de chaque membre du tableau comme son propre rectangle. Voici un exemple :

private void Exercise_Paint(object sender,  PaintEventArgs e)
{
Pen penCurrent = new Pen(Color.Red);
Rectangle[] Rect = { new Rectangle(20, 20, 120, 20),
new Rectangle(20, 50, 120, 30),
new Rectangle(20, 90, 120, 40),
new Rectangle(20, 140, 120, 60) };
        e.Graphics.DrawRectangles(penCurrent, Rect);
}

Cela donnerait :

Rectangles

 

ApplicationApplication : Dessin d'une série de rectangles

  1. Démarrez une nouvelle Application Windows nommée YearlySales1
  2. Concevez le formulaire comme suit :
     

     


    Controle

    Name

    Text

    GroupBox

    GroupBox

     

    Current Year's Sales

    Label

    Label

     

    1st Qtr

    Label

    Label

     

    2nd Qtr

    Label

    Label

     

    3rd Qtr

    Label

    Label

     

    4th Qtr

    TextBox

    TextBox

    txtCurrentQtr1

    0

    TextBox

    TextBox

    txtCurrentQtr2

    0

    TextBox

    TextBox

    txtCurrentQtr3

    0

    TextBox

    TextBox

    txtCurrentQtr4

    0

    Button

    Button

    Close

    btnClose

    GroupBox

    GroupBox

     

    Previous Year's Sales

    étiquette

    Label

     

    1st Qtr

    Label

    Label

     

    2nd Qtr

    Label

    Label

     

    3rd Qtr

    Label

    Label

     

    4th Qtr

    TextBox

    TextBox

    txtPreviousQtr1

    0

    TextBox

    TextBox

    txtPreviousQtr2

    0

    TextBox

    TextBox

    txtPreviousQtr3

    0

    TextBox

    TextBox

    txtPreviousQtr4

    0

    Button

    Button

    Generate

    btnGenerate

    Label

    Label

     

    _________ Legend_________

    Label

    Label

    lblCurYear

    This Year's Sales.

    Label

    Label

    lblLastYear

    Last Year's Sales

  3. Double-cliquez sur une zone libre de l'écran et modifiez le fichier comme suit
    using System;  
    using System.Collections.Generic;  
    using System.ComponentModel;  
    using System.Data;  
    using System.Drawing;  
    using System.Linq;  
    using System.Text;  
    using System.Windows.Forms;    
     
     
    namespace YearlySales1  
    {      
     
    	public partial class Form1 : Form     
    		{          
    	Graphics graphDrawingArea;         
    	Bitmap bmpDrawingArea;            
     
    	public Form1()          
    	{              
    		InitializeComponent();          
    	}            
     
    	private void Form1_Load(object sender, EventArgs e)          
    	{              
    		bmpDrawingArea = new Bitmap(Width, Height);              
    		graphDrawingArea = Graphics.FromImage(bmpDrawingArea);          
    	}      
        }  
    }
  4. Retournez à l'écran et cliquez sur une zone vide
  5. Dans la fenêtre Propriétés, cliquez sur le bouton Events Events
  6. Double-cliquez sur le champ de la peinture et exécutez son événement comme suit :
    private void Form1_Paint(object sender, PaintEventArgs e)  
    {             
     			e.Graphics.DrawImage(bmpDrawingArea, 0, 0);  
    }
  7. Retournez à l'écran et cliquez deux fois sur le bouton générer
  8. Mettez en œuvre l'événement comme suit :
    private void btnGenerate_Click(object sender, EventArgs e)  
    {              
    	int curQtr1 = 0,                  
    		curQtr2 = 0,                  
    		curQtr3 = 0,                  
    		curQtr4 = 0;              
    	int prvQtr1 = 0,                  
    		prvQtr2 = 0,                  
    		prvQtr3 = 0,                  
    		prvQtr4 = 0;                
    				
    	// Retrieve the values of the current year's sales              
    	try              
    	{                  
    		curQtr1 = int.Parse(txtCurrentQtr1.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the first quarter");                  
    	   	curQtr1 = 0;              
    	}                
     
    	try              
    	{                  
    		curQtr2 = int.Parse(txtCurrentQtr2.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the second quarter");                  
    		curQtr2 = 0;              
    	}                
    				
    	try              
    	{                  
    		curQtr3 = int.Parse(txtCurrentQtr3.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the third quarter");                  
    		curQtr3 = 0;              
    	}                
     
    	try              
    	{                  
    		curQtr4 = int.Parse(txtCurrentQtr4.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the fourth quarter"
    	);                  
    	
    	curQtr4 = 0;              
    	}                
     
     
    	// Create an array of Rectangle objects for the current year              
    	Rectangle[] rectCurrentYear =              
    	{                  
    		new Rectangle(txtCurrentQtr1.Left+20,  	                          
    				 380-curQtr1, 40, curQtr1),                  
    		new Rectangle(txtCurrentQtr2.Left+20,  	                          
    				380-curQtr2, 40, curQtr2),                  
    		new Rectangle(txtCurrentQtr3.Left+20,  	                          
    				380-curQtr3, 40, curQtr3),                  
    		new Rectangle(txtCurrentQtr4.Left+20,  	                          
    				380-curQtr4, 40, curQtr4)              
    	};                
     
    	// Retrieve the values of last year's sales              
    	try              
    	{                  
    		prvQtr1 = int.Parse(txtPreviousQtr1.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the third quarter");                  
    		prvQtr1 = 0;              
    	}                
     
    	try              
    	{                  
    		prvQtr2 = int.Parse(txtPreviousQtr2.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the third quarter");                  
    		prvQtr2 = 0;              
    	}                
     
    	try              
    	{                  
    		prvQtr3 = int.Parse(txtPreviousQtr3.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the third quarter");                  
    		prvQtr3 = 0;              
    	}                
     
    	try              
    	{                  
    		prvQtr4 = int.Parse(txtPreviousQtr4.Text) / 100;              
    	}              
    	catch (FormatException)              
    	{                  
    		MessageBox.Show("Invalid value for the third quarter");                  
    		prvQtr4 = 0;              
    	}                
     
    	// Create an array of Rectangle objects for the previous year              
    	Rectangle[] rectPreviousYear =              
    	{                  
    		new Rectangle(txtPreviousQtr1.Left+30,  	                         
    				380-prvQtr1, 40, prvQtr1),                  
    		new Rectangle(txtPreviousQtr2.Left+30,  	                          
    				380-prvQtr2, 40, prvQtr2),                  
    		new Rectangle(txtPreviousQtr3.Left+30,  	                          
    				380-prvQtr3, 40, prvQtr3),                  
    		new Rectangle(txtPreviousQtr4.Left+30,  	                          
    				380-prvQtr4, 40, prvQtr4)              
    	};                
     
    	// In case the user has changed the values,              
    	// erase the previous chart              
    	graphDrawingArea.Clear(BackColor);                
     
    	// Draw the chart for the previous year first to send it back              
    	graphDrawingArea.DrawRectangles(new Pen(Color.Blue),                               
    					 rectPreviousYear);             
    	// Draw the chart for the current year in front              
    	graphDrawingArea.DrawRectangles(new Pen(Color.Red),                               
    					 rectCurrentYear);                
     
    	// Draw the small rectangles of the legend              
    	graphDrawingArea.DrawRectangle(new Pen(Color.Blue),                              
    					lblCurYear.Left - 30,                              
    					lblCurYear.Top, 14, 10);              
    	graphDrawingArea.DrawRectangle(new Pen(Color.Red),                              
    					lblLastYear.Left - 30,                              
    					lblLastYear.Top, 14, 10);                
     
    	graphDrawingArea.DrawRectangle(new Pen(Color.Black),                               
    					 25, 380, Width - 220, 1);              
    	Invalidate();  
    }
  9. Retournez à l'écran
  10. Cliquez deux fois sur le bouton Fermer et mettez en œuvre son événement Click comme suit :
    private void btnClose_Click(object sender, EventArgs e)
    {              
    	Close();  
    }
  11. Exécutez l'application et testez le formulaire
     
  12. Après utilisation, fermez le formulaire

Les Ellipses et les cercles

Une ellipse est une ligne continue fermée dont les points sont positionnés de manière à ce que deux points opposés l'un en face de l'autre aient exactement la même distance d'un point central. Il peut être illustré comme suit :

Ellipse


Puisqu'une ellipse peut être logée dans un rectangle, dans la programmation GDI +, une ellipse est définie par rapport à un rectangle, qu'il ajusterait. Pour dessiner une ellipse, vous pouvez utiliser la méthode Graphics.DrawEllipse() qui vient en quatre versions dont les syntaxes sont :

public void DrawEllipse(Pen pen,  		     
			Rectangle rect);  
public void DrawEllipse(Pen pen,  		     
			RectangleF rect);  
public void DrawEllipse(Pen pen,  		     
			int x,  		     
			int y,  		     
			int width,  		     
			int height);  
public void DrawEllipse(Pen pen,  		     
			float x,  		     
			float y,  		     
			float width,  		     
			float height);

Les arguments de cette méthode jouent le même ròle que ceux de la méthode Graphics.DrawRectangle() :

Ellipse 2

Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Red);            
 
	e.Graphics.DrawEllipse(penCurrent, new Rectangle(20, 20, 226, 144));  
}

Ellipse

ApplicationApplication : Dessin d'un cercle

  1. Démarrez une nouvelle Application Windows nommée RotatingCircles1
  2. Double-cliquez sur le milieu de l'écran et modifiez le fichier comme suit :
    using System;  
    using System.Collections.Generic;  
    using System.ComponentModel;  
    using System.Data;  
    using System.Drawing;  
    using System.Linq;  
    using System.Text;  
    using System.Windows.Forms;    
     
     
    namespace RotatingCircles1  
    {      
     
     
    	public partial class Form1 : Form      
    	{          
    		Graphics graphDrawingArea;          
    		Bitmap bmpDrawingArea;            
     
     
    	public Form1()          
    	{              
    		InitializeComponent();          
    	}            
     
     
    	private void Form1_Load(object sender, EventArgs e)          
    	{              
    		bmpDrawingArea = new Bitmap(Width, Height);              
    		graphDrawingArea = Graphics.FromImage(bmpDrawingArea);          
    	}      
    }  
    }
  3. Dans la section des composantes de la boìte à outils, cliquez sur timer et cliquez sur le formulaire.
  4. Dans la fenêtre Propriétés, modifiez les valeurs suivantes :
    Enabled : true
    Interval : 20
  5. Dans le cadre de l'écran, double-cliquez sur l'objet timer1 et apportez les modifications suivantes :
    using System;  
    using System.Collections.Generic;  
    using System.ComponentModel;  
    using System.Data;  
    using System.Drawing;  
    using System.Linq;  
    using System.Text;  
    using System.Windows.Forms;    
     
     
    namespace RotatingCircles1  
    {      
        public partial class Form1 : Form      
        {          
     
    	    	Graphics graphDrawingArea;         
    		    Bitmap bmpDrawingArea;          
             static int mainRadius = 10;          
             static int smallRadius = 5;          
             static bool isMax;          
             static bool smallRadiusMax;            
     
     
             public Form1()          
             {              
                 InitializeComponent();          
             }            
     
     
             private void Form1_Load(object sender, EventArgs e)          
             {              
                 bmpDrawingArea = new Bitmap(Width, Height);              
                 graphDrawingArea = Graphics.FromImage(bmpDrawingArea);          
             }            
     
     
             void DrawCentralCircle(int CenterX, int CenterY, int Radius)          
             {              
                 int start = CenterX - Radius;              
                 int end = CenterY - Radius;              
                 int diam = Radius * 2;                
     
     
                 graphDrawingArea.DrawEllipse(new Pen(Color.Blue),                            
                               start, end, diam, diam);          
             }            
     
     
             void DrawCornerCircle(int CenterX, int CenterY, int Radius)          
             {              
                 int start = CenterX - Radius;              
                 int end = CenterY - Radius;              
                 int diam = Radius * 2;                
     
     
                 graphDrawingArea.DrawEllipse(new Pen(Color.Red),                            
                               start, end, diam, diam);          
              }            
     
     
              private void timer1_Tick(object sender, EventArgs e)          
              {              
                  Graphics graph = Graphics.FromHwnd(this.Handle);                
     
     
                  int centerX = ClientRectangle.Width / 2;              
                  int centerY = ClientRectangle.Height / 2;                
     
     
                  if (isMax == true)                  
                     mainRadius--;              
                  else                  
                     mainRadius++; 
                   
                  if (mainRadius > (ClientRectangle.Height / 2))                  
                     isMax = true;              
     
     
                  if (mainRadius < 10)                  
                     isMax = false;   
                 
                  if (smallRadiusMax == true)                  
                     smallRadius--;              
                  else                  
                     smallRadius++;                
     
                  if (smallRadius > 240)                  
                      smallRadiusMax = true;              
                  if (smallRadius < 5)                  
                      smallRadiusMax = false;                
     
                  // Central              
                  DrawCentralCircle(centerX, centerY, mainRadius);              
                  // Top-Left              
                  DrawCornerCircle(centerX / 2, centerY / 2, smallRadius);              
                  // Top-Right              
                  DrawCornerCircle(centerX + (centerX / 2), centerY / 2, smallRadius);              
                  // Bottom-Left              
                  DrawCornerCircle(centerX / 2, centerY + (centerY / 2), smallRadius);              
                  // BottomRight              
                  DrawCornerCircle(centerX + (centerX / 2),                       
                  centerY + (centerY / 2), smallRadius);                
                  graph.DrawImage(bmpDrawingArea, 0, 0);          
            }      
        }  
    }
  6. Exécutez l'application pour afficher le résultat.
  7. Fermez l'écran.

Les Lignes

 

Introduction

Une ligne est une jonction de deux points. Cela signifie qu'une ligne a un début et une fin :

Line Definition


Le début et la fin sont deux points distincts. Sur cette base, une ligne est représentée par quatre nombres représentant ses valeurs sur les axes cartésiens ou avec deux valeurs Point. Pour dessiner une ligne, la classe Graphics est équipée de la méthode DrawLine() surchargée suivante :

public void DrawLine(Pen pen,  		  
					Point pt1,  		  
					Point pt2);  
public void DrawLine(Pen pen,  		  
					PointF pt1,  		  
					PointF pt2);  
public void DrawLine(Pen pen,  		  
					int x1,  		  
					int y1,  		  
					int x2,  		  
					int y2);  
public void DrawLine(Pen pen,  		  
					float x1,  		  
					float y1,  		  
					float x2,  		  
					float y2);

Si la ligne est représentée par les nombres naturels, son origine peut être spécifiée comme un Point pt1 et sa fin serait représentée avec un Point pt2. Si la ligne est tracée à l'aide des numéros flottants, vous pouvez démarrer à un PointF pt1 et mettre fin à un autre PointF pt2. Dans le cas contraire, vous pouvez spécifier le point de départ avec les coordonnées (x 1, y1) et la fin serait représentée avec les coordonnées (x 2, y2). Le même type de ligne peut être dessiné à l'aide de valeurs décimales à partir de coordonnées (x 1, y1) aux coordonnées (x 2, y2).

Voici un exemple qui dessine trois lignes :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		 Pen penCurrent = new Pen(Color.Red);          
		 e.Graphics.DrawLine(penCurrent, 20, 20, 205, 20);            
 
 
		 penCurrent = new Pen(Color.Green, 3.50F);          
		 e.Graphics.DrawLine(penCurrent, 40, 40, 225, 40);            
 
 
		 penCurrent = new Pen(Color.Blue, 7.25F);          
		 e.Graphics.DrawLine(penCurrent, 30, 60, 215, 60);  
}

Line

Une série de lignes

La méthode DrawLine() ci-dessus est utilisée pour dessiner une ligne. Si vous avez l'intention d'attirer un groupe de lignes à la fois, vous pouvez utiliser la méthode de Lines() Graphics.Draw. Il est surchargé avec deux versions comme suit :

public  void DrawLines(Penpen, Point[] points);  
public void DrawLines(Penpen, PointF[] points);

Pour utiliser cette méthode, vous devez tout d'abord définir un tableau Point pour les nombres naturels qui représentent les coordonnées cartésiennes ou PointF pour des nombres. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	 Point[] Coordinates = { new Point(20, 10), new Point(205, 20),                                  
				new Point(40, 40), new Point(225, 60),                                  
				 new Point(30, 80), new Point(215, 100) };           
 
	Pen penCurrent = new Pen(Color.Red);          
	e.Graphics.DrawLines(penCurrent, Coordinates);  
}

Cela donnerait :

Drawing Lines

Les Polygones

Un polygone est une série de lignes connectées avec la forme entière en étant fermée. En d'autres termes, un polygone est défini par un groupe de lignes afin que, à l'exception de la première ligne du groupe, le point de départ de chaque ligne soit identique à l'extrémité de la ligne précédente et le point de fin de la dernière ligne soit connecté au point de départ de la première ligne.

Pour dessiner un polygone, vous pouvez utiliser la méthode Graphics.Polygon(). Il est surchargé avec deux versions comme suit :

public void DrawPolygon(Penpen, Point[] points);  
public void DrawPolygon(Penpen, PointF[] points);

Pour utiliser cette méthode, vous pouvez tout d'abord déclarer un tableau Point ou PointF et le passer comme deuxième argument de la méthode. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{      
	 Point[] Pt = { new Point(20, 50),    		   
					new Point(180, 50),  		   
					new Point(180, 20),                     
					new Point(230, 70),  		   
					new Point(180, 120),  		   
					new Point(180, 90),         	           
					new Point(20,  90) };        
 
 
	Pen penCurrent = new Pen(Color.Red);      
	e.Graphics.DrawPolygon(penCurrent, Pt);  
}

Cela donnerait :

Polygon

 

 
 
 
 

Précédent Copyright © 2009-2011, yevol.com Suivant