Home

Les Méthodes et les Événements des Contrôles Windows

 

Les Principes de Base des Méthodes de Contrôle

 

Introduction

Une méthode est une procédure créée comme membre d'une classe. Les Méthodes sont utilisées pour accéder ou manipuler les caractéristiques d'un objet ou d'une variable. Il existe principalement deux catégories de méthodes que vous utiliserez dans vos classes :

  • Si vous utilisez un contrôle comme l'un de ceux fournis par la boîte à outils, vous pouvez appeler n'importe laquelle de ses méthodes publiques. Les exigences d'une telle méthode dépendent de la classe utilisée
  • Si aucune des méthodes existantes ne peut exécuter votre tâche souhaitée, vous pouvez ajouter une méthode à une classe.

La Construction et la Destruction d'un Contrôle

Comme vous le savez de l'étude du langage c#, chaque classe possède une méthode fondamentale appelée un constructeur par défaut. Chaque contrôle du .NET Framework est basé sur une classe qui possède un constructeur par défaut et la plupart de ces classes ont un seul constructeur : la valeur par défaut. Le constructeur par défaut permet d'instancier la classe sans nécessairement l'initialiser. Pour l'utiliser, vous devez connaître le nom du contrôle à utiliser car chaque contrôle porte le même nom que la classe. Voici un exemple :

using System;
using System.Windows.Forms;

public class Exercise :  System.Windows.Forms.Form
{
      private  Button btnReset;

      public  Exercise()
      {
               InitializeComponent();
      }

      #region  Section Used to Initialize Controls
      private  void InitializeComponent()
      {
               btnReset = new Button();
      }
      #endregion
      
      static  void Main()
      {
              Application.Run(new  Exercise());
      }
  }

Si vous ne prévoyez pas d'utiliser directement un contrôle à partir de .NET Framework, vous pouvez également créer votre propre classe dérivée de la classe du contrôle, comme nous l'avons mentionné dans les leçons précédentes.

Comme mentionné dans la leçon précédente, après l'instanciation d'un contrôle, il est disponible, mais l'utilisateur ne peut pas voir. Chaque contrôle qui agit comme un parent d'un autre contrôle possède une propriété appelée contrôle. Cette propriété, qui est un type de ControlCollection, est équipée d'une méthode Add(). Si vous souhaitez afficher le nouveau contrôle à l'utilisateur, vous devez le transmettre à la méthode Control.Controls.Add(). Voici un exemple :

using System;
using System.Windows.Forms;

public class Exercise :  System.Windows.Forms.Form
{
        private Button btnReset;

        public Exercise()
        {
                 InitializeComponent();
        }
        
        #region Section Used to Initialize Controls
        private void InitializeComponent()
        {
                 btnReset  = new Button();
                 Controls.Add(btnReset);
        }
        #endregion
        
        static  void Main()
        {
                Application.Run(new Exercise());
        }
}

Le contrôle s'affiche à l'utilisateur.

Après l'utilisation d'un contrôle, il doit être détruit. En C++, cela se fait traditionnellement à l'aide de l'opérateur delete dans le destructeur du parent de tous les contrôles, ce qui pourrait être un formulaire. Un autre détail des contrôles Windows est qu'ils utilisent ou consomment des ressources de l'ordinateur au cours de leur vie. Lorsque les contrôles ne sont pas utilisés, comme lorsque leur application ferme, ces ressources devraient être libérées et remises au système d'exploitation pour les rendre disponibles aux autres contrôles. Cette tâche peut être effectuée à l'aide de la méthode Dispose() de la classe Control, qui peut ensuite être remplacée par ses contrôles enfants. La syntaxe de la méthode Control.Dispose() est :

protected override void Dispose(bool disposing);

Cette méthode prend un argument, disposing, qui indique comment les ressources seraient libérées. Si cet argument est transmis avec la valeur false, uniquement les ressources non managées seraient libérées. Si elle est transmise comme true, alors les ressources gérées seraient libérées.

La Visibilité du contrôle

Dans la leçon précédente, nous avons vu que vous pouvez appeler la propriété Visible pour masquer un contrôle visible ou pour afficher un contrôle masqué. Outre la propriété Visible, vous pouvez également afficher un contrôle à l'aide de la méthode Show(). Sa syntaxe est la suivante :

Public Sub Show();

Lorsque vous utilisez cette méthode, si le contrôle est visible, rien ne se passerait. Si elle a été masquée, alors elle serait dévoilée. Dans l'exemple suivant, une zone de texte nommée textBox1 est demandée pour s'afficher :

private void button1_Click(object sender,  EventArgs e)
{   
    this.textBox1.Visible  = false;
}

private void button2_Click(object sender,  EventArgs e)
{
      this.textBox1.Show();
}

En interne, la méthode Show() définit la propriété Visible sur true. Nous avons également vu que, pour masquer un contrôle, vous pouvez définir sa propriété Visible sur False. De la même façon, pour masquer un contrôle, vous appelez la méthode Control.Hide(). Sa syntaxe est la suivante :

Public Sub Hide();

Dans l'exemple suivant, la visibilité d'une zone de texte nommée textBox1 est activée/désactivée par l'utilisateur qui clique sur un bouton nommé button1 :

private void button1_Click(object sender, EventArgs  e)
{
    if( textBox1.Visible == true )
        textBox1.Hide();
    else
        textBox1.Show();
}

N'oubliez pas qu'un contrôle de masquage ne peut pas fermer ou détruire.

Le focus du contrôle

Une fois qu'un contrôle est visible, l'utilisateur peut l'utiliser. Certains contrôles ne permettent à l'utilisateur qu'à lire leur texte ou afficher ce qu'ils affichent. D'autres contrôles permettent à l'utilisateur de récupérer leur valeur ou de la modifier. Pour effectuer ces opérations, l'utilisateur doit tout d'abord donner le focus au contrôle. L'accent est un aspect visuel qui indique qu'un contrôle est prêt à recevoir l'entrée de l'utilisateur. Divers contrôles ont différentes manières d'exprimer qu'ils ont reçu le focus.

Les Contrôles basés sur le bouton indiquent qu'ils ont le focus en dessinant une bordure épaisse et un rectangle autour de leur légende. Dans l'illustration suivante, le bouton de droite a le focus :

Focus

Un contrôle basé sur le texte indique qu'il a le focus en affichant un curseur clignotant. Un contrôle basé sur la liste indique qu'il a le focus lorsqu'un de ses éléments a un rectangle en pointillé :

Focus

Pour donner le focus à un contrôle, l'utilisateur peut appuyer sur la touche onglet. Pour donner le focus par programmation à un contrôle, appelez la méthode Focus(). Voici un exemple :

private void button2_Click(object sender,  EventArgs e)
{
    this.textBox1.Focus();
}

Le Z-order des contrôles

Dans la leçon précédente, nous avons vu comment vous pouvez positionner des contrôles visuellement ou manuellement. Dans certains cas, vous vous retrouvez avec un contrôle placé au-dessus de l'autre. Bien entendu, le premier recours qui vient à l'esprit se composerait de passer d'un des contrôles à l'autre. Cela voudrait dire également parfois que vous auriez à agrandir ou à accroître le conteneur des contrôles. Il existe des situations dans lesquelles vous ne pouvez pas ou vous ne voulez pas redimensionner le parent : votre seule solution est d'avoir un contrôle au dessus de l'autre. Heureusement, face à cette situation, vous pouvez indiquer, le cas échéant, quel contrôle à quelle heure doit être affiché à l'utilisateur.

Lorsqu'un contrôle est placé au-dessus de l'autre, ils utilisent un troisième axe dont l'origine, comme les autres axes, est sur le coin supérieur gauche du parent. Ce troisième axe, également considéré comme l'axe z est orienté afin qu'il se déplace du moniteur vers l'utilisateur. Le système d'exploitation est chargé de positionnement et des objets de dessin à l'écran. Comme programmeur, vous pouvez diriger le système d'exploitation quant à l'objet qui doit être dessus et quel objet devrait être derrière. Pour prendre en charge ces modifications, la classe Control utilise deux méthodes que ses enfants appropriés tirent également.

Lorsqu'un contrôle est placé au-dessus d'un autre contrôle, cela entraîne un contrôle partiellement ou complètement masqué. Si vous souhaitez que le contrôle A modifie son ordre z et devienne le dessus du contrôle B, vous pouvez appeler sa méthode BringToFront(). La syntaxe de cette méthode est :

public void BringToFront();

D'autre part, si un control B est positionné au dessus d'un contrôle A, si vous souhaitez que le contrôle B vienne se placer derrière le control A, vous pouvez appeler sa méthode control B's SendToBack(). Sa syntaxe est :

public void SendToBack();

Après que le contrôle ait été positionné, à tout moment, lorsque vous accédez à un contrôle, si vous voulez savoir si ce contrôle est l'objet le plus haut, vous pouvez appeler sa méthode GetTopLevel(). Sa syntaxe est la suivante :

proteced bool GetTopLevel();

Création de nouvelles méthodes

Les crontrôles Windows disponibles à partir du .NET Framework et que nous allons utiliser tout au long de ce site sont entièrement fonctionnels. Ils sont équipés de diverses méthodes prêtes à être utilisées. Bien sûr, aucune bibliothèque ne peut certainement fournir chaque type de méthode unique que chaque programmeur utiliserait. Pour cette raison, il ne sera pas rare que vous ayez besoin d'une méthode qui n'est pas disponible pour un contrôle que vous utilisez. De la même façon, lorsque vous créez une application Windows qui est basée sur une classe Form, vous aurez probablement besoin d'une méthode qui n'est pas définie dans la classe Form. Dans ce cas, vous pouvez créer vos propres et nouvelles méthodes.

Une méthode est créée comme une procédure normale. Si vous souhaitez l'ajouter à un formulaire, vous pouvez ouvrir l'éditeur de code et écrire votre procédure en dehors de toute procédure existante. Voici un exemple :

/// <summary>

       ///  The main entry point for the application.
       ///  </summary>
       [STAThread]
       static  void Main()
       {
               Application.Run(new  Form1());
       }
               
       double CalculateRectangleArea(Rectangle  Recto)
       {
             return  Recto.Width * Recto.Height;
        }
    }
}

De la même manière, si vous dérivez une des classes existantes parce que vous souhaitez obtenir un contrôle personnalisé, vous pouvez déclarer une nouvelle méthode comme bon vous semble et l'utilisez convenablement.

Probablement la meilleure façon est de laisser l'éditeur de code insérer la nouvelle méthode en fonction de vos spécifications. Pour le faire, dans l'affichage de classes, dévéloppez tout d'abord le nom du projet. Puis, cliquez sur le nom de la classe où vous souhaitez ajouter une nouvelle méthode, positionnez la souris sur Ajouter, puis cliquez sur Ajouter la méthode. Ceci ouvrirait la boîte de dialogue Assistant de méthode c#, vous pouvez remplir et cliquez sur Terminer, une fois que le corps de la méthode a été définie par vous.

L'Utilisation des bibliothèques externes

 

Introduction

Les contrôles de Windows présentés dans le .NET Framework sont extrêmement variés et fournissent toutes les fonctionnalités régulières nécessaires dont une application normale aurait besoin. Ils le font par le biais de diverses propriétés et des méthodes différentes. Pour améliorer leurs fonctionnalités et accélérer le développement d'application, vous pouvez créer de nouveau votre propre bibliothèque ou utiliser une bibliothèque créée dans un autre langagage.

Les Fonctions de Microsoft Visual Basic

Microsoft Visual Basic offre un très grand ensemble de fonctions. Vous pouvez utiliser la plupart de ces fonctions dans votre application si vous suivez les étapes appropriées. Pour utiliser une fonction Microsoft Visual Basic dans votre application, vous devez vous référer à sa bibliothèque. La plupart (sinon toutes) des fonctions de Visual Basic sont créées dans l'assemblage de Microsoft.VisualBasic.dll, mais elles pourraient être dans les espaces de noms différents. Sur cette base, vous pouvez inclure n'importe quelle fonction Visual Basic dans votre programme.

L'Utilisation d'une bibliothèque

Si le .NET Framework n'est pas la classe que vous recherchez, vous pouvez en créer une et vous pouvez l'utiliser maintes et maintes fois dans différents programmes. Vous pouvez même créer une classe commerciale et être en mesure de distribuer ou vendre. Pour rendre cela possible, vous pouvez "package" une ou plusieurs classes dans une bibliothèque. Une bibliothèque est un programme qui contient des classes et/ou d'autres programmes que d'autres ressources peuvent utiliser. Un tel programme est créé avec la même approche que les programmes que nous avons faits jusqu'à présent. Puisqu' une bibliothèque n'est pas un fichier exécutable, elle n'a pas besoin de la fonction main(). Une bibliothèque a généralement l'extension .dll.

