Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

ButtonRenderer-Klasse

Aktualisiert: November 2007

Stellt Methoden bereit, mit denen ein Schaltflächen-Steuerelement mit oder ohne visuelle Stile wiedergegeben werden kann. Diese Klasse kann nicht geerbt werden.

Namespace:  System.Windows.Forms
Assembly:  System.Windows.Forms (in System.Windows.Forms.dll)

public sealed class ButtonRenderer
public final class ButtonRenderer
public final class ButtonRenderer

Die ButtonRenderer-Klasse stellt eine Reihe von static-Methoden bereit, mit denen ein Schaltflächen-Steuerelement wiedergegeben werden kann. Mit Wiedergabe eines Steuerelements ist das Zeichnen der Benutzeroberfläche des Steuerelements gemeint. Zeichnen Sie eine Schaltfläche mit einer der DrawButton-Methoden. Diese Methoden bieten eine Vielzahl von Optionen, z. B. das Zeichnen von Text oder einem Bild auf der Schaltfläche.

Wenn im Betriebssystem visuelle Stile aktiviert sind und auf die aktuelle Anwendung angewendet werden, wird die Schaltfläche von DrawButton mit dem aktuellen visuellen Stil gezeichnet. Andernfalls wird die Schaltfläche von DrawButton im klassischen Windows-Stil gezeichnet. Dies ist hilfreich, wenn Sie ein benutzerdefiniertes Steuerelement zeichnen, das automatisch mit den aktuellen visuellen Stileinstellungen des Betriebssystems übereinstimmen soll.

Diese Klasse ist ein Wrapper für die Funktionen eines System.Windows.Forms.VisualStyles.VisualStyleRenderer, der auf eines der Elemente festgelegt wird, die von der System.Windows.Forms.VisualStyles.VisualStyleElement.Button.PushButton-Klasse verfügbar gemacht werden. Weitere Informationen finden Sie unter Rendering von Steuerelementen mit visuellen Stilen.

Hinweis zu Windows XP Home Edition, Windows XP Professional x64 Edition, Windows Server 2003:

Visuelle Stile werden nur von diesen Plattformen unterstützt.

Im folgenden Codebeispiel wird veranschaulicht, wie ein benutzerdefiniertes Steuerelement erstellt wird, das mithilfe der DrawButton-Methode eine Schaltfläche zeichnet. Wenn auf die Schaltfläche geklickt wird, zeichnet das Steuerelement eine kleinere Schaltfläche innerhalb der Begrenzungen der ursprünglichen Schaltfläche. Das Steuerelement zeichnet mithilfe der DrawParentBackground-Methode über den Rest der ursprünglichen Schaltfläche.

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

namespace ButtonRendererSample
{
    class Form1 : Form
    {
        public Form1()
            : base()
        {
            CustomButton Button1 = new CustomButton();
            Controls.Add(Button1);

            if (Application.RenderWithVisualStyles)
                this.Text = "Visual Styles Enabled";
            else
                this.Text = "Visual Styles Disabled";
        }

        [STAThread]
        static void Main()
        {
            // If you do not call EnableVisualStyles below, then   
            // ButtonRenderer automatically detects this and draws
            // the button without visual styles.
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }
    }

    public class CustomButton : Control
    {
        private Rectangle clickRectangleValue = new Rectangle();
        private PushButtonState state = PushButtonState.Normal;

        public CustomButton()
            : base()
        {
            this.Size = new Size(100, 40);
            this.Location = new Point(50, 50);
            this.Font = SystemFonts.IconTitleFont;
            this.Text = "Click here";
        }

        // Define the bounds of the smaller pressed button.
        public Rectangle ClickRectangle
        {
            get
            {
                clickRectangleValue.X = ClientRectangle.X +
                    (int)(.2 * ClientRectangle.Width);
                clickRectangleValue.Y = ClientRectangle.Y +
                    (int)(.2 * ClientRectangle.Height);
                clickRectangleValue.Width = ClientRectangle.Width -
                    (int)(.4 * ClientRectangle.Width);
                clickRectangleValue.Height = ClientRectangle.Height -
                    (int)(.4 * ClientRectangle.Height);

                return clickRectangleValue;
            }
        }

        // Draw the large or small button, depending on the current state.
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            // Draw the smaller pressed button image
            if (state == PushButtonState.Pressed)
            {
                // Set the background color to the parent if visual styles  
                // are disabled, because DrawParentBackground will only paint  
                // over the control background if visual styles are enabled.
                this.BackColor = Application.RenderWithVisualStyles ?
                    Color.Azure : this.Parent.BackColor;

                // If you comment out the call to DrawParentBackground, 
                // the background of the control will still be visible 
                // outside the pressed button, if visual styles are enabled.
                ButtonRenderer.DrawParentBackground(e.Graphics,
                    ClientRectangle, this);
                ButtonRenderer.DrawButton(e.Graphics, ClickRectangle,
                    this.Text, this.Font, true, state);
            }

            // Draw the bigger unpressed button image.
            else
            {
                ButtonRenderer.DrawButton(e.Graphics, ClientRectangle,
                    this.Text, this.Font, false, state);
            }
        }

        // Draw the smaller pressed button image.
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            this.Text = "Clicked!";
            state = PushButtonState.Pressed;
            Invalidate();
        }

        // Draw the button in the hot state. 
        protected override void OnMouseEnter(EventArgs e)
        {
            base.OnMouseEnter(e);
            this.Text = "Click here";
            state = PushButtonState.Hot;
            Invalidate();
        }

        // Draw the button in the unpressed state.
        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);
            this.Text = "Click here";
            state = PushButtonState.Normal;
            Invalidate();
        }

        // Draw the button hot if the mouse is released on the button. 
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            OnMouseEnter(e);
        }

        // Detect when the cursor leaves the button area while 
        // it is pressed.
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);

            // Detect when the left mouse button is down and   
            // the cursor has left the pressed button area. 
            if ((e.Button & MouseButtons.Left) == MouseButtons.Left &&
                !ClientRectangle.Contains(e.Location) &&
                state == PushButtonState.Pressed)
            {
                OnMouseLeave(e);
            }
        }
    }
}


System.Object
  System.Windows.Forms.ButtonRenderer

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0
Anzeigen: