Freigeben über


TrackBarRenderer Klasse

Definition

Stellt Methoden bereit, mit denen ein Trackleisten-Steuerelement mit visuellen Stilen gerendert werden kann. Diese Klasse kann nicht vererbt werden.

public ref class TrackBarRenderer sealed
public ref class TrackBarRenderer abstract sealed
public sealed class TrackBarRenderer
public static class TrackBarRenderer
type TrackBarRenderer = class
Public NotInheritable Class TrackBarRenderer
Public Class TrackBarRenderer
Vererbung
TrackBarRenderer

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sie ein benutzerdefiniertes Steuerelement erstellen, das die TrackBarRenderer Methoden zum Zeichnen einer horizontalen Spurleiste verwendet, die auf Mausklicks reagiert.

#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>
#using <System.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Windows::Forms::VisualStyles;

namespace TrackBarRendererSample
{
    ref class CustomTrackBar : public Control
    {
    private:
        int numberTicks;
        Rectangle trackRectangle;
        Rectangle ticksRectangle;
        Rectangle thumbRectangle;
        int currentTickPosition;
        float tickSpace;
        bool thumbClicked;
        TrackBarThumbState thumbState;

    public:
        CustomTrackBar(int ticks, System::Drawing::Size trackBarSize)
        {
            this->Location = Point(10, 10);
            this->Size = trackBarSize;
            this->numberTicks = ticks;
            this->BackColor = Color::DarkCyan;
            this->DoubleBuffered = true;
            numberTicks = 10;
            thumbState = TrackBarThumbState::Normal;

            // 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;
            }

            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:
        virtual void OnPaint(PaintEventArgs^ e) override
        {
            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:
        virtual void OnMouseDown(MouseEventArgs^ e) override
        {
            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:
        virtual void OnMouseUp(MouseEventArgs^ e) override
        {
            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:
        virtual void OnMouseMove(MouseEventArgs^ e) override
        {
            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
            {
                if (thumbRectangle.Contains(e->Location))
                {
                    thumbState = TrackBarThumbState::Hot;
                }
                else
                {
                    thumbState = TrackBarThumbState::Normal;
                }
            }

            Invalidate();
        }
    };

    ref class Form1 : public Form
    {
    public:
        Form1()
        {
            CustomTrackBar^ TrackBar1 = gcnew CustomTrackBar(19,
                System::Drawing::Size(300, 50));
            this->Width = 500;
            this->Controls->Add(TrackBar1);
        }
    };
}

[STAThread]
int 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(gcnew TrackBarRendererSample::Form1());
    return 0;
}
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();
        }
    }
}
Imports System.Drawing
Imports System.Windows.Forms
Imports System.Windows.Forms.VisualStyles