Une bibliothèque peut être faite d'un seul fichier ou autant de fichiers si nécessaire. Un fichier qui fait partie d'une bibliothèque peut contenir une ou plusieurs classes. Chaque classe doit implémenter un comportement qui peut être éventuellement utile et accessible aux autres classes. Les classes dans une bibliothèque sont créées exactement comme celles que nous avons utilisées jusqu'à présent. Tout dépend de comment vous compilez.

Pour créer une bibliothèque, démarrez en saisissant son code dans un fichier texte. Une fois que la bibliothèque est prête à compiler, à l'invite, tapez :

csc /target:library NameOfFile.cs

et appuyez sur Entrée. Après cela, on créerait une bibliothèque avec le nom du fichier et le fichier d'extension .dll. Si vous souhaitez un nom personnalisé, utilisez la syntaxe suivante :

csc /target:library /out:DesiredNameOfLibrary.dll NameOfFile.cs

L'Utilisation de Visual C++ / CLI Library

L'un des objectifs les plus importants recherchés dans .NET est de permettre aux différentes langues de collaborer, telles que le partage de code. Une façon, que cela peut se produire est de pouvoir utiliser la fonctionnalité d'une langue vers une autre. A titre d'illustration, nous avons vu précédemment que vous pourriez utiliser la riche bibliothèque de fonctions de Visual Basic dans une application c#. Comme aucune bibliothèque n'est jamais complète, vous pouvez encore avoir besoin de fonctionnalité qui n'est pas facile à trouver. En outre, vous pouvez travailler avec une équipe de programmeurs C++ qui ont déjà créé un ensemble de fonctions ou des opérations complexes. Vous devez être en mesure d'utiliser ce code existant.

Dans les années précédentes, c'était un défi de créer une bibliothèque, en particulier en C++. Heureusement, Microsoft Visual C++ rend maintenant particulièrement facile d'en créer un, car un Assistant vous assiste hautement. Pour créer une bibliothèque, affichez d'abord la boîte de dialogue Nouveau projet. Après avoir spécifié Visual C++, dans la liste du milieu, cliquez sur ClassLibrary et donnez-lui un nom. Dans le corps du fichier, vous pouvez créer les classes ou les fonctions comme bon vous semble.

L'Utilisation de la bibliothèque de Win32

Le système d'exploitation Microsoft Windows a été initialement écrit en C, la langue mère de C++ et c# (également Java et JavaScript). Pour permettre aux programmeurs de créer des applications, Microsoft a publié une bibliothèque appelée Win32. Il s'agit d'une série de fonctions et de classes, etc., que vous aviez précédemment eu à utiliser. Comme les temps ont changé, vous ne devez plus utiliser exclusivement Win32 pour créer une application Windows.

Néanmoins, Win32 est encore partout, et il n'est pas entièrement évitable car beaucoup ou certaines des actions que vous souhaiteriez effectuer dans une application Windows sont toujours disponibles uniquement dans Win32. Heureusement, dans la plupart des cas, il n'est pas toujours difficile d'utiliser certaines de ces fonctions dans une application c#, aussi longtemps que vous respectez certaines règles. Voici un exemple :

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("Kernel32.dll")]
    public static extern bool SetConsoleTitle(string strMessage);

    static int Main()
     {
         SetConsoleTitle("C# Programming");
         return  0;
     }
}

L'examen des délégués

 

Introduction

Le concept de fonction de pointeur C et C++ est très utile lors de la programmation pour les systèmes d'exploitation Microsoft Windows, car la bibliothèque Win32 s'appuie sur le concept de fonctions de rappel pour traiter les messages. Pour cette raison et en raison de leurs fonctions, les fonctions de rappel ont été effectuées dans le .NET Framework, mais elles ont été définies avec le nom de délégué.

Un délégué est un type spécial de variable définie par l'utilisateur qui est déclaré dans le monde entier, comme une classe. En fait, un délégué est créé comme une interface mais apparaissant comme une méthode. Sur cette base, un délégué fournit un modèle pour une méthode, comme une interface fournit un modèle pour une classe. Comme une interface, un délégué n'est pas défini. Son rôle est de montrer à quoi ressemblerait une méthode utile. Pour prendre en charge ce concept, un délégué peut fournir toutes les informations nécessaires qui seraient utilisées sur une méthode. Cela inclut un type de retour, aucun argument ou un ou plusieurs arguments.

La Déclaration d'un délégué

Pour déclarer un délégué, vous utilisez le mot-clé delegate. La formule de base utilisée pour créer un délégué est :

[attributes] [modifiers] delegate result-type identifier ([formal-parameters]);

Le facteur d'attributs peut être un attribut normal C#.

Le modificateur peut être un ou une combinaison appropriée des mots-clés suivants : new, public, private, protected ou internal.

Le mot-clé delegate est requis.

Le ReturnType peut être tous les types de données que nous avons utilisés jusqu'à présent. Il peut également être un type void ou le nom d'une classe.

Le nom doit être un nom valide pour une méthode.

Puisqu'un délégué est un type de modèle pour une méthode, vous devez utiliser des parenthèses, requis pour chaque méthode. Si cette méthode ne prendra pas d'argument, vous pouvez laisser les parenthèses vides.

Après avoir déclaré un délégué, n'oubliez pas qu'il fournit seulement un modèle pour une méthode, pas une réelle. Afin de l'utiliser, vous devez définir une méthode qui entraînerait une affectation que la méthode est supposée effectuer. Cette méthode doit avoir le même type de retour et le même argument (de nombre), le cas échéant. Par exemple, le délégué déclaré ci-dessus est de type void et il ne prend aucun argument. Après l'implémentation de la méthode, vous pouvez l'associer au nom du délégué. Pour ce faire, où vous voulez utiliser la méthode, déclarez tout d'abord une variable du type du délégué à l'aide de l'opérateur new. Les parenthèses du constructeur transmettent le nom de la méthode. La déclaration donne un sens au délégué. Pour effectivement utiliser la méthode, appelez le nom du délégué comme s'il s'agissait d'une méthode définie.

Voici un exemple qui utilise un délégué :

using System;
using System.Windows.Forms;

delegate void dlgSimple();
class Exercise : Form
{
       public  Exercise()
       {
                dlgSimple Announce = new dlgSimple(Welcome);
                Announce();
                this.InitializeComponent();
        }
        
        private static void Welcome()
        {

        }

        private  void InitializeComponent()
        {
        }

        static  void Main()
        {
                Exercise  form;
 
form  = new Exercise();
  Application.Run(form);
  }
  }

Vous pouvez également déclarer un délégué qui retourne une valeur. Lorsque vous définissez une méthode qui serait associée au délégué, n'oubliez pas que cette méthode doit renvoyer le même type de valeur. Voici un exemple :

using System;
using System.Windows.Forms;

delegate double Addition();

class Exercise : Form
{
       public  Exercise()
       {
                Addition   Add = new Addition(Plus);
                this.InitializeComponent();
                TextBox  txtBox = new TextBox();
                Controls.Add(txtBox);
                txtBox.Text  = Add().ToString();
      }

      private static double Plus()
      {
              double  a = 248.66, b = 50.28;
              return  a + b;
      }

      private  void InitializeComponent()
      {
      }

      static  void Main()
      {
              Exercise  form;
              form  = new Exercise();
              Application.Run(form);
      }
}

Cela donnerait :

Delegate

Les délégués et les classes

Dans les introductions ci-dessus, nous avons associé les délégués uniquement aux méthodes de la classe principale. Parce que les délégués sont généralement déclarés globalement à l'extérieur d'une classe, ils peuvent être associés à une méthode de n'importe quelle classe, à condition que la méthode ait le même type de retour (et le(s) même(s) argument(s)) (nombre de) que le délégué. Lorsque nous avons créé les méthodes de la classe principale, nous les avons définies comme statiques, puisque toutes les méthodes de la classe principale doivent être déclarées statiques.

Les méthodes de toute classe peuvent également être associées aux délégués. Voici un exemple de deux méthodes associées à un délégué commun :

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 WindowsApplication2
{
    delegate double Multiplication();
    public class Cube
    {
        private double _side;
        public double Side
        {
            get { return _side; }
            set { _side = value; }
        }
        
        public Cube()
        {
            _side = 0;
        }
        
        public Cube(double s)
        {
           _side = s;
        }

         public double Area()
         {
             return 6 * Side * Side;
         }

         public double Volume()
         {
             return Side * Side * Side;
         }
    }

    public partial class Form1 : Form
    {
        public Form1()
        {
            Cube  SmallBox = new Cube(25.58);
            Multiplication AreaDefinition = new Multiplication(SmallBox.Area);
            Multiplication VolDefinition = new Multiplication(SmallBox.Volume);
            
            InitializeComponent();
            
            txtSide.Text  = SmallBox.Side.ToString();
            txtArea.Text = AreaDefinition().ToString();
            txtVolume.Text = VolDefinition().ToString();
       }
    }
}

Cela donnerait :

Delegate

La Compositions de délégués

Une des caractéristiques qui définissent les délégués en dehors des pointeurs de fonction C/C++ est qu'un délégué peut être ajouté à un autre en utilisant l'opération +. On parle alors de composition. Cela s'effectue en ajoutant une variable de délégué à un autre, comme dans a = b + c.

Le délégué qui prend plus d'un argument

Si vous souhaitez associer une méthode qui prend des arguments à un délégué, lorsque vous déclarez le délégué, fournissez l'/les argument (s) nécessaire (s) entre parenthèses. Voici un exemple d'un délégué qui prend deux arguments (et renvoie une valeur) :

delegate double Addition(double x, double  y);

Lors de la définition de la méthode associée, en plus de retourner le même type de valeur si elle n'est pas void, assurez-vous que la méthode prend le même nombre d'arguments. Voici un exemple :

using System;

delegate double Addition(double x, double  y);

class Exercise
{
    private static double Plus(double a, double  b)
    {
        return  a + b;
    }
    
    static  int Main()
    {
           return  0;
    }
}

Une fois de plus, pour associer la méthode, déclarez une variable du type de délégué et transmettez le nom de la méthode au constructeur du délégué. Voici un exemple :

Addition Add = new Addition(Plus);

Notez que seul le nom de la méthode est transmis au délégué. Pour utiliser réellement le délégué lors de l'appel, entre parenthèses, fournissez une valeur dont les arguments sont conformes au type spécifié lorsque vous déclarez le délégué.

Le délégué réussi comme argument

En utilisant les délégués, une méthode peut être indirectement transmise comme argument à une autre méthode. Pour le faire, déclarez tout d'abord le délégué nécessaire. Voici un exemple d'un tel délégué :

using System;

namespace GeometricFormulas
{
        public  delegate double Squared(double x);
        public  class Circle
        {
                private  double _radius;
                
                public  double Radius
                {
                        get  { return _radius; }
                        set  { _radius = value; }
                }       
        }
}

Un délégué peut être passé comme argument à une méthode. Un tel argument sera utilisé comme s'il s'agissait d'une méthode elle-même. Cela signifie que, lorsqu'on accède dans le corps de la méthode, le nom du délégué doit être accompagné par les parenthèses et si le délégué prend un argument, l'argument doit être fourni dans les parenthèses du délégué appelé. Voici un exemple :

using System;

namespace GeometricFormulas
{
        public  delegate double Squared(double x);
        
        public  class Circle
        {
                private  double _radius;
                
                public  double Radius
                {
                        get  { return _radius; }
                        set     { _radius = value; }
                }
                
                public  double Area(Squared  sqd)
                {
                        return  sqd(_radius) * Math.PI;
                }
         }
}

Après avoir déclaré un délégué, n'oubliez pas de définir une méthode qui implémente le comportement nécessaire de ce délégué. Voici un exemple :

using System;

namespace GeometricFormulas
{
        public  delegate double Squared(double x);
        public  class Circle
        {
                 private  double _radius;
                 public static double ValueTimesValue(double  Value)
                 {
                        return Value * Value;
                 }
        }
}

Vous pouvez également définir la méthode associée dans une autre classe, pas nécessairement dans la classe où le délégué serait nécessaire. Une fois que la méthode qui implémente le délégué est connue, vous pouvez utiliser le délégué comme bon vous semble. Pour ce faire, vous pouvez déclarer une variable du type de ce délégué et transmettre la méthode mise en oeuvre à son constructeur. Voici un exemple :

using System;

namespace GeometricFormulas
{
        public  delegate double Squared(double x);

        public  class Circle
        {
                 private  double _radius;
 
                 public  static double ValueTimesValue(double Value)
                 {
                         return  Value * Value;
                 }

                 public  double Area(Squared sqd)
                 {
                         return  sqd(_radius) * Math.PI;
                 }
                 public  void CircleCharacteristics()
                 {
                         Squared Sq = new Squared(ValueTimesValue);
                 }
        }
}

Cette déclaration donne vie au délégué et peut ensuite être utilisée comme nous avons procédé avec les délégués jusqu'à présent.

Les Événements

 

Introduction

À l'exception de la classe principale de votre programme (la classe qui contient la méthode main()), chaque classe est principalement destinée à interagir avec les autres, à demander les valeurs et les méthodes des autres classes ou à fournir d'autres classes avec certaines valeurs ou un comportement dont ils ont besoin. Lorsqu'une classe A demande une valeur ou un service à partir d'une autre classe B, classe A est appelée un client de classe B. Cette relation est importante pas simplement parce qu'elle établit une relation entre les deux classes mais aussi parce que la classe B doit être prête à fournir la valeur ou le comportement qui a besoin d'un client à un certain moment.

Si une classe B est invitée à fournir certaines valeurs, ou effectuer une ou plusieurs affectations pour une autre classe A, beaucoup de choses se produiraient. En fait, il y a un ordre que les actions doivent suivre. Par exemple, pendant la durée de vie d'un programme, c'est-à-dire pendant l'exécution d'un programme, une classe peut avoir une valeur qu'elle peut fournir à ses clients, mais à un autre moment, cette valeur peut ne plus être disponible, pour une raison quelconque ; rien d'étrange, que c'est juste la manière dont elle se produit. Parce que différentes choses peuvent se produire pendant l'exécution d'un programme à une classe B, seule la classe B serait au courant de celles-ci, elle doit pouvoir signalé aux autres classes lorsqu'il y a un changement. C'est la base des événements : un événement est une action qui se produit sur un objet et l'affecte de façon que ses clients doivent en être informés.

La Création de l'événement

Un événement est déclaré comme un pseudo-variable mais basé sur un délégué. Par conséquent, pour déclarer un événement, vous devez avoir un délégué qui va l'implémenter. Effectivement pour déclarer un événement, vous utilisez le mot-clé event avec la formule suivante :

[attributes] [modifiers] event type declarator;
  [attributes] [modifiers] event type member-name {accessor-declarations};

Le facteur d'attributs peut être un attribut normal c#.

Le modificateur peut être un ou une combinaison des mots-clés suivants : public, private, protected, internal, abstract, new, override, static, virtual ou extern.

Le mot-clé de event est requis. Il est suivi du nom du délégué qui spécifie son comportement. Si l'événement est déclaré dans la classe principale, il doit être statique. Comme dans tout programme, un événement doit avoir un nom. Cela permettrait aux clients de savoir quel événement (particulier) s'est produit. Voici un exemple :

using System;

delegate void dlgSimple();

class Exercise
{
       public static event dlgSimple Simply;
 
       public  static void Welcome()
       {

       }
}

Lorsque l'événement se produit, son délégué pourrait être invoqué. Cette spécification est également appelée la connexion d'un événement. Comme l'événement se produit (ou se déclenche), la méthode qui implémente le délégué s'exécute. Cela fournit des fonctionnalités complètes pour l'événement et rend l'événement prêt à être utilisé. Avant d'utiliser un événement, vous devez l'associer à la méthode qu'il implémente. Cela peut être fait en transmettant le nom de la méthode au délégué approprié que nous avons appris lors de l'étude des délégués. Vous pouvez ensuite affecter cette variable pour le nom de l'événement à l'aide de l'opérateur +=. Une fois cette opération effectuée, vous pouvez appeler l'événement. Voici un exemple :

using System;

delegate void dlgSimple();

class Exercise
{
       public  static event dlgSimple Simply;
       
       public  static void Welcome()
       {
       }

       public  static void SayHello()
       {
               Simply();
       }

       static  int Main()
       {
               Simply += new dlgSimple(Welcome);
               SayHello();

               return  0;
        }
}

Au lieu de l'opérateur += utilisé lors de l'initialisation de l'événement, vous pouvez implémenter Add et Remove de la classe Event. Voici un exemple :

using System;

delegate void dlgSimple();

class Exercise
{
       public  event dlgSimple Simply
       {
               add
               {
                        Simply  += new dlgSimple(Welcome);
               }
               
               remove
               {
                        Simply  -= new dlgSimple(Welcome);
               }
       }

       public  void Welcome()
       {

       }
}

Les Événements et contrôle Windows

 

Introduction

Une application est faite de divers objets ou de contrôles. Pendant la durée de vie d'une application, ses contrôles envoient régulièrement des messages au système d'exploitation pour faire quelque chose en leur nom. Ces messages sont semblables aux messages humains et doivent être traités convenablement. Comme la plupart du temps, plus d'une application s'exécute sur l'ordinateur, les contrôles d'une telle aplication envoient également des messages au système d'exploitation. Comme le système d'exploitation est constamment demandé d'effectuer ces affectations, car il peut y avoir tant de demandes présentées de manière imprévisible, le système d'exploitation laisse aux contrôles de spécifier ce qu'ils veulent, quand ils le souhaitent et à quel comportement ou résultat ils s'attendent. Ces scénarios travaillent par les contrôles en envoyant les événements.

Les événements dans le .NET Framework sont mis en œuvre à travers les concepts des délégués et des événements examinés ci-dessus. Les événements les plus courants ont déjà été créés pour les objets des contrôles .NET Framework tant que vous ne devrez pas définir de nouveaux événements, du moins au début de votre interface utilisateur de programmation graphique. La plupart de ce que vous ferez consiste à mettre en œuvre le comportement désiré au déclenchement d'un événement particulier. Pour commencer, vous devez savoir quels événements sont disponibles, quand ils le sont, comment ils fonctionnent et ce qu'ils produisent.

