Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

ButtonRenderer-Klasse

 

Veröffentlicht: Oktober 2016

Bietet Methoden, mit denen ein Schaltflächen-Steuerelement mit oder ohne visuelle Stile gerendert. Diese Klasse kann nicht vererbt werden.

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

System.Object
  System.Windows.Forms.ButtonRenderer

public sealed class ButtonRenderer

NameBeschreibung
System_CAPS_pubpropertySystem_CAPS_staticRenderMatchingApplicationState

Ruft ab oder legt einen Wert, der angibt, ob der Renderer Zustand der Anwendung verwendet, um die Renderingstil zu bestimmen.

NameBeschreibung
System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, Boolean, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen und mit einem optionalen Fokusrechteck.

System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, Image, Rectangle, Boolean, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen, mit dem angegebenen Bild und mit einem optionalen Fokusrechteck.

System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen.

System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, String, Font, Boolean, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen, mit dem angegebenen Text und mit einem optionalen Fokusrechteck.

System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, String, Font, Image, Rectangle, Boolean, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen, mit dem angegebenen Text und Bild und mit einem optionalen Fokusrechteck.

System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, String, Font, TextFormatFlags, Boolean, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen, mit dem angegebenen Text und textformatierung und mit einem optionalen Fokusrechteck.

System_CAPS_pubmethodSystem_CAPS_staticDrawButton(Graphics, Rectangle, String, Font, TextFormatFlags, Image, Rectangle, Boolean, PushButtonState)

Zeichnet ein Schaltflächen-Steuerelement im angegebenen Zustand und Grenzen; mit dem angegebenen Text Formatieren von Text und Bild; und mit einem optionalen Fokusrechteck.

System_CAPS_pubmethodSystem_CAPS_staticDrawParentBackground(Graphics, Rectangle, Control)

Zeichnet den Hintergrund des übergeordneten Elements eines Steuerelements im angegebenen Bereich.

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticIsBackgroundPartiallyTransparent(PushButtonState)

Gibt an, ob der Hintergrund der Schaltfläche halbtransparente Bereiche oder Bereiche mit Alphablending aufweist.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

Die ButtonRenderer -Klasse stellt eine Reihe von static Methoden, die mit einem Schaltflächen-Steuerelement gerendert werden können. Wiedergeben eines Steuerelements zum Zeichnen der Benutzeroberfläche eines Steuerelements. Um eine Schaltfläche zu zeichnen, verwenden Sie eines der DrawButton Methoden. Diese Methoden bieten eine Vielzahl von Optionen, z. B. das Zeichnen von Text oder ein Bild auf die Schaltfläche.

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

Diese Klasse umschließt die Funktionen eines eine System.Windows.Forms.VisualStyles.VisualStyleRenderer festgelegt ist, um eines der Elemente, die verfügbar gemacht werden, indem die System.Windows.Forms.VisualStyles.VisualStyleElement.Button.PushButton Klasse. Weitere Informationen finden Sie unter Rendering von Steuerelementen mit visuellen Stilen.

WinXpFamily

Visual styles are supported only on these platforms.

Im folgenden Codebeispiel wird veranschaulicht, wie ein benutzerdefiniertes Steuerelement zu erstellen, verwendet die DrawButton Methode, um eine Schaltfläche zu zeichnen. Wenn die Schaltfläche geklickt wird, das Steuerelement eine kleinere Schaltfläche innerhalb der Grenzen der ursprünglichen Schaltfläche zeichnet und das Steuerelement verwendet die DrawParentBackground Methode, um den Rest der ursprünglichen Schaltfläche gezeichnet werden soll.

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

.NET Framework
Verfügbar seit 2.0

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: