Home

Les Formulaires d'une Application

 

Les Principes de Base d'un Formulaire

 

Introduction

Le formulaire est l'objet fondamental le plus utilisé dans une application. Un formulaire en soi ne fait rien. Son rôle principal consiste à héberger d'autres objets que l'utilisateur utilise pour communiquer avec l'ordinateur :

Form 1

Création d’un formulaire

Il existe plusieurs façons d’obtenir un formulaire pour votre application :

  • Si vous créez une Application Windows Forms, elle crée un formulaire de démarrage pour vous
  • Après le démarrage d'un projet vide ou d'une Application Windows Forms, vous pouvez lui ajouter un formulaire. Pour le faire, dans le menu principal, vous pouvez cliquer sur Project - > Ajouter un nouvel élément... Sélectionnez Windows Form. Donnez-lui un nom et cliquez sur OK
  • Vous pouvez créer un formulaire dynamique et l’ajouter à votre application.

Dans la leçon 2, nous avons vu que A était basé sur la classe Form qui est définie dans l'espace de noms System.Windows.Forms créée dans l'assemblage de System.Windows.Forms.dll. Par conséquent, si vous démarrez une application à partir de zéro et vous souhaitez utiliser un formulaire dedans, vous pouvez inclure la bibliothèque System.Windows.Forms.dll dans votre application. Pour vous référer à un formulaire, vous pouvez inclure l'espace de noms System.Windows.Forms dans votre application.

Comme dans la leçon 2, pour créer une application basée sur le formulaire, vous pouvez dériver une classe Formulaire. Voici un exemple :

public  class Exercise : System.Windows.Forms.Form
{
    private void InitializeComponent()
    {
    }

    public Exercise()
    {
  	InitializeComponent();
    }
}

public  class Program
{
    static int Main()
    {
  	System.Windows.Forms.Application.Run(new Exercise());
  	return 0;
    }
}

ApplicationApplication : Présentation des formulaires

  1. Démarrez Microsoft Visual c# et créez une nouvelle Application Windows nommée CPAS1
  2. Appuyez sur Ctrl + F5 pour tester le programme.
  3. Fermez le formulaire et retournez à votre environnement de programmation

Le nom d'un formulaire

Comme tout autre contrôle, un formulaire doit avoir un nom. Si vous dérivez une classe de formulaire, le nom que vous utilisez pour la classe serait le nom du formulaire. Si vous ajoutez un formulaire dans la boîte de dialogue Ajouter un nouvel élément, vous devez aussi lui donner un nom. Si vous créez une Application Windows à partir de la boîte de dialogue Nouveau projet, l'Assistant créerait un formulaire par défaut pour vous, nommé Form1. Cependant, quand vous créez ou obtenez un formulaire, vous pouvez modifier son nom.

Pour modifier le nom d'un formulaire, dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du formulaire et tapez un nouveau nom avec l'extension .cs.

ApplicationApplication : Changement de nom d'un formulaire

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Form1.cs et cliquez sur Renommer
  2. Tapez Central.cs et appuyez sur entrée

La barre de titre du formulaire

 

L'icône système

Un formulaire est composé de différentes sections qui permettent son contrôle comme un objet de Windows et d'autres aspects qui jouent un rôle précieux comme une foule d'autres objets. La partie supérieure d'un formulaire est constituée d'une longue partie appelée la barre de titre.

Sur le côté gauche de la barre de titre, l'écran affiche une petite image appelée une icône ou l’icône du système. Microsoft Visual Studio 2010 fournit une icône par défaut pour toutes les formes. Si vous souhaitez utiliser une autre icône, pendant que l'écran est sélectionné, dans la fenêtre Propriétés, vous pouvez cliquer sur le champ Icône et puis cliquez sur son bouton Ellipsis. Cela lancerait la boîte de dialogue Ouvrir d'où vous pouvez trouver une icône et l’ouvrir.

Pour modifier l'icône par programmation, déclarez une variable de type Icône de l'espace de noms System.Drawing et initialisez-la avec le nom d'un fichier d'icône à l'aide de l'opérateur new. Après l'initialisation de l'icône, affectez-la à la propriété du formulaire icône. Voici un exemple :

private void InitializeComponent()
{
    System.Drawing.Icon  customIcon =
  	new  System.Drawing.Icon(@"C:\Programs\RedBook.ico");
    Icon = customIcon;
}

