Home

Accessoires Pour le Dessin

 

Le Point

 

Introduction

Tous les objets graphiques et dessins ont une caractéristique principale qui est leur emplacement. L'emplacement est la section où un objet commence. Cela est également appelé son origine, connue comme coordonnées (0, 0). Un emplacement est identifié par un point. Pour prendre en charge le concept de points, le .NET Framework fournit une structure nommée point. La structure point est définie dans l'espace de noms System.Drawing qui est un membre de la bibliothèque System.Drawing.dll.

 

Les Caractéristiques d'un point

Une des propriétés de la structure point est X, qui représente la distance horizontale du point dans le coin supérieur gauche de l'objet auquel appartient le point. Une autre propriété, Y représente la mesure verticale du point quant à l'angle supérieur gauche de l'objet auquel appartient le point. Sur cette base, un objet point peut être représenté sur le système de coordonnées de Windows comme suit :

Representation of a Point

Les deux propriétés X et Y de la structure point sont de type int. Dans certains cas, vous voudrez utiliser un nombre entier ou les caractéristiques décimales. Pour cela, le .NET Framework fournit la structure PointF. Ses propriétés X et Y sont de type float.

Nous avons mentionné qu'un point spécial nommé origine a des coordonnées (0, 0) :

The Origin of the Windows default coordinate system

Pour indiquer que c'est là le point dont vous parlez, le Point et les structures PointF sont équipés d'un champ statique nommé Empty. Dans cette propriété, les deux valeurs X et Y sont définies sur 0 :

Axes of the Windows Coordinate System

Voici un exemple d'y accéder :

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 WindowsFormsApplication1  
{      
    public partial class Exercise : Form      
    {          
	public Exercise()          
	{              
		InitializeComponent();         
 	}            
 

	private void btnPoint_Click(object sender, EventArgs e)          
	{              
	    Point origin = Point.Empty;                
				
	    MessageBox.Show(string.Format("P({0}, {1})", origin.X, origin.Y), "Origin");          
	}      
    }  
}

Pour vous aider à déterminer si un point est vide, le Point et les structures PointF sont équipés d'une propriété de type Boolean nommée IsEmpty.

Vous pouvez en savoir davantage sur cette propriété à l'aide d'une instruction conditionnelle.

Pour créer ou identifier un point, vous pouvez utiliser un des trois constructeurs du Point ou la structure PointF.

Un de ces constructeurs utilise la syntaxe suivante :

public Point(int x, int y)

Ce constructeur prend un arguments haut et gauche.

Voici un exemple de création du point à utiliser :

private void btnPoint_Click(object sender, EventArgs e)  
{      
	Point pt = new Point(6, -2);        
	
	MessageBox.Show(string.Format("P({0}, {1})", pt.X, pt.Y), "Coordinate");  
}

Le point et les structures PointF sont équipés des méthodes pour effectuer diverses opérations telles que l'ajout ou la soustraction des points, etc..

La Taille

 

Introduction

La distance entre le bord gauche de la bordure droite d'un objet est appelée sa largeur. De la même manière, la distance entre le haut et les bordures en bas d'un contrôle est sa hauteur. Cela peut être illustré comme suit :

The location and dimension of a control

La combinaison de la largeur et la hauteur d'un objet sont appelées sa taille.

Pour prendre en charge la taille d'un objet, l'espace de noms System.Drawing définit la structure Size. Il existe quatre caractéristiques qui définissent une valeur Siez : son emplacement et ses dimensions. Une valeur Size doit avoir un point de départ (X, Y), tout comme l'objet point a été illustré précédemment. La largeur est la distance entre la gauche et les bordures droites d'un objet Size. La hauteur représente la distance entre le haut et les frontières du bas d'une valeur de Size

Size Representation

Les membres d'une structure de taille utilisent des valeurs de type int. Si vous souhaitez utiliser des valeurs décimales, le .NET Framework fournit la structure SizeF dont les membres traitent des valeurs de type float.

Les Caractéristiques d'une taille

La taille et les structures de SizeF sont équipées de propriétés Width et Height qui représentent respectivement leur largeur et hauteur.

public Size(int width, int height);

Le constructeur SizeF équivalent utilise la syntaxe suivante :

public SizeF(float width, float height);

Vous pouvez également définir un objet de taille (ou SizeF) à l'aide d'une valeur de point (ou PointF).

Pour cela, la structure de taille est équipée du constructeur suivant :

public Size(Point pt);

Le constructeur SizeF équivalent utilise la syntaxe suivante :

public SizeF(PointF pt);

Après la déclaration d'une variable avec ce constructeur, vous pouvez accéder à ses propriétés de Largeur et de hauteur pour terminer la définition de l'objet de taille.

Si vous avez déjà la taille d'un objet, vous pouvez uniquement spécifier les dimensions de la variable.

Le rectangle

 

Introduction

La combinaison de l'emplacement et la taille d'un objet sont représentées sous la forme d'un rectangle : une figure géométrique avec quatre côtés. Pour prendre en charge cette figure, l'espace de noms System.Drawing fournit le rectangle et les structures RectangleF. Un rectangle peut être représenté comme suit :

