Teilen über


ProgressBarRenderer Klasse

Definition

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

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

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sie ein benutzerdefiniertes Steuerelement erstellen, das die DrawVerticalBar Methoden und DrawVerticalChunks verwendet, um eine vertikale Fortschrittsleiste zu zeichnen. Das Steuerelement verwendet ein Timer , um die Statusleiste mit einem zusätzlichen Stück pro Sekunde neu zu zeichnen. Die SetupProgressBar -Methode verwendet die ChunkThickness Eigenschaften und ChunkSpaceThickness , um die Höhe jedes progressiven größeren Rechtecks zu berechnen, das gezeichnet wird.

#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 ProgressBarRendererSample
{
    public ref class VerticalProgressBar : public Control
    {
    private:
        int numberChunksValue;
        int ticks;
        Timer^ progressTimer;
        array<Rectangle>^ progressBarRectangles;

    public:
        VerticalProgressBar() : Control()
        {
            this->Location = Point(10, 10);
            this->Width = 50;
            progressTimer = gcnew Timer();

            // The progress bar will update every second.
            progressTimer->Interval = 1000;
            progressTimer->Tick += gcnew EventHandler(this,
                &VerticalProgressBar::progressTimer_Tick);

            // This property also calls SetupProgressBar to initialize
            // the progress bar rectangles if styles are enabled.
            NumberChunks = 20;

            // Set the default height if visual styles are not enabled.
            if (!ProgressBarRenderer::IsSupported)
            {
                this->Height = 100;
            }
        }

        // Specify the number of progress bar chunks to base the height on.
    public:
        property int NumberChunks
        {
            int get()
            {
                return numberChunksValue;
            }

            void set(int value)
            {
                if (value <= 50 && value > 0)
                {
                    numberChunksValue = value;
                }
                else
                {
                    MessageBox::Show("Number of chunks must be between " +
                        "0 and 50; defaulting to 10");
                    numberChunksValue = 10;
                }

                // Recalculate the progress bar size, if visual styles
                // are active.
                if (ProgressBarRenderer::IsSupported)
                {
                    SetupProgressBar();
                }
            }
        }

        // Draw the progress bar in its normal state.
    protected:
        virtual void OnPaint(PaintEventArgs^ e) override
        {
            __super::OnPaint(e);

            if (ProgressBarRenderer::IsSupported)
            {
                ProgressBarRenderer::DrawVerticalBar(e->Graphics, 
                    ClientRectangle);
                this->Parent->Text = "VerticalProgressBar Enabled";
            }
            else
            {
                this->Parent->Text = "VerticalProgressBar Disabled";
            }
        }

        // Initialize the rectangles used to paint the states of the
        // progress bar.
    private:
        void SetupProgressBar()
        {
            if (!ProgressBarRenderer::IsSupported)
            {
                return;
            }

            // Determine the size of the progress bar frame.
            this->Size = System::Drawing::Size(ClientRectangle.Width,
                (NumberChunks * (ProgressBarRenderer::ChunkThickness + 
                (2 * ProgressBarRenderer::ChunkSpaceThickness))) + 6);

            // Initialize the rectangles to draw each step of the
            // progress bar.
            progressBarRectangles = gcnew array<Rectangle>(NumberChunks);

            for (int i = 0; i < NumberChunks; i++)
            {
                // Use the thickness defined by the current visual style
                // to calculate the height of each rectangle. The size
                // adjustments ensure that the chunks do not paint over
                // the frame.

                int filledRectangleHeight = 
                    ((i + 1) * (ProgressBarRenderer::ChunkThickness +
                    (2 * ProgressBarRenderer::ChunkSpaceThickness)));

                progressBarRectangles[i] = Rectangle(
                    ClientRectangle.X + 3,
                    ClientRectangle.Y + ClientRectangle.Height - 3
                    - filledRectangleHeight,
                    ClientRectangle.Width - 6,
                    filledRectangleHeight);
            }
        }

        // Handle the timer tick; draw each progressively larger rectangle.
    private:
        void progressTimer_Tick(Object^ myObject, EventArgs^ e)
        {
            if (ticks < NumberChunks)
            {
                Graphics^ g = this->CreateGraphics();
                ProgressBarRenderer::DrawVerticalChunks(g,
                    progressBarRectangles[ticks]);
                ticks++;
            }
            else
            {
                progressTimer->Enabled = false;
            }
        }

        // Start the progress bar.
    public:
        void Start()
        {
            if (ProgressBarRenderer::IsSupported)
            {
                progressTimer->Start();
            }
            else
            {
                MessageBox::Show("VerticalScrollBar requires visual styles");
            }
        }
    };

    public ref class Form1 : public Form
    {
    private:
        VerticalProgressBar^ bar1;
        Button^ button1;

    public:
        Form1() : Form()
        {
            this->Size = System::Drawing::Size(500, 500);
            bar1 = gcnew VerticalProgressBar();
            bar1->NumberChunks = 30;
            button1 = gcnew Button();
            button1->Location = Point(150, 10);
            button1->Size = System::Drawing::Size(150, 30);
            button1->Text = "Start VerticalProgressBar";
            button1->Click += gcnew EventHandler(this, &Form1::button1_Click);
            Controls->AddRange(gcnew array<Control^> { button1, bar1 });
        }

        // Start the VerticalProgressBar.
    private:
        void button1_Click(Object^ sender, EventArgs^ e)
        {
            bar1->Start();
        }
    };
}