Si vous avez attribué une icône pour le pour ou le non, vous pouvez contrôler si le formulaire doit afficher une icône. Pour cela, la classe Form est équipée d'une propriété de type Boolean nommée ShowIcon. Si vous définissez cette propriété sur false, l’icône n'apparaît pas dans la barre de titre du formulaire. Si la propriété Form.ShowIcon est définie sur true, ce qui est sa valeur par défaut, la barre de titre du formulaire affiche une icône.

ApplicationApplication : Configuration de la barre de titre d'un formulaire

  1. Dans le menu principal, cliquez sur Projet - > Ajouter un nouvel élément...
  2. Dans la liste du milieu, cliquez sur l'icône Fichier
  3. Définissez le nom de cpas, cliquez sur Ajouter
  4. Concevez l'icône de 32 x 32 comme suit :
     
    Icon Design
  5. Concevez l'icône 16 x 16 comme suit :
     
    Icon Design
  6. Pour enregistrer l'icône de la barre d'outils standard, cliquez sur le bouton Enregistrer tout Save All
  7. Fermez l'onglet de la fenêtre qui contient l'icône conçue
  8. Cliquez sur le corps de l'écran pour vous assurer que cette option est sélectionnée. Dans la fenêtre Propriétés, cliquez sur l'icône et cliquez sur son bouton Ellipsis
  9. Dans la boîte de dialogue Ouvrir, recherchez le dossier dans lequel vous avez enregistré le projet et sélectionnez l'icône du cpas
     
    Open
  10. Cliquez sur Ouvrir
     
    A form with a System icon
  11. Exécutez l'application pour la tester
  12. Fermez et revenez à votre environnement de programmation

La Légende du formulaire

Sur le côté droit de l'icône système, il y a un mot ou un groupe de mots, appelés la légende. Par défaut, la légende affiche le nom du formulaire. Si vous souhaitez modifier la légende, pendant que l'écran est sélectionné, dans la fenêtre Propriétés, cliquez sur le champ Text et tapez ce que vous voulez. Après avoir tapé le texte, appuyez sur Entrée pour afficher sur l'écran.

Au moment du design, la légende est faite de texte que vous tapez "tel quel". Au moment de l'exécution, vous pouvez modifier la légende pour afficher un texte plus complexe qui pourrait être un temps changeant, le résultat d'un calcul, etc.. Voici un exemple :

private void InitializeComponent()
{
  	Icon = new System.Drawing.Icon(@"C:\Programs\RedBook.ico");
  	Text  = "Windows Fundmentals - Programming";
}

Cela donnerait :

 The Caption of a Form 

ApplicationApplication : Définition de la légende d'un formulaire

  1. Lorsque le formulaire est sélectionné, dans la fenêtre Propriétés, cliquez sur Text et tapez
    College Park Auto Shop – Customer Repair Order
  2. Appuyez sur entrée

Les Boutons du Système

Sur le côté droit de la légende, il y a trois petits boutons appelés les boutons du système, faits pour la réduction (Minimize, , ou ), l'agrandissement (Maximize, , ou ) et la Fermeture (Close, , ou ) des boutons. La présence ou l'absence de ces boutons est contrôlée par la propriété Boolean ControlBox dont la valeur par défaut est true pour indiquer que le formulaire est équipé avec les boutons du système. Si vous le définissez sur false, aucun bouton de système ne s'affiche :

A form without the control box

Dans ce cas, l'utilisateur ne serait pas en mesure de fermer le formulaire en utilisant les boutons du système. Par conséquent, si vous créez ce type de formulaire, veillez à ce que vous fournissiez à l'utilisateur un moyen pour le fermer.

La réduction (Minimize, , ou ) du bouton est contrôlée par une propriété booléenne appelée MinimizeBox. Par défaut, lorsque vous créez fraîchement un formulaire, cette propriété est définie sur true et le formulaire affiche un bouton réduire Minimize.

L'agrandissement (Maximize, , ou ) du bouton est contrôlé par la propriété Boolean MaximizeBox, qui est définie à True par défaut. Selon ce que vous essayez d'atteindre dans votre application, vous pouvez modifier la valeur d'une ou deux de ces propriétés. Les quatre combinaisons sont comme suit :

MaximizeBox

MinimizeBox

Display

Résultat

True

True

Maximize = True and Minimize = True

Le formulaire peut être réduit ou agrandi

True

False

Maximize = True and Minimize = False