Comme chaque représentation géométrique dans votre programme, une figure rectangulaire est basée sur un système de coordonnées dont l'origine se trouve sur un coin supérieur gauche. L'objet qui "possède" ou définit le rectangle possède également cette origine.

Les Caractéristiques d'un rectangle

Pour le représenter complètement, un rectangle est défini par son emplacement et sa taille. L'emplacement est défini par un point sur le coin supérieur gauche du rectangle :

  • La distance entre le bord gauche de l'objet auquel appartient le rectangle et la bordure gauche du rectangle est représentée par une propriété appelée Left
  • La distance qui sépare la bordure supérieure de l'objet auquel appartient le rectangle à la bordure supérieure du rectangle est représentée par une propriété appelée Top
  • La distance entre la gauche et les bordures droites du rectangle est représentée par une propriété appelée Width
  • La distance entre la gauche et les bordures droites du rectangle est représentée par une propriété appelée Height
  • La distance entre le bord gauche de l'objet auquel appartient le rectangle et la bordure droite du rectangle est représentée par une propriété appelée Right
  • La distance qui sépare la bordure supérieure de l'objet auquel appartient le rectangle et la bordure inférieure du rectangle est représentée par une propriété appelée Bottom

Sur cette base, un rectangle peut être illustré comme suit :


Rectangle Representation

Pour créer un rectangle, vous devez fournir au moins son emplacement et les dimensions. L'emplacement peut être représenté par une valeur de point et les dimensions peuvent être représentées par une valeur de taille. Sur cette base, vous pouvez utiliser le constructeur suivant pour déclarer une variable Rectangle :

public Rectangle(Point location, Size size);

Le constructeur RectangleF équivalent utilise la syntaxe suivante :

public RectangleF(PointF location, SizeF size);

Ce constructeur exige que vous définissiez un point (ou PointF) et une taille (ou SizeF) afin de l'utiliser.

Si au lieu de cela, vous connaissez les valeurs entières de l'emplacement et les dimensions, vous pouvez utiliser le constructeur suivant pour déclarer un objet Rectangle :

public Rectangle(int x, int y, int width, int height);

Le constructeur RectangleF équivalent a la syntaxe suivante :

public RectangleF(float x, float y, float width, float height);

à tout moment, vous pouvez accéder ou récupérer les caractéristiques d'un objet rectangle, comme illustré dans l'image ci-dessus de ses propriétés.

Vous utilisez les mêmes noms que nous avons utilisés dans l'image.

La Couleur

 

Introduction

La couleur est l'un des objets les plus fondamentaux qui améliore l'aspect esthétique d'un objet. La couleur est un objet non spatial qui est ajouté à un objet pour modifier certains de ses aspects visuels. Pour prendre en charge les couleurs, la librairie GDI + fournit la structure de couleur qui est définie dans l'espace de noms System.Drawing.

La Composotion d'une couleur

Une couleur est créée comme une combinaison de quatre valeurs de 8 bits. La première valeur est appelée alpha, mais elle est surtout utilisée en interne. La seconde est appelée rouge. La troisième est appelée verte. La quatrième est appelée bleue :

Bits

Alpha

7

6

5

4

3

2

1

0

Red

7

6

5

4

3

2

1

0

Green

7

6

5

4

3

2

1

0

Bleu

7

6

5

4

3

2

1

0

Converti en décimal, chacun des numéros rouge, vert et bleu produirait :

2 7 + 2 6 + 2 5 + 2 4 + 2 3 + 2, 2 + 2 1 + 2 0  

= 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1

= 255

Par conséquent, chaque numéro peut avoir une valeur comprise entre 0 et 255 dans le système décimal. La section alpha est réservée au système d'exploitation. Les trois autres numéros sont combinés pour produire une seule valeur comme suit :

Couleur

23

22

21

20

19

18

17

16

15

14

13

12

11

10

9

8

7

6

5

4

3

2

1

0

Bleu

Green

Red

Valeur

Converti en décimal, ce nombre a une valeur de 255 * 255 * 255 = 16581375. Cela signifie que nous pouvons avoir environ 16 millions de couleurs disponibles. La question qui vient à l'esprit est comment nous utilisons ces couleurs, pour produire l'effet.

Le Moniteur d'ordinateur a une surface qui ressemble à une série de métallique des lignes horizontales et verticales. L'intersection d'une ligne horizontale et une ligne verticale est appelée un pixel. Ce pixel détient, transporte ou affiche une couleur :

Pixel

Comme les pixels proches les uns aux autres ont différentes couleurs, l'effet est une distorsion merveilleuse qui crée une image esthétique. C'est en changeant les couleurs des pixels que vous produisez l'effet des variations de couleur visible sur les photos et autres graphiques.

L'Utilisation d'une couleur

Pour faciliter la sélection de la couleur, la structure Color est équipée de diverses propriétés dont chacune représente un nom d'une couleur.

Par conséquent, pour utiliser l'une de ces couleurs, appelez la structure Color suivie de l'opérateur "." , suivie de la couleur souhaitée.

Tous les noms de couleurs populaires sont reconnus, et ils sont représentés dans la structure de la couleur par les propriétés statiques.

Celles-ci comprennent le rouge, vert, bleu, noir, blanc, jaune, fuchsia, argent, Gray, Brown, et kaki, etc., juste pour n'en nommer que quelques-uns.

Il existe de nombreuses autres couleurs qui ne sont pas nécessairement populaires.

Voici un exemple :

private void btnBackColor_Click(object sender, EventArgs e)  
{              
	panel1.BackColor = Color.Turquoise;  
}

L'Extraction d'une couleur

Si aucune des couleurs prédéfinies ne vous convient, vous pouvez définir votre propre couleur comme une combinaison de valeurs rouges, vertes et bleues.

Pour créer une couleur à l'aide de cette approche, vous pouvez déclarer une variable de type Color.

Pour spécifier les caractères de la couleur, la structure de couleur fournit la méthode statique FromArgb() surchargée en quatre versions comme suit :

public static Color FromArgb(int argb);  
public static Color FromArgb(int alpha, Color baseColor);  
public static Color FromArgb(int red, int green, int blue);  
public static Color FromArgb(int alpha, int red, int green, int blue);

La troisième version, qui est la plus utilisée permet de spécifier les trois valeurs dont chacune varie de 0 à 255.

Voici un exemple :

private void btnBackColor_Click(object sender, EventArgs e)  
{              
	panel1.BackColor = Color.FromArgb(26, 69, 174);  
}

Au lieu de définir une couleur par sa composition RVB, si vous connaissez le nom de la couleur que vous souhaitez utiliser, la structure de couleurs propose une méthode nommée FromName que vous pouvez utiliser.

Sa syntaxe est la suivante :

public static Color FromName(string name);

Cette méthode attend comme argument le nom de la couleur.

Voici un exemple :

private void btnBackColor_Click(object sender, EventArgs e)  
{              
    panel1.BackColor = Color.FromName("LightBlue");
}

Lors de l'appel de cette méthode, assurez-vous que vous connaissez le nom de la couleur que vous souhaitez utiliser.

Si vous fournissez un nom unregnized, le compilateur ne déclenche pas une exception mais définit les valeurs du rouge, vert et bleu, afin que l'objet puisse devenir transparent.

Par conséquent, vous devez connatre la couleur à utiliser, mais vous ne pouvez pas savoir de façon réaliste les noms de toutes les couleurs disponibles.

Pour vous aider à identifier une couleur, la structure de couleur fournit une méthode nommée FromKnownColor et sa syntaxe est la suivante :

public static Color FromKnownColor(KnownColor name);

Cette méthode prend comme argument un membre d'une énumération nommée KnownColor.

L'énumération KnownColor contient les noms des 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.

Voici un exemple de l'appel de cette méthode :

private void btnBackColor_Click(object sender, EventArgs e)  
{              
	panel1.BackColor = Color.FromKnownColor(KnownColor.DarkTurquoise);  
}

L'Extraction d'une couleur

Si une couleur a été initialisée avec une des propriétés de couleur prédéfinie de Color, à l'aide de la FromArgb(), FromName() ou les méthodes FromKnownColor(), si vous souhaitez récupérer les composantes rouges, vertes et bleues d'une couleur, vous pouvez utiliser le R, le G ou les propriétés de B pour extraire la valeur de chacune.

Chacune de ces propriétés est de type byte.

Alternativement, vous pouvez appeler la méthode Color.ToArgb().

Sa syntaxe est la suivante :

public int ToArgb();

Cette méthode renvoie un nombre entier.

Nous avons mentionné que les couleurs sont généralement connues par leurs noms.

Tandis que la méthode ToArgb() produit un nombre entier qui représente une couleur, si vous souhaitez obtenir les couleurs par leur nom commun ou connu au lieu de cela, la structure de couleur fournit une méthode nommée ToKnownColor et dont la syntaxe est la suivante :

public KnownColor ToKnownColor();

Cette méthode renvoie une valeur qui est basée sur l'énumération KnownColor.

La bote de dialogue couleurs

 

Introduction

Pour permettre la sélection des couleurs sur les applications Microsoft Windows, le système d'exploitation fournit une bote de dialogue commune appropriée pour ces tches. Vous pouvez utiliser la bote de dialogue couleurs pour diverses raisons, comme permettant à l'utilisateur de définir ou modifier la couleur d'un objet ou de spécifier la couleur d'arrière-plan d'un contrôle ou la couleur utilisée pour peindre un objet. Lorsqu'elle affiche, par défaut, la bote de dialogue s'affiche comme suit :

The Color Dialog Box

Cela affiche une liste de constante de couleurs à l'utilisateur. Si aucune des couleurs disponibles n'est appropriée pour la tche à accomplir, l'utilisateur peut cliquer sur Définir les couleurs personnalisées >> bouton pour développer la bote de dialogue :

The Expanded Dialog Box


La bote de dialogue couleur étendue permet à l'utilisateur de sélectionner l'une des couleurs prédéfinies ou personnalisées à créer une couleur en spécifiant les valeurs rouges, vertes et bleues.

