Lire en anglais

Partager via


TrackBarRenderer Classe

Définition

Fournit les méthodes utilisées pour restituer un contrôle de barre de suivi avec des styles visuels. Cette classe ne peut pas être héritée.

public sealed class TrackBarRenderer
public static class TrackBarRenderer
Héritage
TrackBarRenderer

Exemples

L’exemple de code suivant montre comment créer un contrôle personnalisé qui utilise les TrackBarRenderer méthodes pour dessiner une barre de suivi horizontale qui répond aux clics de souris.

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

namespace TrackBarRendererSample
{
    class Form1 : Form
    {
        public Form1()
        {
            CustomTrackBar TrackBar1 = new CustomTrackBar(19,
                new Size(300, 50));
            this.Width = 500;
            this.Controls.Add(TrackBar1);
        }

        [STAThread]
        static void Main()
        {
            // Note that the call to EnableVisualStyles below does
            // not affect whether TrackBarRenderer.IsSupported is true; 
            // as long as visual styles are enabled by the operating system, 
            // IsSupported is true.
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }
    }

    class CustomTrackBar : Control
    {
        private int numberTicks = 10;
        private Rectangle trackRectangle = new Rectangle();
        private Rectangle ticksRectangle = new Rectangle();
        private Rectangle thumbRectangle = new Rectangle();
        private int currentTickPosition = 0;
        private float tickSpace = 0;
        private bool thumbClicked = false;
        private TrackBarThumbState thumbState =
            TrackBarThumbState.Normal;

        public CustomTrackBar(int ticks, Size trackBarSize)
        {
            this.Location = new Point(10, 10);
            this.Size = trackBarSize;
            this.numberTicks = ticks;
            this.BackColor = Color.DarkCyan;
            this.DoubleBuffered = true;

            // Calculate the initial sizes of the bar, 
            // thumb and ticks.
            SetupTrackBar();
        }

        // Calculate the sizes of the bar, thumb, and ticks rectangle.
        private void SetupTrackBar()
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            using (Graphics g = this.CreateGraphics())
            {
                // Calculate the size of the track bar.
                trackRectangle.X = ClientRectangle.X + 2;
                trackRectangle.Y = ClientRectangle.Y + 28;
                trackRectangle.Width = ClientRectangle.Width - 4;
                trackRectangle.Height = 4;

                // Calculate the size of the rectangle in which to 
                // draw the ticks.
                ticksRectangle.X = trackRectangle.X + 4;
                ticksRectangle.Y = trackRectangle.Y - 8;
                ticksRectangle.Width = trackRectangle.Width - 8;
                ticksRectangle.Height = 4;

                tickSpace = ((float)ticksRectangle.Width - 1) /
                    ((float)numberTicks - 1);

                // Calculate the size of the thumb.
                thumbRectangle.Size =
                    TrackBarRenderer.GetTopPointingThumbSize(g,
                    TrackBarThumbState.Normal);

                thumbRectangle.X = CurrentTickXCoordinate();
                thumbRectangle.Y = trackRectangle.Y - 8;
            }
        }

        private int CurrentTickXCoordinate()
        {
            if (tickSpace == 0)
            {
                return 0;
            }
            else
            {
                return ((int)Math.Round(tickSpace) *
                    currentTickPosition);
            }
        }

        // Draw the track bar.
        protected override void OnPaint(PaintEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
            {
                this.Parent.Text = "CustomTrackBar Disabled";
                return;
            }

            this.Parent.Text = "CustomTrackBar Enabled";
            TrackBarRenderer.DrawHorizontalTrack(e.Graphics,
                trackRectangle);
            TrackBarRenderer.DrawTopPointingThumb(e.Graphics,
                thumbRectangle, thumbState);
            TrackBarRenderer.DrawHorizontalTicks(e.Graphics,
                ticksRectangle, numberTicks, EdgeStyle.Raised);
        }

        // Determine whether the user has clicked the track bar thumb.
        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            if (this.thumbRectangle.Contains(e.Location))
            {
                thumbClicked = true;
                thumbState = TrackBarThumbState.Pressed;
            }