Pour traiter un message, il (le message) doit fournir au moins deux informations : ce qui a provoqué le message et quel type de message il est. Les deux valeurs sont transmises comme les arguments à l'événement. Étant donné que tous les contrôles utilisés dans le .NET Framework sont basés sur la classe Object, le premier argument doit être un type object et représente le contrôle qui a envoyé le message.

Comme déjà dit, chaque contrôle envoie ses propres messages lorsque c'est nécessaire. Sur cette base, certains messages sont spécifiques à certains contrôles en fonction de leurs rôles. Certains messages sont communs aux différents contrôles, car ils ont tendance à fournir des actions similaires. Pour gérer ces diverses configurations, le .NET Framework considère les messages en deux grandes catégories.

Comme cela arrive, pour effectuer leurs actions prévues, certains messages ne nécessitent pas beaucoup d'informations. Par exemple, supposez que votre coeur envoie un message au bras et dit, "Levez votre main". Dans ce cas, supposez que tout va bien, le bras ne demande pas, "Comment dois-je soulever ma main?". Il fait tout simplement parce qu'il sait comment, sans aucune intervention. Ce type de message serait envoyé sans beaucoup de détails.
Dans le .NET Framework, un message qui n'a pas besoin d' informations particulières est assuré par une classe nommée EventArgs. Dans l'implémentation de l'événement, un argument EventArgs est transmis comme le second paramètre.

Envisagez un autre message où le bras porte de l'eau et dit à la bouche, "Avale l'eau suivante" . Il faudrait que l'eau ait besoin d'être avalée par la bouche. Par conséquent, le message doit être accompagné des informations supplémentaires. Envisagez un autre message où le cœur dit à la langue, "Goutte à la nourriture suivante mais ne l'avale pas". Pour traiter ce message, la langue aurait besoin de la nourriture et quelque chose pour indiquer que la nourriture ne doit pas être avalée. Dans ce cas, le message doit être accompagné par des informations détaillées.

Lorsqu'un message doit comporter des informations supplémentaires, le contrôle qui a envoyé le message indique les informations par le nom du deuxième argument. Parce qu'il existe différents types de messages comme ça, il existe également différents types de classes utilisées pour transporter ces messages. Nous allons présenter chaque classe, le cas échéant.

La Mise en œuvre des événements

Bien qu'il existe différents moyens de mise en œuvre d'un événement, il y a deux façons principales que vous pouvez lancer son codage. Si le contrôle a un événement par défaut et si vous double-cliquez dessus, le studio déclencherait l'événement par défaut et ouvrirait l'éditeur de code. Le curseur devrait être positionné dans le corps de l'événement, qui est prêt à recevoir vos instructions. Une autre technique que vous pouvez utiliser consiste à afficher le premier et à cliquer sur le formulaire ou le contrôle qui déclenche l'événement. Puis, dans la fenêtre Propriétés, cliquez sur le bouton Events Events, double-cliquez sur le nom de l'événement que vous souhaitez utiliser.

La Présentation des événements

 

La Peinture de contrôle

Si une application s'ouvre sur l'écran ou elle doit être indiquée, le système d'exploitation doit afficher ses contrôles. Pour ce faire, les couleurs de contrôles et d'autres aspects visuels doivent être récupérées et restaurées. Ceci est fait par la peinture du contrôle. Si l'écran qui héberge les contrôles a été caché quelque part comme derrière une autre fenêtre ou a été réduite, lorsqu'il arrive, le système d'exploitation doit le peindre (à nouveau).

Lorsqu'un contrôle est peint, il déclenche l'événement Paint(). La syntaxe de l'événement Paint() est :

public event PaintEventHandler Paint;

Cet événement est assuré par un délégué PaintEventHandler déclaré comme suit :

public delegate void  PaintEventHandler(object sender, PaintEventArgs e);

Le paramètre PaintEventArgs fournit des informations sur la zone à peindre et l'objet graphique à peindre.

Le Redimensionnement de contrôle

Lorsque vous utilisez une application, l'une des actions qu'un utilisateur peut effectuer sur un formulaire ou un contrôle est de changer sa taille, à condition que l'objet le permette. Aussi, de temps en temps, si possible, l'utilisateur peut réduire, agrandir ou restaurer une fenêtre. Chaque fois qu'une de ces actions se produit, le système d'exploitation doit conserver la trace de l'emplacement et la taille d'un contrôle. Par exemple, si une fenêtre précédemment réduite ou agrandie est en cours de restauration, le système d'exploitation doit se rappeler où l'objet a été précédemment placé et quelles étaient ses dimensions.

Lorsque la taille d'un contrôle a été modifiée, elle déclenche l'événement Resize(), qui est un type de EventArgs.

Les Messages du Clavier

 

Introduction

Un clavier est un objet matériel connecté à l'ordinateur. Par défaut, il est utilisé pour entrer des symboles reconnaissables, lettres et autres caractères sur un contrôle. Chaque touche du clavier affiche un symbole, une lettre ou une combinaison de ceux-ci, pour donner une indication de ce pour quoi la clé pourrait être utilisée.

Généralement, l'utilisateur appuie sur une touche qui envoie un signal à un programme. Le signal est analysé pour trouver son sens. Si le programme ou le contrôle qui a le focus est équipé pour traiter le signal, il peut produire le résultat escompté. Si le programme ou le contrôle ne peut pas comprendre ce qu'il faut faire, il ignore l'action.

Chaque clé comporte un code qui reconnaît le système d'exploitation.

Le message sur la touche bas/The KeyDown message

Lorsque l'utilisateur appuie sur une touche de clavier, un message appelé KeyDown est envoyé. KeyDown est un type de KeyEventArgs interprété par le biais de la classe KeyEventHandler. Cet événement est défini comme suit :

private void Control_KeyDown(object  sender, KeyEventArgs e)
{

}

Cet événement est assuré par la classe KeyEventArgs définie dans l'espace de noms System.Windows.Forms. Lorsque vous lancez cet événement, son argument KeyEventArgs fournit autant d'informations que possible pour implémenter un comportement approprié.

La clé en haut du message/The Key Up message

Par opposition à la clé, le message est envoyé lorsqu'une touche est en panne, le message KeyUp est envoyé lorsque l'utilisateur relâche la clé. L'événement est lancé comme suit :

private void Control_KeyUp(object  sender, KeyEventArgs e)
{

}

Comme KeyDown, KeyUp est un type de KeyEventArgs.

Le message de la clé de presse/The Key Press Message

Lorsque l'utilisateur appuie sur une touche, le message KeyPress est envoyé. Contrairement aux deux autres messages de clavier, la touche pour cet événement doit (devrait) être une touche de caractère. L'événement est lancé comme suit :

private void Control_KeyPress(object  sender, KeyPressEventArgs e)
{

}

L'événement KeyPress est assuré par un type de KeyPressEventArgs. La propriété Handled s'identifie si cet événement a été traité. La propriété KeyChar identifie la clé qui a été enfoncée. Elle doit être une lettre ou un symbole reconnaissable. Les caractères alphabétiques minuscules, chiffres et les premiers caractères de base tels que; à ¢ â ' ¬Ëœ []-= / sont reconnus comme ils le sont. Pour une majuscule ou un symbole de base supérieure, l'utilisateur doit appuyer sur la touche Maj +. Le caractère serait identifié comme une seule entité. Cela signifie que le pourcentage de symbole type avec Maj + 5 est considéré comme un caractère.

Les Messages de souris

 

Introduction

La souris est un autre objet qui est connecté à l'ordinateur permettant à l'utilisateur de communiquer avec la machine. La souris et le clavier peuvent chacun accomplir certaines tâches qui ne sont pas normalement disponibles sur l'autre ou les deux peuvent accomplir certaines tâches de la même manière.

La souris est équipée de deux, trois ou plusieurs boutons. Lorsqu'une souris comporte deux boutons, l'un se trouve généralement à gauche et l'autre est situé sur la droite. Lorsqu'une souris comporte trois boutons, une est habituellement au milieu des deux autres. Une souris peut également avoir un objet rond dénommé une roue.

La souris est utilisée pour sélectionner un point ou une position sur l'écran. Une fois que l'utilisateur a localisé un élément, ce qui peut être également un espace vide, une lettre ou un mot, il ou elle aurait positionné le pointeur de la souris dessus.

Pour effectivement utiliser la souris, l'utilisateur appuyerait sur la gauche, le milieu (le cas échéant) ou le bouton de droite. Si l'utilisateur appuie sur le bouton gauche une fois, cette action est appelée, cliquez sur ce bouton. Si l'utilisateur appuie sur le bouton droit de la souris, l'action est appelée contextuel. Si l'utilisateur appuie sur le bouton gauche deux fois et très rapidement, l'action est appelée double-clic.

Si la souris est équipée d'une roue, l'utilisateur peut placer le pointeur de la souris quelque part sur l'écran et faire rouler la molette. Cela provoque généralement le document ou la page pour faire défiler vers le haut ou vers le bas, lent ou rapide, en fonction de la façon dont il a été configuré.

Le message Entrée de la souris

Avant d'utiliser un contrôle à l'aide de la souris, l'utilisateur doit tout d'abord placer la souris dessus. Dans ce cas, le contrôle déclenche un événement MouseEnter. Cet événement est lancé comme suit :

private void Control_MouseEnter(object  sender, EventArgs e)
{

}

Cet événement est assuré par un argument EventArgs mais ne fournit pas beaucoup d'informations, uniquement pour vous informer que la souris est positionnée sur un contrôle.

Le message de déplacement de la souris

Chaque fois que la souris est déplacée d'un contrôle, un événement de souris est envoyé. Cet événement est appelé MouseMove et est du type MouseEventArgs. Il est établi comme suit :

private void Control_MouseMove(object  sender, System.Windows.Forms.MouseEventArgs e)
{

}

Pour mettre en œuvre cet événement, un argument MouseEventArgs est transmis à l'implémenteur d'événement MouseEventHandler. L'argument MouseEventArgs fournit les informations nécessaires sur l'événement comme quel bouton a été cliqué, combien de fois le bouton est cliqué et l'emplacement de la souris.

Le message par pointage de souris

Si l'utilisateur place la souris sur un contrôle et il passe dessus, un événement MouseHover est déclenché. Cet événement est lancé comme suit :

private void Control_MouseHover(object  sender, EventArgs e)
{

}

Cet événement est assuré par un argument de EventArgs qui ne fournit pas les informations complémentaires que la souris est pointant sur le contrôle.

La souris vers le bas du message

Imaginez que l'utilisateur a trouvé une position ou un élément sur un document et appuie sur un des boutons de la souris. Alors que le bouton est enfoncé et est en panne, un message button-down est envoyé. Cet événement est appelé MouseDown et est du type MouseEventArgs, il est lancé comme suit :

private void Control_MouseDown(object  sender, MouseEventArgs e)
{

}

Comme l'autre au-dessus de l'événement souris, l'événement MouseDown est assuré par un argument MouseEventArgs.

Les message de la souris

Après avoir appuyé sur un bouton de la souris, l'utilisateur le libère généralement. Alors que le bouton est libéré, un message de bouton-up est envoyé et il dépend du bouton, la gauche ou la droite, qui était sorti. L'événement produit est MouseUp et il est lancé comme suit :

private void Control_MouseUp(object  sender, MouseEventArgs e)
{

}

Comme le message MouseDown, l'événement MouseUp est de type MouseEventArgs qui est transmis à MouseEventHandler pour traitement.

Le message d'autorisation de souris

Lorsque l'utilisateur déplace le pointeur de la souris à partir d'un contrôle, le contrôle déclenche un événement MouseLeave. Cet événement est lancé comme suit :

private void Form1_MouseLeave(object  sender, EventArgs e)
{

}

Les messages d'événements Drag and Drop

 

Introduction

Pour prendre en charge la trainée des opérations n ', le .NET Framework fournit divers événements par le biais de la classe Control. L'objet de point de départ de l'opération est appelé la source. Cet objet peut être ou non de votre application. Par exemple, un utilisateur peut démarrer une opération de déplacement d'un utilitaire de fichier (tel que Windows Explorer). L'objet ou le document où doit se terminer l'opération déplacée est appelé la cible. Puis que vous créez une application où vous voulez autoriser l'utilisateur à déplacer des objets, la cible fait généralement partie de votre application.

Démarrage de l'opération de déplacement

Pour lancer l'opération de déplacement, l'utilisateur clique et maintient la souris sur un objet ou un texte. Puis l'utilisateur commmence à déplacer la souris. Pour l'instant, si l'objet source se trouve à partir de votre application, le contrôle déclenche un événement DragLeave :