L'utilisateur peut modifier la couleur dans quatre domaines différents. La partie supérieure gauche affiche une liste des 48 couleurs prédéfinies. Si la couleur souhaitée n'est pas dans cette section, l'utilisateur peut cliquer et faire glisser la souris dans la palette multicolores. L'utilisateur peut également faire glisser la barre de droite qui affiche une palette basée sur la couleur de la palette ; l'utilisateur peut faire défiler en haut et en bas en faisant glisser la flèche. Pour plus de précision, l'utilisateur peut saisir les valeurs rouges, vertes et bleues. Chacune utilise une valeur intégrale allant de 1 à 255.

La Réalisation d'une bote de dialogue couleurs

Pour fournir la bote de dialogue couleurs à votre application, dans la section de botes de dialogue de la bote à outils, vous pouvez cliquer sur le bouton ColorDialog et cliquer n'importe où sur l'écran.

La bote de dialogue couleurs est implémentée par la classe ColorDialog, qui est basée sur la classe CommonDialog qui est l'ancêtre de toutes les botes de dialogue Windows courantes du .NET Framework.

Pour afficher la bote de dialogue à l'utilisateur, appelez la méthode CommonDialog.ShowDialog().

Voici un exemple :

private void btnBackColor_Click(object sender, EventArgs e)  
{              
	ColorDialog dlg = new ColorDialog();
           	     
	dlg.ShowDialog();  
}

Les caractéristiques de la bote de dialogue couleurs

 

Les couleurs produites par une bote de dialogue couleurs

La propriété la plus importante et la plus évidente de la bote de dialogue couleurs est la couleur que l'utilisateur aurait sélectionnée après utilisation. Cette couleur sélectionnée est représentée par la propriété ColorDialog.Color. Lorsque vous configurez un contrôle ColorDialog pour votre application, si vous souhaitez spécifier la couleur par défaut, dans la fenêtre Propriétés, vous pouvez cliquer sur la flèche de la propriété de couleur. Cela vous donnerait la possibilité de sélectionner une couleur de trois onglets disponibles :

Back Color Back Color
Back Color

Au moment de l'exécution, vous pouvez définir la couleur par programmation en lui affectant un nom valide connu d'une couleur :

private void btnBackColor_Click(object sender, EventArgs e)  
{              
	ColorDialog dlg = new ColorDialog();              
	dlg.Color = Color.Red;              
	dlg.ShowDialog();  
}

Lorsque l'utilisateur a terminé d'utiliser la bote de dialogue couleurs et cliqué sur OK, vous trouverez quelle couleur a été sélectionnée par extraction de la valeur de la propriété ColorDialog.Color.

Voici un exemple :

private void btnBackColor_Click(object sender, EventArgs e)  
{          
		ColorDialog dlg = new ColorDialog();          
		dlg.Color = Color.FromKnownColor(KnownColor.DarkTurquoise);            
 
		if( dlg.ShowDialog() == DialogResult.OK )                  
				panel1.BackColor = dlg.Color;  
}

La vue complète d'une bote de dialogue couleurs

Par défaut, la bote de dialogue couleurs s'affiche dans sa taille (petit) régulière. Cela permet à l'utilisateur de sélectionner une des couleurs prédéfinies. Si la couleur souhaitée n'est pas disponible, comme déjà dit, l'utilisateur peut cliquer sur Définir les couleurs personnalisées >> Bouton. Si vous souhaitez contrôler la capacité de l'utilisateur pour développer la bote de dialogue, utilisez la propriété Boolean AllowFullOpen. Lorsque cette propriété est définie sur True, qui est sa valeur par défaut, la bote de dialogue apparat à sa taille normale, mais avec Définir les couleurs personnalisées >> Bouton activé. Si vous souhaitez que l'utilisateur puisse sélectionner une seule des couleurs prédéfinies et ne pas avoir la possibilité d'étendre la bote de dialogue, définissez la propriété AllowFullOpen à False. Avec cette valeur, lorsque la bote de dialogue couleurs vient, c'est à sa taille normale mais Définir les couleurs personnalisées >> Bouton est désactivé :

The Color dialog box that cannot be expanded

Comme nous l'avons déjà mentionné, par défaut, la bote de dialogue couleurs affiche à sa taille normale. Vous pouvez contrôler la taille régulière ou complète de la bote de dialogue à l'aide de la propriété Boolean FullOpen. Lorsque sa valeur est False, ce qui est la valeur par défaut, la bote de dialogue apparat régulièrement. Si vous souhaitez qu'elle apparaisse dans sa taille réelle, définissez cette propriété sur True.

La couleur d'un pixel

  

Définition de la couleur ou de la peinture d'un pixel

Dans notre introduction de GDI +, nous avons vu que l'écran d'un moniteur d'ordinateur utilise une série de lignes horizontales et verticales, l'intersection de deux lignes perpendiculaires est un pixel. Chaque pixel est titulaire d'une couleur. Bien entendu, les deux pixels adjacents peuvent contenir la même couleur ou chacun peut contenir une couleur différente.

Une image bitmap est une série de couleurs des pixels adjacents. Autrement dit, pour un groupe de pixels à considérer un bitmap, ces pixels doivent constituer un groupe. Un bitmap est fait en spécifiant la couleur de chaque pixel. Cela signifie que les images que nous avons utilisées jusqu'à présent étaient simplement faites des pixels et chaque pixel a une couleur appropriée.