[STAThread]
int main()
{
    // The call to EnableVisualStyles below does not affect
    // whether ProgressBarRenderer.IsSupported is true; as
    // long as visual styles are enabled by the operating system,
    // IsSupported is true.
    Application::EnableVisualStyles();
    Application::Run(gcnew ProgressBarRendererSample::Form1());
}
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;

namespace ProgressBarRendererSample
{
    public class Form1 : Form
    {
        private VerticalProgressBar bar1 = new VerticalProgressBar();
        private Button button1 = new Button();

        public Form1()
            : base()
        {
            this.Size = new Size(500, 500);
            bar1.NumberChunks = 30;
            button1.Location = new Point(150, 10);
            button1.Size = new Size(150, 30);
            button1.Text = "Start VerticalProgressBar";
            button1.Click += new EventHandler(button1_Click);
            Controls.AddRange(new Control[] { button1, bar1 });
        }

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

        // Start the VerticalProgressBar.
        private void button1_Click(object sender, EventArgs e)
        {
            bar1.Start();
        }
    }

    public class VerticalProgressBar : Control
    {
        private int numberChunksValue;
        private int ticks;
        private Timer progressTimer = new Timer();
        private Rectangle[] progressBarRectangles;

        public VerticalProgressBar()
            : base()
        {
            this.Location = new Point(10, 10);
            this.Width = 50;

            // The progress bar will update every second.
            progressTimer.Interval = 1000;
            progressTimer.Tick += new EventHandler(progressTimer_Tick);

            // This property also calls SetupProgressBar to initialize 
            // the progress bar rectangles if styles are enabled.
            NumberChunks = 20;

            // Set the default height if visual styles are not enabled.
            if (!ProgressBarRenderer.IsSupported)
            {
                this.Height = 100;
            }
        }

        // Specify the number of progress bar chunks to base the height on.
        public int NumberChunks
        {
            get
            {
                return numberChunksValue;
            }

            set
            {
                if (value <= 50 && value > 0)
                {
                    numberChunksValue = value;
                }
                else
                {
                    MessageBox.Show("Number of chunks must be between " +
                        "0 and 50; defaulting to 10");
                    numberChunksValue = 10;
                }

                // Recalculate the progress bar size, if visual styles 
                // are active.
                if (ProgressBarRenderer.IsSupported)
                {
                    SetupProgressBar();
                }
            }
        }

        // Draw the progress bar in its normal state.
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            if (ProgressBarRenderer.IsSupported)
            {
                ProgressBarRenderer.DrawVerticalBar(e.Graphics,
                    ClientRectangle);
                this.Parent.Text = "VerticalProgressBar Enabled";
            }
            else
            {
                this.Parent.Text = "VerticalProgressBar Disabled";
            }
        }