Le formulaire peut être agrandi, mais ne peut pas être réduit.

False

True

Maximize = False and Minimize = True

Le formulaire peut être réduit, mais ne peut pas être agrandi.

False

False

Maximize = False and Minimize = False

Le formulaire ne peut être ni réduit ni agrandi

Pour modifier un bouton système par programmation, appelez les propriétés du bouton désiré et attribuez-lui une valeur true ou false. Voici un exemple qui garantit que l'utilisateur ne peut pas optimiser le formulaire :

private  void InitializeComponent()
{
    Icon = new  System.Drawing.Icon(@"C:\Programs\RedBook.ico");
    Text = "Windows Fundmentals -  Programming";
    ControlBox = true;
    MinimizeBox = true;
    MaximizeBox = false;
}

Cela donnerait :

Control Box 

ApplicationApplication : Configuration des boutons du système d'un formulaire

  1. Pour vous assurer que l'utilisateur ne peut pas maximiser l'écran, sous la fenêtre Propriétés, cliquez sur le champ MaximizeBox pour révéler sa zone de liste déroulante et sélectionnez la valeur false
  2. Testez le programme
  3. College Park Auto Shop - Customer Repair Order

  4. Fermez le Formulaire et Retournez-le à Votre Environnement de Programmation

La Position du Formulaire

 

La Localisation du Formulaire

Lorsque vous créez une application et pendant que vous concevez le formulaire, il est fixé dans le coin supérieur gauche du Concepteur de formulaire. Ce n'est pas la position que l'écran aurait lorsqu'il s'exécutera. En fait, par défaut, une position aléatoire est définie pour le formulaire lorsqu'il apparait. Heureusement, vous pouvez spécifier l’endroit où le formulaire serait localisé lorsqu'il s’affiche et vous avez différentes alternatives.

Comme chaque contrôle sur une application, un formulaire a un parent : le bureau. Le bureau est la large zone du moniteur facilement visible lorsque l'ordinateur s'affiche. Tout sur l'ordinateur est localisé sur ce parent principal. De la même façon, un formulaire utilise le bureau pour déterminer son emplacement "physique". Sur cette base, lorsqu'une application est lancée, sa forme occupe une zone du bureau. Pour localiser ses enfants, le bureau utilise un repère cartésien dont l'origine se trouve dans le coin supérieur gauche de l'écran :

The Origin of the Windows default coordinate system

Les mesures horizontales se déplacent de l'origine vers la droite. Les mesures verticales se déplacent de l'origine vers le bas :

Axes of the Windows Coordinate System

La distance entre le bord gauche du Bureau/desktop's et la bordure gauche du formulaire/form's est représentée par la propriété Left du formulaire. La distance entre la bordure supérieure du bureau/desktop's et la bordure supérieure du formulaire/form's est spécifiée par la propriété Top. Par conséquent, les valeurs Left et Top sont connues comme emplacement du formulaire. Cela peut être illustré comme suit :

The Form Location

Pour spécifier l'emplacement d’un formulaire par défaut lorsque l'application est ouverte, dans la fenêtre Propriétés, cliquez sur le bouton + du champ Location pour afficher les valeurs de l'emplacement. Si une valeur d'une propriété est définie à 0, le compilateur sélectionnerait une valeur aléatoire pour elle lorsque le formulaire s'affiche. Dans le cas contraire, vous pouvez modifier chaque valeur à un numéro naturel valide.

Si vous souhaitez définir par programmation l'emplacement de l'écran, vous pouvez affecter une valeur à sa Left et/ou ses propriétés Top. Voici un exemple :

 public  class Exercise : System.Windows.Forms.Form
{
   public Exercise()
   {
   	InitializeComponent();
   }
  
   private void InitializeComponent()
   {
	Icon = new  System.Drawing.Icon(@"C:\Programs\RedBook.ico");
	Text = "Windows Fundmentals -  Programming";
       	Left = 228;
    	Top  = 146;
    }
}

Vous pouvez également affecter une variable Point à la propriété Location du formulaire. Voici un exemple :

private  void InitializeComponent()
{
	Icon = new  System.Drawing.Icon(@"C:\Programs\RedBook.ico");
	Text = "Windows Fundmentals -  Programming";
      	Location = new  System.Drawing.Point(228, 146);
}

La position de démarrage d'un formulaire

Au moment du design, les valeurs X et Y de la propriété Location vous permettent d'indiquer une position pour le formulaire. Au moment de l'exécution, les propriétés Left et Top atteignent le même objectif. Microsoft Windows fournit une autre position pour spécifier l'emplacement de l'écran par rapport à son parent. C'est le rôle de la propriété StartPosition de la classe Form, qui est une valeur de l'énumérateur FormStartPosition. Il fournit les cinq valeurs suivantes :

Vale Résultat
CenterParent

Le formulaire est placé au centre de son parent. Si la demande est faite d'un seul formulaire, cet écran pourrait être positionné dans le milieu du bureau

CenterScreen

Le formulaire est placé dans le milieu du Bureau même si ce formulaire fait partie d'une application qui est faite de diverses formes.

Manual

Le formulaire utilise les valeurs de X, Y, Left et/ou les propriétés Top de Location

WindowsDefaultLocation

Le système d'exploitation précisera la position du formulaire à l'aide d'une valeur connue dans Win32 comme CW_USEDEFAULT

Basé sur ce point, pour définir par défaut la position relative d'un formulaire lorsqu'il s'affiche, modifiez la valeur de sa zone de liste déroulante StartPosition dans la fenêtre Propriétés. Pour spécifier cette caractéristique lors de la création d'un formulaire par programmation, ou pour modifier cette propriété au moment de l'exécution, appelez l'énumération FormStartPosition, sélectionnez la valeur désirée et affectez-la à la propriété StartPosition de l'écran. Voici un exemple :

using  System;
using  System.Windows.Forms;

public  class Exercise : System.Windows.Forms.Form
{
    public Exercise()
    {
    	InitializeComponent();
    }
    
    private void InitializeComponent()
    {
   	Icon = new  System.Drawing.Icon(@"C:\Programs\RedBook.ico");
   	Text = "Windows Fundmentals -  Programming";
        StartPosition = FormStartPosition.WindowsDefaultLocation;
    }
}

La propriété StartPosition fournit une autre valeur liée à la taille. Par conséquent, nous ferons mention lorsque nous allons examiner la taille d'un formulaire.

ApplicationApplication : Définition par défaut de la position d'un formulaire

  1. Cliquez sur le milieu de l'écran pour vous assurer que cette option est sélectionnée
  2. Dans la fenêtre Propriétés, cliquez sur StartPosition pour révéler sa zone de liste déroulante. Cliquez sur la flèche de la zone de liste déroulante et sélectionnez CenterScreen
  3. Exécutez l'application pour afficher le résultat. Notez qu'il est centré sur l'écran.
  4. Fermez et revenez à votre environnement de programmation

L'état de Fenêtre d'un Formulaire

Lors de la création de votre application, vous pouvez configurer son formulaire (principal) pour être réduit ou agrandi lorsque l'application est lancée. Cette fonctionnalité est contrôlée par la propriété WindowState. La valeur par défaut de cette propriété est Normal, ce qui signifie que le formulaire s'affiche dans les mêmes dimensions qu'il a été conçu. Si vous souhaitez que le formulaire soit réduit ou agrandi au démarrage, dans la fenêtre Propriétés, modifiez la valeur souhaitée de la propriété WindowState Maximized ou Minimized.

Pour contrôler l'état de la fenêtre/window’s par programmation, affectez la valeur Maximized ou Minimized, qui sont des membres de l'énumérateur FormWindowState, à la propriété WindowState. Voici un exemple :

using System;
using System.Drawing;
using System.Windows.Forms;

public class Exercise : System.Windows.Forms.Form
{
    public Exercise()
    {
   	InitializeComponent();
    }
    
    private void InitializeComponent()
    {
    	Icon = new  Icon(@"C:\Programs\RedBook.ico");
    	Text = "Windows Fundmentals -  Programming";
        WindowState = FormWindowState.Maximized;
    }
}

Si vous souhaitez vérifier l'état d’une fenêtre avant d’agir, utilisez simplement une instruction conditionnelle pour comparer sa propriété WindowState avec les valeurs Normal, Maximized ou Minimized.

La Présence de la Barre des Tâches du Formulaire

Lorsqu'une application s'affiche sur l'écran avec d'autres applications, sa forme peut être positionnée au dessus ou derrière les formulaires d'autres applications. Cela est autorisé par les affectations multitâches. Lorsqu'un formulaire est masqué, la barre des tâches permet d'y accéder car l'écran serait représenté par un bouton. Cet aspect de formulaires est contrôlé par la propriété de type Boolean ShowInTaskbar. Sa valeur par défaut est True, qui indique que le formulaire serait représenté sur la barre des tâches par un bouton.