Si vous décidez de créer ou de concevoir une image à l'aide de l'outil des ressources dans Microsoft Visual C++ disponibles à partir de l'affichage des ressources (ou de l'Explorateur de solutions), vous feriez des expériences sur une grande échelle, la possibilité de spécifier la couleur de chaque pixel individuel, à l'aide des (une liste limitée de) couleurs :

Bitmap Design

En fait, lorsque vous avez une image bitmap, vous pouvez accéder à tous les pixels de l'image et puis vous pouvez spécifier sa couleur ou obtenir sa couleur actuelle.

Pour vous permettre de spécifier la couleur d'un pixel, la classe bitmap fournit une méthode nommée SetPixel et sa syntaxe est la suivante :

public void SetPixel(int x, int y,
	             Color color);

Les arguments x et y représentent les valeurs left et top de l'emplacement du pixel.

Le troisième argument spécifie la nouvelle couleur que le pixel tiendra.

Voici un exemple :

private void Form1_Paint(object sender, PaintEventArgs e)  
{          
	Bitmap bgDrawingArea = new Bitmap(Width, Height);          
	e.Graphics.DrawImage(bgDrawingArea, 0, 0);            
  
	for (int i = 0; i < Width; i += 20)               
		 for (int j = 0; j < Height; j += 20)               
		 {                      
			bgDrawingArea.SetPixel(i, j, Color.White);                        

			Graphics painter = Graphics.FromHwnd(Handle);                      
			painter.DrawImage(bgDrawingArea, 0, 0);               
		}  
}

Pixel

L'Obtention de la couleur d'un pixel

Nous avons mentionné précédemment qu'une image était une série de pixels avec chaque pixel contenant une couleur. Au lieu de spécifier la couleur d'un pixel, vous pouvez récupérer sa couleur. Pour cela, la classe bitmap est équipée d'une méthode nommée GetPixel. Sa syntaxe est la suivante :

public Color GetPixel(int x, int y);

Les arguments x et y représentent les valeurs left et top de l'emplacement du pixel dont vous souhaitez obtenir la couleur. Cette méthode renvoie la couleur de ce pixel.

ApplicationApplication : Accès à la couleur d'un pixel

  1. Pour créer un nouveau programme, dans le menu principal, cliquez sur fichier - > New - > Projet...
  2. Dans la liste du milieu, cliquez sur Windows Application
  3. Définissez le nom pour ColorSelector1 et cliquez sur OK
  4. Copiez l'image suivante et collez-la quelque part dans votre ordinateur.
     
    Color Palette
  5. Concevez le formulaire comme suit :
     

    Color Selector

    Contrôle

    Texte

    Nom

    Autres propriétés.

    PictureBox

    Picture Box

     

    pbxColor

    Image : colorpal1.jpg

    étiquette

    Label

    Rouge :

     

     

    TextBox

    TextBox

     

    txtRed

     

    étiquette

    Label

    Vert :

     

     

    TextBox

    TextBox

     

    txtGreen

     

    étiquette

    Label

    Bleu :

     

     

    TextBox

    TextBox

     

    txtBlue

     

    Panneau

    Panel

     

    pnlPreview

    BorderStyle : FixedSingle

    Bouton

    Button

    Fermer

    btnClose

     

  6. Cliquez droit sur le formulaire et cliquez sur Afficher le code
  7. Au-dessus de la ligne public Form1(), déclarez une variable booléenne nommée IsSelecting :
         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 ColorSelector1  
    	  {      
    	 	 public partial class Form1 : Form      
    	 	 {          
    		 	bool isSelecting;            
     
     
    		 	public Form1()          
    		 	{              
    			 	InitializeComponent();          
    		 	}      
    	 	}  
    	}
  8. Retournez à l'écran et cliquez deux fois sur une zone libre de son corps
  9. Exécutez l'événement comme suit :
    private void Form1_Load(object sender, EventArgs e)  
    {              
    	isSelecting = false;  
    }
  10. Retournez à l'écran et cliquez sur le contrôle de zone d'image
  11. Dans la fenêtre Propriétés, cliquez sur le bouton événements et double-cliquez sur MouseDown
  12. Exécutez l'événement comme suit :
    private void pbxColor_MouseDown(object sender, MouseEventArgs e)  
    {              
    	isSelecting = true;  
    }
  13. Retournez à l'écran et cliquez sur le contrôle de zone d'image
  14. Dans la section Evénements de la fenêtre Propriétés, double-cliquez sur MouseUp et exécutez l'événement comme suit :
    private void pbxColor_MouseUp(object sender, MouseEventArgs e)  
    {              
    	isSelecting = false;  
    }
  15. Retournez à l'écran et cliquez sur le contrôle de zone d'image
  16. Dans la section Evénements de la fenêtre Propriétés, double-cliquez sur MouseMove et exécutez l'événement comme suit :
    private void pbxColor_MouseMove(object sender, MouseEventArgs e) 
    {          
    	if (isSelecting == true)          
    	{                  
    		Bitmap bmpImage = (Bitmap)pbxColor.Image;                  
    		Color clr = bmpImage.GetPixel(e.X, e.Y);                    
     
    		txtRed.Text = clr.R.ToString();                  
    		txtGreen.Text = clr.G.ToString();                  
    		txtBlue.Text = clr.B.ToString();                    
     
    		pnlPreview.BackColor = clr;          
           }  
    }
  17. Exécutez l'application
  18. Cliquez avec la souris sur l'image de la souris et faites glisser pour produire une couleur.
     
  19.  Fermez l'cran