public event EventHandler DragLeave;

Cet événement est de type EventArgs, qui signifie qu'il ne transporte pas de renseignement, juste pour vous informer qu'une opération de déplacement a démarré.

Glissement d' un objet

L'utilisateur fait glisser un objet d'un emplacement à un autre. Entre la source et la cible, l'utilisateur peut passer par un autre objet, mais ce n'est pas la cible. Dans ce cas, le contrôle qui est le plus transmis déclenche un événement DragOver :

public event DragEventHandler DragOver;

L'événement DragOver est géré par une classe nommée DragEventAgs. La plupart du temps, vous ne serez pas concerné par cet événement car la plupart des opérations de drag n ' drop impliquent une source et une cible. Pour cette raison, nous n'allons pas examiner cette classe en ce moment.

Saisie de la cible

En même temps, l'utilisateur va atteindre sa cible. C'est avant la suppression de l'élément. Pour l'instant, le contrôle sur lequel est positionée la souris déclenche l'événement DragEnter :

public event DragEventHandler DragEnter;

À ce moment, l'utilisateur n'a pas encore décidé ou non de déplacer l'objet. C'est important car à ce moment, vous pouvez toujours prendre certaines décisions, telles que identifier le type d'élément dont est muni l'utilisateur, si vous souhaitez autoriser cette opération ou non, etc..

L'événement DragEnter est géré par la classe DragEventArgs. Une des propriétés de cette classe est appelée Effet. Cette propriété est de type DragDropEffects, qui est une énumération.

Probablement l'information la plus importante que vous voulez savoir est ce dont est muni l'utilisateur. Par exemple, un utilisateur peut faire glisser le texte, une image ou un document, etc.. Pour vous aider à identifier ce qui est maintenant la souris, la classe DragEventArgs est équipée de la propriété de données qui est de type IDataObject.

Suppression de l'objet

Une fois que l'utilisateur a atteint la cible et veut encore terminer l'opération, il doit relâcher le bouton de la souris. Pour l'instant, l'objet sur lequel la souris est positionnée déclenche l'événement DragDrop :

public event DragEventHandler DragDrop;

L'événement DragDrop est géré par la classe DragEventArgs.

Mise en œuvre du message personnalisé

 

Introduction

Il est possible, mais peu probable, qu'aucun des événements disponibles présentés dans les contrôles des combinaisons .NET Framework ne convienne à votre scénario. Dans ce cas, vous pouvez implémenter votre propre événement. Pour ce faire, vous devez tout d'abord consulter la documentation de Win32 pour identifier le type de message que vous souhaitez envoyer.

Il existe deux principales techniques que vous pouvez utiliser pour créer et envoyer un message qui n'est pas disponible dans un contrôle. Vous pouvez également fournir votre propre implémentation d'un message.

Envoi d'un message de Windows personnalisé

Pour envoyer une version personnalisée d'un message Windows de votre contrôle, vous devez tout d'abord être familier avec le message. Un message dans le .NET Framework est basé sur la structure du message qui est définie comme suit :

public struct Message
{
    public IntPtr HWnd {get; set;}
    public IntPtr LParam {get; set;}
    public int Msg {get; set;}
    public IntPtr Result {get; set;}
    public IntPtr WParam {get; set;}
    public static Message Create(IntPtr hWnd,
                                 int msg,
                                 IntPtr wparam,
                                 IntPtr lparam);
    public override bool Equals(object o);
    public override int GetHashCode();
    public object GetLParam(Type cls);
    public override string ToString();
}

Une des propriétés de cette structure est le Msg. Cette propriété contient un nombre entier qui est le message à envoyer. Les propriétés constantes des messages sont définies dans la bibliothèque de Win32. Pour envoyer un message, vous pouvez déclarer une variable de type message et le définir. Une fois que la variable est prête, vous pouvez passer à la méthode DefWndProc(). Sa syntaxe est la suivante :

protected virtual void DefWndProc(ref  Message m);

Pour connaître les différents messages disponibles, vous pouvez consulter la documentation de Win32, mais vous avez besoin d'un moyen d'obtenir la valeur constante de ce message. Imaginez que vous souhaitez envoyer un message pour fermer un formulaire lorsque l'utilisateur clique sur un bouton nommé Button1. Si vous disposez de Microsoft Visual Studio (toute version) installé dans votre ordinateur, vous pouvez ouvrir le lecteur : \Program Files\Microsoft Visual Studio\VC98\Include\WINUSER.H fichier. Dans ce fichier, le message WM_CLOSE qui exécute une action proche est défini avec la valeur hexadécimale constante 0x0010

WinUser

Vous pouvez ensuite définir une constante entière dans votre code et l'initialiser avec cette même valeur. Voici un exemple :

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 WindowsApplication2
{
     public partial class Form1 : Form
     {
         private  const int WM_CLOSE = 0x0010;

         public Form1()
         {
             InitializeComponent();
         }

         private void button1_Click(object sender, EventArgs e)
         {
             Message  msg = new Message();
             msg.HWnd = this.Handle;
             msg.Msg = WM_CLOSE;
             DefWndProc(ref msg);
         }
     }
}

La Création d'un événement personnalisé

Pour traiter un message Windows qui n'est pas disponible pour un contrôle que vous souhaitez utiliser dans votre application, vous pouvez implémenter sa méthode WndProc(). Sa syntaxe est la suivante :

protected virtual void WndProc(ref Message  m);

Pour pouvoir utiliser cette méthode, vous devez la remplacer dans votre propre classe. Une fois de plus, vous devez connaître le message que vous souhaitez envoyer. Cela peut être fait en consultant la documentation Win32. Voici un exemple qui déclenche un événement OnMove lorsque l'utilisateur essaie de déplacer une fenêtre (Cela empêche l'utilisateur d'effectuer l'action) :

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;
using System.Runtime.InteropServices;

namespace WindowsApplication2
{
    public partial class Form1 : Form
    {
         private  const int WM_MOVE = 0x0003;
         public Form1()
         {
             InitializeComponent();
         }

         [DllImport("User32.dll")]
         public static extern bool ReleaseCapture();

         protected override void WndProc(ref Message m)
         {
             switch (m.Msg)
             {
                case WM_MOVE:
                    ReleaseCapture();
                    break;
             }
             
             base.WndProc(ref m);
       }
    }
}
       
 
 
 
 

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