Si vous créez une application présentée par différentes formes, vous ne souhaiterez pas montrer toutes ses formes sur la barre des tâches. Habituellement la forme première ou principale serait suffisante. Pour empêcher un bouton d’un formulaire d’afficher la barre des tâches, définissez sa propriété ShowInTaskbar à False.

Voici un exemple :

private void InitializeComponent()
{
    Icon = new Icon(@"C:\Programs\RedBook.ico");
    Text = "Windows Fundmentals -  Programming";
    ShowInTaskbar = false;
}

Sauf si vous avez une bonne raison, et il est difficile de voir ce que cela pourrait être, vous ne devriez pas définir la propriété ShowInTaksbar de l'écran de la forme première ou principale d'une application sur false.

Les Mesures du Formulaire

 

La Taille du formulaire

La Taille d'un écran est la quantité d'espace qu'il occupe sur l'écran. Elle est exprimée par sa largeur et sa hauteur. La largeur d'un formulaire est la distance entre sa gauche à ses bordures de droite. La hauteur est la distance entre le haut et les bordures du bas d'un formulaire :


The Size of a Form

Lorsque vous créez un formulaire, il suppose une taille par défaut. Pour définir ou modifier la taille d'un formulaire, au moment du design, cliquez d’abord dessus pour le sélectionner. Ensuite, placez la souris sur sa droite, en bas ou en bas à droite des poignées. Cela modifie le curseur de la souris dans l'une des trois formes :

Resizing a form

Avant de positionner la souris, faites glisser dans la direction souhaitée.

Si vous ne souhaitez pas pouvoir redimensionner un formulaire et que vous souhaitez éviter cela par accident, au moment du design, définissez la propriété du formulaire Locked sur True. Si vous faites ceci :

  • Une petite image d'un verrou s'affiche dans le coin supérieur gauche de l'écran :
  • L'écran devient entouré d'un rectangle avec une bordure noire
  • Les poignées de redimensionnement du formulaire disparaissent

The Locked property of the form set to True

Parce que le verrouillage est uniquement une caractéristique de conception, ce n'est pas une propriété réelle de la classe Form. Par conséquent, vous ne pouvez pas l'utiliser pour verrouiller un formulaire au moment de l'exécution. Dans les mots d'ordre, vous ne pouvez pas utiliser la fonction de verrouillage pour empêcher l'utilisateur de redimensionner un formulaire.

Outre le redimensionnement de l'écran en faisant glisser une de ses poignées, pour modifier la taille d'un formulaire, sélectionnez-le et, dans la fenêtre Propriétés, cliquez sur le bouton du champ Size +. Puis tapez la valeur souhaitée pour Width et la valeur souhaitée pour Height. Les valeurs doivent être des nombres naturels.

Pour modifier par programmation la taille d'un formulaire, affectez les valeurs souhaitées à l’une ou l’autre des propriétés de Width et Height. Voici un exemple :

private  void InitializeComponent()
{
	Icon = new  Icon(@"C:\Programs\RedBook.ico");
	Text = "Windows Fundmentals -  Programming";
   	Width = 425;
   	Height = 308;
}

Alternativement, vous pouvez affecter une valeur Size à la propriété Size de l'écran. Voici un exemple :

private  void InitializeComponent()
{
    Icon = new  Icon(@"C:\Programs\RedBook.ico");
    Text = "Windows Fundmentals -  Programming";
    Size = new Size(425,  308);
}

Si vous souhaitez le système d'exploitation pour spécifier la taille de l'écran, définissez sa propriété StartPosition à WindowsDefaultBounds. Dans ce cas, une valeur appelée CW_USEDEFAULT pourrait être affectée à la fois à Width qu’aux prooriétés Height.

ApplicationApplication : Définition par défaut de la taille du formulaire

  1. Positionnez la souris sur le petit carré de la bordure droite de l'écran.
  2. Cliquez et faites glisser dans la bonne direction afin de vérifier que la légende dans la barre de titre peut apparaître complètement
     
    Resizing a form
  3. Relâchez le bouton de la souris

Les bordures du formulaire

Un formulaire peut être fait pour ressembler à un hôte rectangulaire régulier d'une icône de système et les boutons du système. En fonction de vos objectifs, vous pouvez également effectuer un formulaire apparaissant comme une boîte de dialogue ou une fenêtre dockable. Les frontières d'un formulaire sont contrôlées par la propriété FormBorderStyle.

