ProgressBarRenderer Classe

Definição

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

Herança

Object

ProgressBarRenderer

Exemplos

O exemplo de código a seguir demonstra como criar um controle personalizado que usa o e DrawVerticalChunks os DrawVerticalBar métodos para desenhar uma barra de progresso vertical. O controle usa um Timer para redesenhar a barra de progresso com uma peça adicionada a cada segundo. O SetupProgressBar método usa as ChunkThickness propriedades e ChunkSpaceThickness para calcular a altura de cada retângulo progressivamente maior que é desenhado.

#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

Comentários

A ProgressBarRenderer classe fornece um conjunto de static métodos que podem ser usados para renderizar um controle de barra de progresso com o estilo visual atual do sistema operacional. Renderizar um controle refere-se a desenhar a interface do usuário de um controle. Isso será útil se você estiver desenhando um controle personalizado que deve ter a aparência do estilo visual atual. Para desenhar uma barra de progresso, use os métodos ou DrawVerticalBar os DrawHorizontalBar métodos para desenhar a barra vazia e, em seguida, use os métodos ou DrawVerticalChunks os DrawHorizontalChunks elementos que preenchem a barra.

Se os estilos visuais estiverem habilitados no sistema operacional e os estilos visuais forem aplicados à área do cliente das janelas do aplicativo, os métodos dessa classe desenharão a barra de progresso com o estilo visual atual. Caso contrário, os métodos e as propriedades dessa classe lançarão um InvalidOperationException. Para determinar se os membros dessa classe podem ser usados, você pode verificar o valor da IsSupported propriedade.

Essa classe encapsula a funcionalidade de um System.Windows.Forms.VisualStyles.VisualStyleRenderer que é definido como um dos elementos expostos por System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.Bar, System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.BarVertical, System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.Chunke System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar.ChunkVertical classes. Para obter mais informações, consulte Controles de renderização com estilos visuais.

Propriedades

Métodos

Aplica-se a

Confira também

• VisualStyleRenderer
• VisualStyleElement