DrawTreeNodeEventArgs Classe

Définition

Espace de noms:

System.Windows.Forms

Assembly:

System.Windows.Forms.dll

Source:

DrawTreeNodeEventArgs.cs

Fournit des données pour l'événement DrawNode.

C#

public class DrawTreeNodeEventArgs : EventArgs

Héritage

Object

EventArgs

DrawTreeNodeEventArgs

Exemples

L’exemple de code suivant montre comment personnaliser un TreeView contrôle à l’aide du dessin propriétaire. Le TreeView contrôle de l’exemple affiche des balises de nœud facultatives à côté des étiquettes de nœud standard. Les balises de nœud sont spécifiées à l’aide de la TreeNode.Tag propriété . Le TreeView contrôle utilise également des couleurs personnalisées, y compris une couleur de surbrillance personnalisée.

Vous pouvez personnaliser la plupart des couleurs en définissant les TreeView propriétés de couleur, mais la couleur de surbrillance de sélection n’est pas disponible en tant que propriété. En outre, le rectangle de surbrillance de sélection par défaut s’étend uniquement autour d’une étiquette de nœud. Le dessin propriétaire doit être utilisé pour dessiner les balises de nœud et pour dessiner un rectangle de surbrillance personnalisé suffisamment grand pour inclure une balise de nœud.

Dans l’exemple, un gestionnaire pour l’événement TreeView.DrawNode dessine manuellement les balises de nœud et la sélection personnalisée. Les nœuds non sélectionnés n’ont pas besoin de personnalisation. Pour ceux-ci, la DrawDefault propriété est définie sur true afin qu’ils soient dessinés par le système d’exploitation.

En outre, un gestionnaire pour l’événement Control.MouseDown fournit des tests d’accès. Par défaut, un nœud peut être sélectionné uniquement en cliquant sur la région autour de son étiquette. Le Control.MouseDown gestionnaire d’événements sélectionne un nœud sur lequel on clique n’importe où dans cette région ou dans la région autour d’une balise de nœud, le cas échéant.

C#

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

public class TreeViewOwnerDraw : Form
{
    private TreeView myTreeView;

    // Create a Font object for the node tags.
    Font tagFont = new Font("Helvetica", 8, FontStyle.Bold);

    public TreeViewOwnerDraw()
    {
        // Create and initialize the TreeView control.
        myTreeView = new TreeView();
        myTreeView.Dock = DockStyle.Fill;
        myTreeView.BackColor = Color.Tan;
        myTreeView.CheckBoxes = true;

        // Add nodes to the TreeView control.
        TreeNode node;
        for (int x = 1; x < 4; ++x)
        {
            // Add a root node to the TreeView control.
            node = myTreeView.Nodes.Add(String.Format("Task {0}", x));
            for (int y = 1; y < 4; ++y)
            {
                // Add a child node to the root node.
                node.Nodes.Add(String.Format("Subtask {0}", y));
            }
        }
        myTreeView.ExpandAll();

        // Add tags containing alert messages to a few nodes 
        // and set the node background color to highlight them.
        myTreeView.Nodes[1].Nodes[0].Tag = "urgent!";
        myTreeView.Nodes[1].Nodes[0].BackColor = Color.Yellow;
        myTreeView.SelectedNode = myTreeView.Nodes[1].Nodes[0];
        myTreeView.Nodes[2].Nodes[1].Tag = "urgent!";
        myTreeView.Nodes[2].Nodes[1].BackColor = Color.Yellow;

        // Configure the TreeView control for owner-draw and add
        // a handler for the DrawNode event.
        myTreeView.DrawMode = TreeViewDrawMode.OwnerDrawText;
        myTreeView.DrawNode += 
            new DrawTreeNodeEventHandler(myTreeView_DrawNode);

        // Add a handler for the MouseDown event so that a node can be 
        // selected by clicking the tag text as well as the node text.
        myTreeView.MouseDown += new MouseEventHandler(myTreeView_MouseDown);

        // Initialize the form and add the TreeView control to it.
        this.ClientSize = new Size(292, 273);
        this.Controls.Add(myTreeView);
    }