Une liste des images

 

Introduction

Dans une application qui traite avec le graphique, vous ne pouvez utiliser qu'une seule image, mais dans différents, sinon la plupart des autres applications, telles que celles utilisées pour afficher, échanger ou changer des photos, vous pouvez traiter avec des images différentes. Dans ce type d'application, parfois les images sont de tailles différentes, y compris même les tailles imprévisibles. Dans un autre type d'application, les images que vous utilisez, certaines peuvent avoir la même taille (exacte). Pour ce type, au lieu d'utiliser chaque image individuellement, vous pouvez les stocker dans une collection, puis accéder à chaque image lorsque c'est nécessaire.

Une liste d'images est une collection d'icônes ou des images qui sont stockées afin que chaque icône ou image puisse être située par un index. Les icônes ou les photos doivent être de la même taille et elles doivent être du même type. Cela signifie que la collection peut être faite uniquement des icônes de tailles 16 x 16, seulement les icônes de tailles 32 x 32, seulement les icônes des tailles 48 x 48, ou uniquement les bitmaps (mais de la même taille).

Lorsqu'il s'agit de concevoir, il existe deux types de listes d'images. Chaque image peut être ajoutée individuellement à la collection, ou toutes les images peuvent être conçues dans une image plus longue et, à l'intérieur de cette longue photo, vous utiliseriez une technique pour rechercher chaque photo.

Une fois que vous obtenez une liste d'images, il n'y a aucun moyen prédéfini que vous devez utiliser. Certains contrôles Windows utilisent une liste d'images pour utiliser les images dont ils ont besoin, mais il existe diverses autres façons imprévisibles que vous pouvez utiliser une liste d'images.

ApplicationApplication : Présentation des listes d'images

  1. Pour créer une nouvelle application, dans le menu principal, cliquez sur Fichier - > New - > Projet...
  2. Dans la liste du milieu, cliquez sur Windows Application
  3. Définissez le nom sur ImageViewer1 et cliquez sur OK

La Création d'une liste des images

Pour exécuter des listes d'images, le .NET Framework fournit une classe appelée ImageList qui est définie dans l'espace de noms System.Windows.Forms de la bibliothèque System.Windows.Forms.dll. Au moment du design, pour créer une liste d'images, dans la section des composantes de la bote à outils, vous pouvez cliquez sur le bouton ImageList et cliquez sur le formulaire.

Pour créer par programmation une liste d'images, déclarez une variable de type ImageList et initialisez-la en utilisant l'un de ses deux constructeurs. Le constructeur par défaut est utilisé pour simplement signaler que vous allez utiliser une liste d'images. Voici un exemple :

using System;  
using System.Windows.Forms;    
 
 
public class Exercise : Form  
{      
	 private ImageList lstImages;        
 
 
	 public Exercise()      
	 {          
		 InitializeComponent();      
	 }        
 
 
	 void InitializeComponent()      
	 {          
		lstImages = new ImageList();      
	 }  
}    
 
 
public class Program  
{      
	 public static int Main()      
	 {          
		 Application.Run(new Exercise());            
		 
		 return 0;      
	 }  
}

La classe ImageList est équipée d'un autre constructeur dont la syntaxe est la suivante :

public ImageList(IContainer container);

Ce constructeur attend comme argument le conteneur de contrôle qui sera chargé de se débarrasser de la liste de l'image lorsque vous quittez l'application.

ApplicationApplication : Création d'une liste des images

  1. Dans la section des composantes de la bote à outils, cliquez sur ImageList et cliquez sur le formulaire.
  2. Dans la fenêtre Propriétés, modifiez son nom à lstPictures
  3. Dans la section des composantes de la bote à outils, cliquez sur timer et cliquez sur le formulaire.
  4. Dans la fenêtre Propriétés, modifiez ses caractéristiques comme suit :
     
    Enabled : true
    Interval : 2000
  5. Dans la section contrôles communs de la bote à outils, cliquez sur PictureBox et cliquez sur le formulaire
  6. Dans la fenêtre Propriétés, modifiez ses caractéristiques comme suit :

    (Name): pbxViewer
    Dock : Fill

  7. Enregistrez tous

Les Caractéristiques d'une liste des images

 

La taille des images

Avant de créer une liste d'images, vous devez préparer les images.

Comme mentionné précédemment, vous pouvez utiliser les images individuelles qui seraient faites dans un jeu.

Lorsque vous créez les images, votre préoccupation principale est la taille que vous leur donnez.

La taille par défaut d'une image est de 16 x 16.

Si vous créez une liste d'icônes, vous pouvez créer chacune avec la taille par défaut de 16 x 16.