Si vous définissez les propriétés MaximizeBox et MinimizeBox sur False, nous avons vu que la forme aurait uniquement le bouton Fermer système, mais l'écran peut encore être redimensionné. Si vous souhaitez que le formulaire affiche uniquement le bouton Close système et empêche l'utilisateur de redimensionner, définissez sa propriété FormBorderStyle à FixedDialog. Voici un exemple :

private  void InitializeComponent()
{
    Icon = new Icon(@"C:\Programs\RedBook.ico");
    Text = "Windows Fundmentals -  Programming";
    
    FormBorderStyle =  FormBorderStyle.Fixed3D;
}

Cela donnerait :

 
      

Une fenêtre de l'outil est une forme équipée d'une barre de titre abrégée, aucune icône et seulement un petit bouton Fermer système. Il existe deux types de fenêtres outil.
  • Une fenêtre d'outil est appelée fixe si l'utilisateur ne peut pas redimensionner. Dans ce cas, la propriété FormBorderStyle du formulaire est définie à FixedToolWindow :
     
    FormBorderStyle = FormBorderStyle.FixedToolWindow ;
  • Une fenêtre d'outil est appelée considérable si elle permet à l'utilisateur de redimensionner. Pour obtenir une telle forme, définissez sa propriété FormBorderStyle à SizableToolWindow :
     
    FormBorderStyle = FormBorderStyle.SizableToolWindow ;

Vous pouvez également créer un formulaire sans frontières en affectant None à la propriété FormBorderStyle. Si vous faites cela, assurez-vous de fournir à l'utilisateur un moyen pour fermer l'écran ; sinon...

A Tool Window

L'Espace Client d'un Cormulaire

 

Introduction

Lorsqu'un formulaire a été créé, vous pouvez lui ajouter des contrôles Windows. Ces contrôles peuvent être positionnés uniquement dans une zone spécifique, le corps de l'écran. Le corps s'étend de la bordure gauche de l'écran, à l'exclusion de la frontière elle-même, de la bordure droite de l'écran, à l'exclusion de la frontière. Il couvre également du côté supérieur, juste sous la barre de titre, à la bordure inférieure, à l'exclusion de la bordure inférieure de l'écran. La zone du formulaire mise à la disposition des contrôles ajoutés est appelée zone client :

Si un contrôle est positionné sur un formulaire, InstallationDesigner utilise un système de coordonnées dont l'origine est positionnée sur la section en haut à gauche de la zone client (juste sous la barre de titre). L'axe x déplace depuis l'origine vers la gauche. Les axes y descendent de l'origine :

The origin of the coordinate system and its axes

La distance entre le bord gauche de la zone cliente et la bordure gauche du contrôle est la propriété Left. La distance entre le bord supérieur de la zone cliente et la bordure supérieure du contrôle est la propriété Top. Celles-ci peuvent être illustrées comme suit :


Pour connaître la quantité d'espace d'un formulaire disponible pour le contrôle de son enfant, vous pouvez accéder à la propriété du formulaire ClientSize.

La couleur d'arrière-plan d'un formulaire

La zone client d'un formulaire est peinte avec une couleur spécifiée par le système d'exploitation. Pour modifier la couleur de ce que vous voulez, vous pouvez utiliser le champ BackColor de la fenêtre Propriétés. Si vous cliquez sur la flèche de la zone de liste déroulante, elle affiche une feuille de propriétés avec trois onglets qui divisent la couleur dans les catégories :

Back Color

Back Color

Back Color

Pour modifier par programmation la couleur, attribuez une couleur de la structure de la couleur à la propriété BackColor. Voici un exemple :

public  class Exercise : System.Windows.Forms.Form
{
    public Exercise()
    {
    	InitializeComponent();
    }
    
    private void InitializeComponent()
    {
    	Icon = new  Icon(@"C:\Programs\RedBook.ico");
    	Text = "Windows Fundmentals";
       	BackColor = Color.BurlyWood;
    }
}

Cela donnerait :

 Back Color 
      

Si vous regardez attentivement, vous remarquerez que seule la zone client du formulaire est peinte. Les frontières, car elles ne font pas partie de la zone client, ne sont pas peintes.

L'image d'arrière-plan d'un formulaire

 

Introduction