    // Clean up any resources being used.        
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            tagFont.Dispose();
        }
        base.Dispose(disposing);
    }

    [STAThreadAttribute()]
    static void Main() 
    {
        Application.Run(new TreeViewOwnerDraw());
    }

    // Draws a node.
    private void myTreeView_DrawNode(
        object sender, DrawTreeNodeEventArgs e)
    {
        // Draw the background and node text for a selected node.
        if ((e.State & TreeNodeStates.Selected) != 0)
        {
            // Draw the background of the selected node. The NodeBounds
            // method makes the highlight rectangle large enough to
            // include the text of a node tag, if one is present.
            e.Graphics.FillRectangle(Brushes.Green, NodeBounds(e.Node));

            // Retrieve the node font. If the node font has not been set,
            // use the TreeView font.
            Font nodeFont = e.Node.NodeFont;
            if (nodeFont == null) nodeFont = ((TreeView)sender).Font;

            // Draw the node text.
            e.Graphics.DrawString(e.Node.Text, nodeFont, Brushes.White,
                Rectangle.Inflate(e.Bounds, 2, 0));
        }

        // Use the default background and node text.
        else 
        {
            e.DrawDefault = true;
        }

        // If a node tag is present, draw its string representation 
        // to the right of the label text.
        if (e.Node.Tag != null)
        {
            e.Graphics.DrawString(e.Node.Tag.ToString(), tagFont,
                Brushes.Yellow, e.Bounds.Right + 2, e.Bounds.Top);
        }

        // If the node has focus, draw the focus rectangle large, making
        // it large enough to include the text of the node tag, if present.
        if ((e.State & TreeNodeStates.Focused) != 0)
        {
            using (Pen focusPen = new Pen(Color.Black))
            {
                focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
                Rectangle focusBounds = NodeBounds(e.Node);
                focusBounds.Size = new Size(focusBounds.Width - 1, 
                focusBounds.Height - 1);
                e.Graphics.DrawRectangle(focusPen, focusBounds);
            }
        }
    }

    // Selects a node that is clicked on its label or tag text.
    private void myTreeView_MouseDown(object sender, MouseEventArgs e)
    {
        TreeNode clickedNode = myTreeView.GetNodeAt(e.X, e.Y);
        if (NodeBounds(clickedNode).Contains(e.X, e.Y))
        {
            myTreeView.SelectedNode = clickedNode;
        }
    }

    // Returns the bounds of the specified node, including the region 
    // occupied by the node label and any node tag displayed.
    private Rectangle NodeBounds(TreeNode node)
    {
        // Set the return value to the normal node bounds.
        Rectangle bounds = node.Bounds;
        if (node.Tag != null)
        {
            // Retrieve a Graphics object from the TreeView handle
            // and use it to calculate the display width of the tag.
            Graphics g = myTreeView.CreateGraphics(); 
            int tagWidth = (int)g.MeasureString
                (node.Tag.ToString(), tagFont).Width + 6;

            // Adjust the node bounds using the calculated value.
            bounds.Offset(tagWidth/2, 0);
            bounds = Rectangle.Inflate(bounds, tagWidth/2, 0);
            g.Dispose();
         }
        
        return bounds;
    }
}

Remarques

Utilisez l’événement DrawNode pour personnaliser l’apparence des nœuds dans un TreeView contrôle à l’aide du dessin du propriétaire.

L’événement DrawNode est déclenché par un TreeView contrôle lorsque sa TreeView.DrawMode propriété est définie sur TreeViewDrawMode.OwnerDrawAll ou TreeViewDrawMode.OwnerDrawText et qu’un nœud est affiché ou mis à jour. Le DrawTreeNodeEventArgs transmis au gestionnaire d’événements contient des informations sur le nœud à dessiner et fournit des méthodes pour vous aider à dessiner le nœud.

Utilisez les State propriétés ou Node pour récupérer des informations sur le nœud à dessiner. Utilisez la Graphics propriété pour effectuer le dessin réel dans la zone spécifiée par la Bounds propriété . Pour que le système d’exploitation dessine un nœud qui n’a pas besoin d’être dessiné par le propriétaire, définissez la propriété sur DrawDefaulttrue.

Lorsque la propriété a la TreeView.DrawMode valeur TreeViewDrawMode.OwnerDrawText, la zone indiquée par la Bounds propriété inclut uniquement la partie étiquette du nœud. Lorsque la TreeView.DrawMode propriété a la TreeViewDrawMode.OwnerDrawAllvaleur , la zone inclut le Bounds nœud entier, y compris la zone généralement utilisée pour les icônes, les cases à cocher, les signes plus et moins et les lignes reliant les nœuds.

Constructeurs

DrawTreeNodeEventArgs(Graphics, TreeNode, Rectangle, TreeNodeStates)

Initialise une nouvelle instance de la classe DrawTreeNodeEventArgs.

Propriétés

Bounds	Obtient l'emplacement et la taille de TreeNode à dessiner.
DrawDefault	Obtient ou définit une valeur indiquant si TreeNode doit être dessiné par le système d'exploitation plutôt qu'être owner-drawn.
Graphics	Obtient l'objet Graphics utilisé pour dessiner TreeNode.
Node	Obtient TreeNode à dessiner.
State	Obtient l'état actuel de TreeNode à dessiner.

S’applique à

Voir aussi

• TreeView
• DrawMode
• DrawNode
• TreeViewDrawMode