            this.Invalidate();
        }

        // Redraw the track bar thumb if the user has moved it.
        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            if (thumbClicked == true)
            {
                if (e.Location.X > trackRectangle.X &&
                    e.Location.X < (trackRectangle.X +
                    trackRectangle.Width - thumbRectangle.Width))
                {
                    thumbClicked = false;
                    thumbState = TrackBarThumbState.Hot;
                    this.Invalidate();
                }

                thumbClicked = false;
            }
        }

        // Track cursor movements.
        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            // The user is moving the thumb.
            if (thumbClicked == true)
            {
                // Track movements to the next tick to the right, if 
                // the cursor has moved halfway to the next tick.
                if (currentTickPosition < numberTicks - 1 &&
                    e.Location.X > CurrentTickXCoordinate() +
                    (int)(tickSpace))
                {
                    currentTickPosition++;
                }

                // Track movements to the next tick to the left, if 
                // cursor has moved halfway to the next tick.
                else if (currentTickPosition > 0 &&
                    e.Location.X < CurrentTickXCoordinate() -
                    (int)(tickSpace / 2))
                {
                    currentTickPosition--;
                }

                thumbRectangle.X = CurrentTickXCoordinate();
            }

            // The cursor is passing over the track.
            else
            {
                thumbState = thumbRectangle.Contains(e.Location) ?
                    TrackBarThumbState.Hot : TrackBarThumbState.Normal;
            }

            Invalidate();
        }
    }
}

Remarques

La TrackBarRenderer classe fournit un ensemble de static méthodes qui peuvent être utilisées pour restituer chaque partie d’un contrôle de barre de suivi avec le style visuel actuel du système d’exploitation. Le rendu d’un contrôle fait référence au dessin de l’interface utilisateur d’un contrôle. Cela est utile si vous dessinez un contrôle personnalisé qui doit avoir l’apparence du style visuel actuel.

Si les styles visuels sont activés dans le système d’exploitation et que les styles visuels sont appliqués à la zone cliente des fenêtres d’application, les méthodes de cette classe dessinent la barre de suivi avec le style visuel actuel. Dans le cas contraire, les méthodes de cette classe lèvent un InvalidOperationException. Pour déterminer si les membres de cette classe peuvent être utilisés, vous pouvez vérifier la valeur de la IsSupported propriété.

Cette classe encapsule les fonctionnalités d’un System.Windows.Forms.VisualStyles.VisualStyleRenderer élément défini sur l’un des éléments exposés par la System.Windows.Forms.VisualStyles.VisualStyleElement.TrackBar classe. Pour plus d’informations, consultez Rendu des contrôles avec les styles visuels.

Propriétés

IsSupported

Obtient une valeur indiquant si la classe TrackBarRenderer peut être utilisée pour dessiner une barre de suivi avec des styles visuels.

Méthodes

DrawBottomPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Dessine un curseur de barre de suivi orienté vers le bas (également connu sous le nom de curseur de défilement) avec les styles visuels.

DrawHorizontalThumb(Graphics, Rectangle, TrackBarThumbState)

Dessine un curseur de barre de suivi horizontal (également connu sous le nom de curseur de défilement) avec les styles visuels.

DrawHorizontalTicks(Graphics, Rectangle, Int32, EdgeStyle)

Dessine le nombre spécifié de graduations de la barre de suivi horizontale avec les styles visuels.

DrawHorizontalTrack(Graphics, Rectangle)

Dessine le rail d'une barre de suivi horizontale avec les styles visuels.

DrawLeftPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Dessine un curseur de barre de suivi orienté vers la gauche (également connu sous le nom de curseur de défilement) avec les styles visuels.

DrawRightPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Dessine un curseur de barre de suivi orienté vers la droite (également connu sous le nom de curseur de défilement) avec les styles visuels.

DrawTopPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Dessine un curseur de barre de suivi orienté vers le haut (également connu sous le nom de curseur de défilement) avec les styles visuels.

DrawVerticalThumb(Graphics, Rectangle, TrackBarThumbState)

Dessine un curseur de barre de suivi vertical (également connu sous le nom de curseur de défilement) avec les styles visuels.

DrawVerticalTicks(Graphics, Rectangle, Int32, EdgeStyle)

Dessine le nombre spécifié de graduations de la barre de suivi verticale avec les styles visuels.

DrawVerticalTrack(Graphics, Rectangle)

Dessine le rail pour une barre de suivi verticale avec les styles visuels.

GetBottomPointingThumbSize(Graphics, TrackBarThumbState)

Retourne la taille, en pixels, du curseur de la barre de suivi (également connu sous le nom de curseur de défilement) orienté vers le bas.

GetLeftPointingThumbSize(Graphics, TrackBarThumbState)

Retourne la taille, en pixels, du curseur de la barre de suivi (également connu sous le nom de curseur de défilement) orienté vers la gauche.

GetRightPointingThumbSize(Graphics, TrackBarThumbState)

Retourne la taille, en pixels, du curseur de la barre de suivi (également connu sous le nom de curseur de défilement) orienté vers la droite.

GetTopPointingThumbSize(Graphics, TrackBarThumbState)

Retourne la taille, en pixels, du curseur de la barre de suivi (également connu sous le nom de curseur de défilement) orienté vers le haut.

S’applique à

Voir aussi