Namespace TrackBarRendererSample

    Class Form1
        Inherits Form

        Public Sub New()
            Dim TrackBar1 As New CustomTrackBar(19, New Size(300, 50))
            Me.Width = 500
            Me.Controls.Add(TrackBar1)
        End Sub

        <STAThread()> _
        Shared Sub 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())
        End Sub
    End Class

    Class CustomTrackBar
        Inherits Control
        Private numberTicks As Integer = 10
        Private trackRectangle As New Rectangle()
        Private ticksRectangle As New Rectangle()
        Private thumbRectangle As New Rectangle()
        Private currentTickPosition As Integer = 0
        Private tickSpace As Single = 0
        Private thumbClicked As Boolean = False
        Private thumbState As TrackBarThumbState = TrackBarThumbState.Normal

        Public Sub New(ByVal ticks As Integer, ByVal trackBarSize As Size)

            With Me
                .Location = New Point(10, 10)
                .Size = trackBarSize
                .numberTicks = ticks
                .BackColor = Color.DarkCyan
                .DoubleBuffered = True
            End With

            ' Calculate the initial sizes of the bar, 
            ' thumb and ticks.
            SetupTrackBar()
        End Sub

        ' Calculate the sizes of the bar, thumb, and ticks rectangle.
        Private Sub SetupTrackBar()
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            Using g As Graphics = Me.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 = (CSng(ticksRectangle.Width) - 1) / _
                    (CSng(numberTicks) - 1)

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

                thumbRectangle.X = CurrentTickXCoordinate()
                thumbRectangle.Y = trackRectangle.Y - 8
            End Using
        End Sub

        Private Function CurrentTickXCoordinate() As Integer
            If tickSpace = 0 Then
                Return 0
            Else
                Return CInt(Math.Round(tickSpace)) * currentTickPosition
            End If
        End Function

        ' Draw the track bar.
        Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Me.Parent.Text = "CustomTrackBar Disabled"
                Return
            End If

            Me.Parent.Text = "CustomTrackBar Enabled"
            TrackBarRenderer.DrawHorizontalTrack(e.Graphics, _
                trackRectangle)
            TrackBarRenderer.DrawTopPointingThumb(e.Graphics, _
                thumbRectangle, thumbState)
            TrackBarRenderer.DrawHorizontalTicks(e.Graphics, _
                ticksRectangle, numberTicks, EdgeStyle.Raised)
        End Sub

        ' Determine whether the user has clicked the track bar thumb.
        Protected Overrides Sub OnMouseDown(ByVal e As MouseEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            If Me.thumbRectangle.Contains(e.Location) Then
                thumbClicked = True
                thumbState = TrackBarThumbState.Pressed
            End If

            Me.Invalidate()
        End Sub

        ' Redraw the track bar thumb if the user has moved it.
        Protected Overrides Sub OnMouseUp(ByVal e As MouseEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            If thumbClicked = True Then
                If e.Location.X > trackRectangle.X And _
                    e.Location.X < trackRectangle.X + _
                    trackRectangle.Width - thumbRectangle.Width Then

                    thumbClicked = False
                    thumbState = TrackBarThumbState.Hot
                    Me.Invalidate()
                End If
                thumbClicked = False
            End If
        End Sub

        ' Track cursor movements.
        Protected Overrides Sub OnMouseMove(ByVal e As MouseEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            ' The user is moving the thumb.
            If thumbClicked = True Then

                ' Track movements to the next tick to the right, if the
                ' cursor has moved halfway to the next tick.
                If currentTickPosition < numberTicks - 1 And _
                    e.Location.X > CurrentTickXCoordinate() + _
                    CInt(tickSpace) Then
                    currentTickPosition += 1

                ' Track movements to the next tick to the left, if 
                ' the cursor has moved halfway to the next tick.
                Else
                    If currentTickPosition > 0 And _
                        e.Location.X < CurrentTickXCoordinate() - _
                        CInt(tickSpace / 2) Then
                        currentTickPosition -= 1
                    End If
                End If
                thumbRectangle.X = CurrentTickXCoordinate()

            ' The cursor is passing over the track.
            Else
                If thumbRectangle.Contains(e.Location) Then
                    thumbState = TrackBarThumbState.Hot
                Else
                    thumbState = TrackBarThumbState.Normal
                End If
            End If

            Invalidate()
        End Sub

    End Class
End Namespace

Hinweise

Die TrackBarRenderer Klasse stellt eine Reihe von static Methoden bereit, die verwendet werden können, um jeden Teil eines Track bar-Steuerelements mit dem aktuellen visuellen Stil des Betriebssystems zu rendern. Unter dem Rendern eine Steuerelements versteht man das Zeichnen der Benutzeroberfläche eines Steuerelements. Dies ist nützlich, wenn Sie ein benutzerdefiniertes Steuerelement zeichnen, das das Aussehen des aktuellen visuellen Stils aufweisen sollte.

Wenn visuelle Formatvorlagen im Betriebssystem aktiviert sind und visuelle Formatvorlagen auf den Clientbereich von Anwendungsfenstern angewendet werden, zeichnen die Methoden in dieser Klasse die Trackleiste mit der aktuellen visuellen Formatvorlage. Andernfalls löst die Methoden in dieser Klasse eine InvalidOperationException. Um zu ermitteln, ob die Member dieser Klasse verwendet werden können, können Sie den Wert der IsSupported Eigenschaft überprüfen.

Diese Klasse umschließt die Funktionalität eines System.Windows.Forms.VisualStyles.VisualStyleRenderer Elements, das auf eines der elemente festgelegt ist, die von der System.Windows.Forms.VisualStyles.VisualStyleElement.TrackBar Klasse verfügbar gemacht werden. Weitere Informationen finden Sie unter Renderingsteuerelemente mit visuellen Formatvorlagen.

Eigenschaften

IsSupported

Ruft einen Wert ab, der angibt, ob mithilfe der TrackBarRenderer-Klasse eine Trackleiste mit visuellen Stilen gezeichnet werden kann.

Methoden

DrawBottomPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Zeichnet einen nach unten zeigenden Trackleistenschieberegler, der auch als Ziehpunkt bezeichnet wird, mit visuellen Stilen.

DrawHorizontalThumb(Graphics, Rectangle, TrackBarThumbState)

Zeichnet einen horizontalen Trackleistenschieberegler, der auch als Ziehpunkt bezeichnet wird, mit visuellen Stilen.

DrawHorizontalTicks(Graphics, Rectangle, Int32, EdgeStyle)

Zeichnet die angegebene Anzahl von horizontalen Trackleistenteilstrichen mit visuellen Stilen.

DrawHorizontalTrack(Graphics, Rectangle)

Zeichnet die Laufleiste für eine horizontale Trackleiste mit visuellen Stilen.

DrawLeftPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Zeichnet einen nach links zeigenden Trackleistenschieberegler, der auch als Ziehpunkt bezeichnet wird, mit visuellen Stilen.

DrawRightPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Zeichnet einen nach rechts zeigenden Trackleistenschieberegler, der auch als Ziehpunkt bezeichnet wird, mit visuellen Stilen.

DrawTopPointingThumb(Graphics, Rectangle, TrackBarThumbState)

Zeichnet einen nach oben zeigenden Trackleistenschieberegler, der auch als Ziehpunkt bezeichnet wird, mit visuellen Stilen.

DrawVerticalThumb(Graphics, Rectangle, TrackBarThumbState)

Zeichnet einen vertikalen Trackleistenschieberegler, der auch als Ziehpunkt bezeichnet wird, mit visuellen Stilen.

DrawVerticalTicks(Graphics, Rectangle, Int32, EdgeStyle)

Zeichnet die angegebene Anzahl von vertikalen Trackleistenteilstrichen mit visuellen Stilen.

DrawVerticalTrack(Graphics, Rectangle)

Zeichnet die Laufleiste für eine vertikale Trackleiste mit visuellen Stilen.

GetBottomPointingThumbSize(Graphics, TrackBarThumbState)

Gibt die Größe des nach unten zeigenden Trackleistenschiebereglers, der auch als Ziehpunkt bezeichnet wird, in Pixel zurück.

GetLeftPointingThumbSize(Graphics, TrackBarThumbState)

Gibt die Größe des nach links zeigenden Trackleistenschiebereglers, der auch als Ziehpunkt bezeichnet wird, in Pixel zurück.

GetRightPointingThumbSize(Graphics, TrackBarThumbState)

Gibt die Größe des nach rechts zeigenden Trackleistenschiebereglers, der auch als Ziehpunkt bezeichnet wird, in Pixel zurück.

GetTopPointingThumbSize(Graphics, TrackBarThumbState)

Gibt die Größe des nach oben zeigenden Trackleistenschiebereglers, der auch als Ziehpunkt bezeichnet wird, in Pixel zurück.

Gilt für

Siehe auch