Si vous préférez couvrir la zone client avec une image, utilisez la propriété BackgroundImage. Pour spécifier l'image d'arrière-plan au moment du design, dans la fenêtre Propriétés, cliquez sur BackgroundImage et cliquez sur son bouton de sélection. Ceci ouvririrait la boîte de dialogue Sélectionner des ressources. Pour rechercher une photo, cliquez sur un des boutons d'importation, sélectionnez l'image dans le dossier choisi et cliquez sur Ouvrir. La photo devrait être importée dans la boîte de dialogue :

Select Resource

Vous pouvez ensuite sélectionner et cliquez sur OK.

Pour définir par programmation ou modifier l'image utilisée comme arrière-plan, déclarez et initialisez un pointeur vers la classe bitmap. Puis affectez-la à la propriété BackgroundImage. Voici un exemple :

private void InitializeComponent()
{
	Icon = new Icon(@"C:\Programs\RedBook.ico");
	Text = "A Day at the Beach";
	MaximizeBox = false;

   	BackgroundImage =  Image.FromFile(@"E:\Programs\beach.jpg");
}
Form Background 
      

Options d'image d’arrière-plan

Il existe deux façons que vous pouvez utiliser une image d'arrière-plan sur un formulaire. Si l'image est plus grande que la zone client, vous pouvez remplir la zone cliente ensemble avec l'image. Si l'image est plus étroite et/ou plus courte que celle de la photo, vous pouvez redimensionner ou répéter. Pour vous aider à prendre cette décision, la classe Form est équipée d'une propriété nommée BackgroundImageLayout.

La propriété Form.BackgroundImageLayout est basée sur l'énumération ImageLayout. Ses valeurs sont :

  • None : la photo s'affiche une fois, depuis l'origine de haut-gauche de la zone cliente. Voici un exemple :
    private void InitializeComponent()
    {
        Icon = new    Icon(@"C:\Programs\RedBook.ico");
        Text = "Fire Wall";
        MaximizeBox = false;
        
        BackgroundImage =    Image.FromFile(@"E:\Programs\FireWall.png");
        BackgroundImageLayout =    ImageLayout.None;
    }

  • None : la photo s'affiche une fois, depuis l'origine de haut-gauche de la zone cliente du formulaire. Voici un exemple :
    private void    InitializeComponent()
    {
        Icon = new    Icon(@"C:\Programs\RedBook.ico");
        Text = "Fire Wall";
        MaximizeBox = false;
    
        BackgroundImage =    Image.FromFile(@"E:\Programs\FireWall.png");
            BackgroundImageLayout =    ImageLayout.None;
    }

  • Center : la photo s'affiche une fois, dans le milieu-centre de la zone cliente du formulaire. Voici un exemple :
    private void    InitializeComponent()
    {
            Icon = new    Icon(@"C:\Programs\RedBook.ico");
            Text = "Fire Wall";
            MaximizeBox = false;
    
            BackgroundImage =    Image.FromFile(@"E:\Programs\FireWall.png");
            BackgroundImageLayout =    ImageLayout.Center;
    }

    BackgroundImageLayout = ImageLayout.Center;

  • Tile : la photo va commencer à s’afficher à l'origine en haut à gauche de la zone cliente. Elle va ensuite se répéter horizontalement, suivie de la ligne suivante, puis la suivante et ainsi de suite. Voici un exemple :  
    private void    InitializeComponent()
    {
            Icon = new    Icon(@"C:\Programs\RedBook.ico");
            Text = "Fire Wall";
            MaximizeBox = false;
            
            BackgroundImage = Image.FromFile(@"E:\Programs\FireWall.png");
            BackgroundImageLayout =    ImageLayout.Tile;
    }

    BackgroundImageLayout = ImageLayout.Tile

  • Stretch : la photo est tout d'abord placée au milieu de la zone cliente de l'écran, puis elle va s'étirer pour occuper la zone cliente entière et ainsi de suite. Voici un exemple :
    private void InitializeComponent()
    {
            Icon = new    Icon(@"C:\Programs\RedBook.ico");
            Text = "Fire    Wall";
            MaximizeBox = false;
               
            BackgroundImage =    Image.FromFile(@"E:\Programs\FireWall.png");
            BackgroundImageLayout =    ImageLayout.Stretch;
    }

  • Zoom : le compilateur saura quelle mesure est plus petite entre la largeur et la hauteur de la zone cliente du formulaire. Cette plus petite mesure sera utilisée pour la largeur et la hauteur de l'image. Voici un exemple :
    private void    InitializeComponent()
    {
        Icon = new Icon(@"C:\Programs\RedBook.ico");
        Text = "Fire Wall";
        MaximizeBox = false;
                
        BackgroundImage = Image.FromFile(@"E:\Programs\FireWall.png");
        BackgroundImageLayout = ImageLayout.Zoom;
    }

  • Si la largeur du formulaire est inférieure à sa hauteur, alors l'image est placée au milieu de l'écran :

  • Si la hauteur du formulaire est inférieure à sa largeur, alors l'image est placée au centre de l'écran :