Dans certains cas (par exemple, si vous envisagez d'utiliser les images pour un affichage de la liste), vous pouvez créer ou concevoir un deuxième ensemble d'icônes dont la taille est de 32 x 32 (48 x 48) chacune.

Vous pouvez utiliser une taille supérieure :

  • La longueur maximale qu'une image peut avoir est de 256 pixels
  • La hauteur maximale que l'image peut avoir est de 256 pixels

Pour créer ou concevoir vos images bitmap, vous pouvez utiliser le concepteur de bitmap de Microsoft Visual Studio, ou vous pouvez utiliser une application externe plus avancée pour préparer les images.

Bien que les images utilisées dans une liste d'images sont généralement carrées (16 x 16, 32 x 32, 48 x 48, 96 x 96, etc.), vous pouvez utiliser une longueur différente et une hauteur différente mais, si vous créez des images individuelles, elles doivent avoir chacune la même taille (même longueur et même hauteur).

Au lieu d'utiliser des images différentes, vous pouvez créer une image longue dont les sections seraient utilisées pour identifier chaque image.

Il n'existe aucun moyen particulier que vous devez concevoir l'image longue et aucune règle réelle sur ses dimensions : la taille deviendrait un problème lorsqu'il est temps d'utiliser la picture(s).

également, lorsque vous créez l'image, si elle inclue les différentes images qui seraient considérées comme dans la liste, assurez-vous que vous savez où chaque image modulable commence et où elle se termine.

Dans ce cas, il y a une photo longue de différentes sections et chaque section contient une image particulière.

Lors de la création de ce type, vous devez connatre la taille qui contient chaque image particulière.

Après la préparation des images, vous pouvez vous apprêter à créer la liste d'images.

Si vous le souhaitez, vous pouvez spécifier la taille de chaque image avant de créer effectivement la liste.

Pour cela, la classe ImageList est équipée d'une propriété nommée ImageSize.

La propriété ImageSize est de type Size.

Vous pouvez l'utiliser pour spécifier la taille de chaque image.

Voici un exemple :

using System;  
using System.Drawing;  
using System.Windows.Forms;    
 
public class Exercise : Form  
{      
 
	 private ImageList lstImages;       
 
 
	 public Exercise()      
	 {          
		 InitializeComponent();      
	 }        
	 
	 void InitializeComponent()      
	 {          
		lstImages = new ImageList();          
		lstImages.ImageSize = new Size(256, 256);      
	 }  
}

Si la liste de l'image a déjà été créée, à savoir la taille de l'image, vous pouvez obtenir la valeur de la propriété ImageSize.

ApplicationApplication : Préparation des images

  1. Copiez chacune des images suivantes et collez-les dans un répertoire ou un dossier de votre ordinateur.

    Field

    Field

    Field

    Field

    Field

    Field

  2. Sous la forme, cliquez sur lstPictures et, dans la fenêtre Propriétés, définissez l'ImageSize à 250, 165

La profondeur de couleur

Avant de créer la liste des images, vous devez spécifier le nombre de bits qui sera utilisé pour spécifier la couleur de chaque pixel. Cette information est appelée la profondeur de couleur. Pour la prendre en charge, la classe ImageList est équipée d'une propriété appelée ColorDepth. Les valeurs possibles sont Depth4Bit, Depth8Bit, Depth16Bit, Depth24Bit et Depth32Bit. La valeur par défaut est Depth8Bit.

ApplicationApplication : Spécification de la couleur Depht

  • Dans le cadre de l'écran, cliquez sur lstPictures et, dans la fenêtre Propriétés, définissez la ColorDeph à Depth32Bit

La Création de la collection d'images

Après la préparation des photos, pour créer visuellement la liste des images, sous la forme, cliquez sur le contrôle de liste d'image pour le sélectionner. Puis :

  • Cliquez sur la flèche sur le contrôle Image List. Puis cliquez sur Choisir les images
     
    Image List: Choose Images
  • Dans la fenêtre Propriétés, cliquez sur le bouton de sélection du champ images

Cela ouvrirait l'éditeur de collections d'images. Pour ajouter une image, vous pouvez cliquez sur le bouton Ajouter, recherchez une photo et sélectionnez-la. Vous pouvez continuer cette opération jusqu'à ce que vous ayez sélectionné toutes les images nécessaires. Voici un exemple :

Image Collection

Après avoir sélectionné les images, vous pouvez cliquer sur OK.

Pour vous aider à la création de la liste des images, la classe ImageList est équipée d'une propriété nommée images, qui est une collection. La propriété ImageList.Images est de type ImageCollection. La classe ImageCollection implémente l' interface IList, ICollection et les interfaces IEnumerable.

à l'aide de la classe ImageCollection via la propriété d'images, vous pouvez ajouter les icônes nécessaires ou des images, une à la fois. Pour vous aider à cela, la classe ImageCollection implémente la méthode Add(). Si vous créez une liste d'icônes, vous pouvez appeler la version suivante de la méthode Add() :

public void Add(Icon value);

Si vous créez une liste de photos, vous pouvez appeler la version suivante de la méthode Add() :

public void Add(Image value);

Voici un exemple :

public class Exercise : Form  
{      
	 private ImageList lstImages;        
	 
	 public Exercise()      
	 {          
		 InitializeComponent();      
	 }        
 
 
	 void InitializeComponent()      
	 {          
	 	 lstImages = new ImageList();          
	 	 lstImages.ImageSize = new Size(256, 256);            
 
 
	 	 Image img1 = Image.FromFile("E:\\Programs\\image1.jpg");          
	 	 lstImages.Images.Add(img1);          
	 	 Image img2 = Image.FromFile("E:\\Programs\\Image2.jpg");          
	 	 lstImages.Images.Add(img2);      
	 }  
}

Au lieu d'ajouter une image à un moment, vous pouvez tout d'abord la stocker dans un tableau.

Pour ajouter un tableau de photos, la classe ImageCollection fournit une méthode nommée AddRange et dont la syntaxe est la suivante :

public void AddRange(Image[] images);

Voici un exemple :

void InitializeComponent()  
{          
		lstImages = new ImageList();          
		lstImages.ImageSize = new Size(256, 256);            
 
 
		Image img1 = Image.FromFile(@"E:\Programs\image1.jpg");          
		lstImages.Images.Add(img1);          
		Image img2 = Image.FromFile(@"E:\Programs\Image2.jpg");          
		lstImages.Images.Add(img2);
										            
		Image[] images =          
		{              
			Image.FromFile(@"E:\Programs\image3.jpg"),              
			Image.FromFile(@"E:\Programs\Image4.jpg"),              
			Image.FromFile(@"E:\Programs\Image5.jpg")          
		};            
			
		lstImages.Images.AddRange(images);  
}

ApplicationApplication : Création d'une liste des images

  1. Dans le cadre de l'écran, cliquez sur lstPictures
  2. Dans la fenêtre Propriétés, cliquez sur les images, puis cliquez sur le bouton de sélection Ellipsis
  3. Dans l'éditeur de collections d'images, cliquez sur Ajouter, recherchez une des images que vous avez enregistrées, sélectionnez-la et cliquez sur Ouvrir
  4. Faites la même chose pour sélectionner les autres photos
     
    Images Collection Editor
  5. Cliquez sur OK

L'utilisation d'une liste des images

Après avoir créé une liste d'images, vous pouvez l'utiliser dans votre application. Comme son nom l'indique, une liste d'images est simplement une collection d'images. Le contrôle qui contient cette collection ne définit pas pourquoi ni quand les images seraient utilisées. Certains contrôles Windows, tels que l'affichage de la liste, le contrôle de l'onglet ou la barre d'outils les utilisent. La plupart du temps, vous saurez quand un certain contrôle a besoin d'une liste d'images et comment l'utiliser. Dans le cas contraire, vous pouvez utiliser les images dans une liste d'images de différentes manières. Par exemple, vous pouvez utiliser ces images, comme d'autres, pour afficher une sur un formulaire.

Pour prendre en charge la possibilité d'afficher les images d'une liste d'images, la classe ImageList est équipée d'une méthode appelée Draw. Lors de l'appel de cette méthode, puisque la liste d'images ne sait pas où elle serait utilisée, et parce que le contrôle cible ne définirait pas d'où vient l'image, le principal argument de cette méthode est la plate-forme sur laquelle afficher l'image. Cette plate-forme est un objet Graphics. Une fois que vous avez décidé sur le graphique de réception, vous devez indiquer l'emplacement où l'image devrait être positionnée. Vous avez deux options principales. Vous pouvez spécifier l'emplacement par les coordonnées gauche et haut. Dans ce cas, vous utilisez la version suivante de la méthode Draw() :

public void Draw(Graphics g, int x,  int y, int index);

Vous pouvez également spécifier l'emplacement par une valeur de Point. Dans ce cas, vous utilisez la version suivante de la méthode :

public void Draw(Graphics g, Point pt,  int index);

Dans les deux cas, le dernier argument est l'index de l'image souhaitée dans la collection.

ApplicationApplication : Dessin des images

  1. Dans le cadre de l'écran, double-cliquez surtimer1 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 ImageViewer1  
    {      
        public partial class Form1 : Form      
        {          
    	static int index = 0;            
     
    	public Form1()          
    	{              
    		InitializeComponent();          
    	}            
     
    	private void timer1_Tick(object sender, EventArgs e)          
    	{              
    		if (index < 6)              
    		{                  
    			lstPictures.Draw(pbxViewer.CreateGraphics(),                                             
    					   pbxViewer.Left,                            	           
    					   pbxViewer.Top,                            	           
    					   index);                  
    			index++;              
    		}              
    		else                  
    			index = 0;          
    	}      
        }  
    }
  2. Exécutez l'application pour afficher le résultat.
     
    Water Falls Presentation
  3. Fermez le formulaire et le retourner à votre environnement de programmation

La couleur transparente

Lorsque vous dessinez les images d'une liste d'images, vous pouvez désigner une couleur que le compilateur ignorera ou "verra". On parle de la couleur transparente. Pour cela, la classe ImageList est équipée d'une propriété nommée TransparentColor, qui est de type Color.

 
 
 
 

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