        // Initialize the rectangles used to paint the states of the 
        // progress bar.
        private void SetupProgressBar()
        {
            if (!ProgressBarRenderer.IsSupported)
            {
                return;
            }

            // Determine the size of the progress bar frame.
            this.Size = new Size(ClientRectangle.Width,
                (NumberChunks) * (ProgressBarRenderer.ChunkThickness +
                (2 * ProgressBarRenderer.ChunkSpaceThickness)) + 6);

            // Initialize the rectangles to draw each step of the 
            // progress bar.
            progressBarRectangles = new Rectangle[NumberChunks];

            for (int i = 0; i < NumberChunks; i++)
            {
                // Use the thickness defined by the current visual style 
                // to calculate the height of each rectangle. The size 
                // adjustments ensure that the chunks do not paint over 
                // the frame.

                int filledRectangleHeight =
                    ((i + 1) * (ProgressBarRenderer.ChunkThickness +
                    (2 * ProgressBarRenderer.ChunkSpaceThickness)));

                progressBarRectangles[i] = new Rectangle(
                    ClientRectangle.X + 3,
                    ClientRectangle.Y + ClientRectangle.Height - 3
                    - filledRectangleHeight,
                    ClientRectangle.Width - 6,
                    filledRectangleHeight);
            }
        }

        // Handle the timer tick; draw each progressively larger rectangle.
        private void progressTimer_Tick(Object myObject, EventArgs e)
        {
            if (ticks < NumberChunks)
            {
                using (Graphics g = this.CreateGraphics())
                {
                    ProgressBarRenderer.DrawVerticalChunks(g,
                        progressBarRectangles[ticks]);
                    ticks++;
                }
            }
            else
            {
                progressTimer.Enabled = false;
            }
        }

        // Start the progress bar.
        public void Start()
        {
            if (ProgressBarRenderer.IsSupported)
            {
                progressTimer.Start();
            }
            else
            {
                MessageBox.Show("VerticalScrollBar requires visual styles");
            }
        }
    }
}
Imports System.Drawing
Imports System.Windows.Forms
Imports System.Windows.Forms.VisualStyles



Public Class Form1
    Inherits Form
    Private bar1 As New VerticalProgressBar()
    Private button1 As New Button()
    
    
    Public Sub New() 
        Me.Size = New Size(500, 500)
        bar1.NumberChunks = 30
        button1.Location = New Point(150, 10)
        button1.Size = New Size(150, 30)
        button1.Text = "Start VerticalProgressBar"
        AddHandler button1.Click, AddressOf button1_Click
        Controls.AddRange(New Control() {button1, bar1})
    
    End Sub
    
    
    <STAThread()>  _
    Public Shared Sub Main() 
        ' The call to EnableVisualStyles below does not affect
        ' whether ProgressBarRenderer.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
    
    
    ' Start the VerticalProgressBar.
    Private Sub button1_Click(ByVal sender As Object, ByVal e As EventArgs) 
        bar1.Start()
    
    End Sub
End Class


Public Class VerticalProgressBar
    Inherits Control
    Private numberChunksValue As Integer
    Private ticks As Integer
    Private progressTimer As New Timer()
    Private progressBarRectangles() As Rectangle
    
    
    Public Sub New() 
        Me.Location = New Point(10, 10)
        Me.Width = 50
        
        ' The progress bar will update every second.
        progressTimer.Interval = 1000
        AddHandler progressTimer.Tick, AddressOf progressTimer_Tick
        
        ' This property also calls SetupProgressBar to initialize 
        ' the progress bar rectangles if styles are enabled.
        NumberChunks = 20
        
        ' Set the default height if visual styles are not enabled.
        If Not ProgressBarRenderer.IsSupported Then
            Me.Height = 100
        End If
    
    End Sub
    
    ' Specify the number of progress bar chunks to base the height on.
    
    Public Property NumberChunks() As Integer 
        Get
            Return numberChunksValue
        End Get
        
        Set
            If value <= 50 AndAlso value > 0 Then
                numberChunksValue = value
            Else
                MessageBox.Show("Number of chunks must be between " + "0 and 50; defaulting to 10")
                numberChunksValue = 10
            End If
            
            ' Recalculate the progress bar size, if visual styles 
            ' are active.
            If ProgressBarRenderer.IsSupported Then
                SetupProgressBar()
            End If
        End Set
    End Property
    
    
    ' Draw the progress bar in its normal state.
    Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs) 
        MyBase.OnPaint(e)
        
        If ProgressBarRenderer.IsSupported Then
            ProgressBarRenderer.DrawVerticalBar(e.Graphics, ClientRectangle)
            Me.Parent.Text = "VerticalProgressBar Enabled"
        Else
            Me.Parent.Text = "VerticalProgressBar Disabled"
        End If
    
    End Sub
    
    ' Initialize the rectangles used to paint the states of the 
    ' progress bar.
    Private Sub SetupProgressBar() 
        If Not ProgressBarRenderer.IsSupported Then
            Return
        End If
        
        ' Determine the size of the progress bar frame.
        Me.Size = New Size(ClientRectangle.Width, NumberChunks *(ProgressBarRenderer.ChunkThickness + 2 * ProgressBarRenderer.ChunkSpaceThickness) + 6)
        
        ' Initialize the rectangles to draw each step of the 
        ' progress bar.
        progressBarRectangles = New Rectangle(NumberChunks) {}
        
        Dim i As Integer
        For i = 0 To NumberChunks
            ' Use the thickness defined by the current visual style 
            ' to calculate the height of each rectangle. The size 
            ' adjustments ensure that the chunks do not paint over 
            ' the frame.
            Dim filledRectangleHeight As Integer = (i + 1)  _
        *(ProgressBarRenderer.ChunkThickness + 2 * ProgressBarRenderer.ChunkSpaceThickness)
            
            progressBarRectangles(i) = New Rectangle(ClientRectangle.X + 3, _
                ClientRectangle.Y + ClientRectangle.Height - 3 - filledRectangleHeight, _
                ClientRectangle.Width - 6, filledRectangleHeight)
        Next i
    
    End Sub
    
    ' Handle the timer tick; draw each progressively larger rectangle.
    Private Sub progressTimer_Tick(ByVal myObject As [Object], ByVal e As EventArgs) 
        If ticks < NumberChunks Then
            Dim g As Graphics = Me.CreateGraphics()
            Try
                ProgressBarRenderer.DrawVerticalChunks(g, progressBarRectangles(ticks))
                ticks += 1
            Finally
                g.Dispose()
            End Try
        Else
            progressTimer.Enabled = False
        End If
    
    End Sub
    
    ' Start the progress bar.
    Public Sub Start() 
        If ProgressBarRenderer.IsSupported Then
            progressTimer.Start()
        Else
            MessageBox.Show("VerticalScrollBar requires visual styles")
        End If
    
    End Sub
End Class

Hinweise

Die ProgressBarRenderer -Klasse stellt eine Reihe von static Methoden bereit, mit denen ein Statusleistensteuerelement mit dem aktuellen visuellen Stil des Betriebssystems gerendert werden kann. 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 die Darstellung des aktuellen visuellen Stils aufweisen soll. Um eine Statusleiste zu zeichnen, verwenden Sie die DrawHorizontalBar - oder DrawVerticalBar -Methoden, um den leeren Balken zu zeichnen, und verwenden Sie dann die DrawHorizontalChunks -Methode oder DrawVerticalChunks , um die Elemente zu zeichnen, die den Balken ausfüllen.

Wenn visuelle Stile im Betriebssystem aktiviert sind und visuelle Stile auf den Clientbereich von Anwendungsfenstern angewendet werden, zeichnen die Methoden dieser Klasse die Statusleiste mit dem aktuellen visuellen Stil. Andernfalls lösen die Methoden und Eigenschaften dieser Klasse einen aus InvalidOperationException. Um zu bestimmen, 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 , das auf eines der Elemente festgelegt ist, die von den System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.BarKlassen , System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.BarVertical, System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.Chunkund System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.ChunkVertical verfügbar gemacht werden. Weitere Informationen finden Sie unter Rendering von Steuerelementen mit visuellen Stilen.

Eigenschaften

ChunkSpaceThickness

Ruft die Breite des Abstands zwischen den inneren Teilen der Statusanzeige in Pixel ab.

ChunkThickness

Ruft die Breite eines einzelnen inneren Teils der Statusanzeige in Pixel ab.

IsSupported

Ruft einen Wert ab, der angibt, ob mithilfe der ProgressBarRenderer-Klasse ein Statusanzeige-Steuerelement mit visuellen Stilen gezeichnet werden kann.

Methoden

DrawHorizontalBar(Graphics, Rectangle)

Zeichnet ein leeres Statusanzeige-Steuerelement, das horizontal ausgefüllt wird.

DrawHorizontalChunks(Graphics, Rectangle)

Zeichnet eine Reihe von Teilen der Statusanzeige, die eine horizontale Statusanzeige füllen.

DrawVerticalBar(Graphics, Rectangle)

Zeichnet ein leeres Statusanzeige-Steuerelement, das vertikal ausgefüllt wird.

DrawVerticalChunks(Graphics, Rectangle)

Zeichnet eine Reihe von Teilen der Statusanzeige, die eine vertikale Statusanzeige füllen.

Gilt für:

Weitere Informationen