Les Méthodes et événements pour gérer un Formulaire

 

Création de formulaire

Le formulaire est implémenté par la classe Form de l'espace de noms System.Windows.Forms. La classe Form est équipée d'un constructeur qui permet de créer dynamiquement. Après qu'un formulaire a été créé, il doit être chargé à s’afficher à l'écran. Lorsqu'un formulaire est en cours de chargement, il déclenche l'événement Load() qui est de type EventArgs. Cet événement est déclenché lorsqu'un formulaire est sur le point d'être affiché pour la première fois. Par conséquent, il peut être utilisé pour effectuer des initialisations de dernière minute.

Activation de formulaire

Lorsque deux ou plusieurs formulaires sont en cours d'exécution sur l'ordinateur, un seul peut recevoir la contribution de l'utilisateur. Cela signifie que seul un formulaire peut effectivement être utilisé directement à un moment donné. Une telle fenêtre a une barre de titre avec la couleur identifiée dans le panneau comme fenêtre active. L'autre ou les autres fenêtre (s), le cas échéant, affiche (nt) la/leur barre de titre avec une couleur appelée fenêtre inactive.

Pour gérer ce paramètre, les fenêtres sont organisées dans un repère tridimensionnel et elles sont progressivement positionnées sur la coordonnée Z, qui définit l’origine (0, 0, 0) sur l'écran (sur le coin supérieur gauche de l'écran) avec la coordonnée Z provenant de l'écran vers vous.

Afin d'utiliser une forme autre que celle qui est active, vous devez l’activer. Pour le faire, vous pouvez appeler la méthode Activate(). Sa syntaxe est la suivante :

public void Activate();

Lorsqu'un formulaire est activé, il déclenche l'événement Activated, ce qui est un type d'événement EventArgs.

Désactivation de formulaire

S'il y a plus d'un formulaire ou une application sur l'écran, un seul peut être en face des autres et pouvoir recevoir les commentaires des autres. Si un formulaire n'est pas actif et que vous souhaitez le mettre en haut de la page, vous devez l'activer, ce qui déclenche l'événement Activated(). Lorsqu'un formulaire est en cours d'activation, celui qui était en haut deviendrait désactivé. Le formulaire qui était au dessus, car il perd le focus, déclencherait l'événement Deactivate() qui est un type EventArgs.

Fermeture de l'écran

Lorsque l'utilisateur a terminé d’utiliser un formulaire, il ou elle doit pouvoir le fermer. La Fermeture d'un formulaire est rendue possible par un simple appel à la méthode Close(). Sa syntaxe est la suivante :

public void Close();

Lorsque cette méthode est appelée, le processus de fermeture d'un formulaire commence. Pour l'instant, l'événement Closing() est déclenché. L'événement Closing() est implémenté par la classe CancelEventArgs par le délégué CancelEventHandler. La classe CancelEventArgs est équipée seulement de la propriété Cancel. La propriété CancelEventArgs.Cancel vous permet d'annuler ou de continuer avec la fermeture de l'écran. Si vous définissez la propriété CancelEventArgs.Cancel sur true, l'événement sera ignoré comme s'il n'était pas déclenché. Si vous souhaitez que l'événement continue la fermeture de l'écran, vous pouvez définir cette propriété sur false. Cet événement se produit avant que le formulaire soit effectivement fermé, vous donnant le temps de laisser la forme fermée, d’empêcher la fermeture du formulaire ou prendre toute autre mesure nécessaire.

Après qu'un formulaire ait été fermé, un événement Closed() est déclenché. Bien que cette méthode puisse être utilisée pour fermer toute forme d'une application, si elle est appelée par le formulaire principal, elle ferme également l'application.

 
 
 
 

Précédente Copyright © 2004-2011, yevol.com Suivant