VisualStyleRenderer クラス

定義

VisualStyleElementに関する情報を描画および取得するためのメソッドを提供します。 このクラスは継承できません。

public ref class VisualStyleRenderer sealed
public sealed class VisualStyleRenderer
type VisualStyleRenderer = class
Public NotInheritable Class VisualStyleRenderer
継承
VisualStyleRenderer

次のコード例では、VisualStyleRenderer クラスを使用して、タイトル バーでのドラッグ、サイズ変更ハンドルによるサイズ変更、閉じるなど、ウィンドウの基本的な UI の一部をシミュレートするカスタム コントロールを実装します。 この例では、VisualStyleElement.Window.CaptionVisualStyleElement.Window.CloseButton、および VisualStyleElement.Status.Gripper クラスによって公開される要素など、ウィンドウの標準部分を表す複数の VisualStyleElement オブジェクトを使用します。

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

using namespace System;
using namespace System::Text;
using namespace System::Drawing;
using namespace System::Drawing::Drawing2D;
using namespace System::Collections::Generic;
using namespace System::Windows::Forms;
using namespace System::Windows::Forms::VisualStyles;

namespace VisualStyleRendererSample
{

    public ref class WindowSimulation : public Control
    {
    private:
        Dictionary<String^, VisualStyleElement^>^ windowElements;
        Dictionary<String^, Rectangle>^ elementRectangles;
        VisualStyleRenderer^ renderer;
        Point closeButtonOffset;
        System::Drawing::Size gripperSize;
        System::Drawing::Size closeButtonSize;
        bool isResizing;
        bool isMoving;
        bool isClosing;
        int captionHeight;
        int frameThickness;
        int statusHeight;
        Point originalClick;
        Point resizeOffset;

    public:
        WindowSimulation() : Control()
        {
            statusHeight = 22;
            windowElements = gcnew Dictionary<String^, VisualStyleElement^>();
            elementRectangles = gcnew Dictionary<String^, Rectangle>();
            this->Location = Point(50, 50);
            this->Size = System::Drawing::Size(350, 300);
            this->BackColor = Color::Azure;
            this->DoubleBuffered = true;
            this->MinimumSize = System::Drawing::Size(300, 200);
            this->Font = SystemFonts::CaptionFont;
            this->Text = "Simulated Window";

            // Insert the VisualStyleElement objects into the Dictionary.
            windowElements->Add("windowCaption",
                VisualStyleElement::Window::Caption::Active);
            windowElements->Add("windowBottom",
                VisualStyleElement::Window::FrameBottom::Active);
            windowElements->Add("windowLeft",
                VisualStyleElement::Window::FrameLeft::Active);
            windowElements->Add("windowRight",
                VisualStyleElement::Window::FrameRight::Active);
            windowElements->Add("windowClose",
                VisualStyleElement::Window::CloseButton::Normal);
            windowElements->Add("statusBar",
                VisualStyleElement::Status::Bar::Normal);
            windowElements->Add("statusGripper",
                VisualStyleElement::Status::Gripper::Normal);

            // Get the sizes and location offsets for the window parts
            // as specified by the visual style, and then use this
            // information to calcualate the rectangles for each part.
            GetPartDetails();
            CalculateRectangles();

            this->MouseDown +=
                gcnew MouseEventHandler(this,
                    &WindowSimulation::ImitationWindow_MouseDown);
            this->MouseUp +=
                gcnew MouseEventHandler(this,
                    &WindowSimulation::ImitationWindow_MouseUp);
            this->MouseMove +=
                gcnew MouseEventHandler(this,
                    &WindowSimulation::ImitationWindow_MouseMove);
        }

        // Get the sizes and offsets for the window parts as specified
        // by the visual style.
    private:
        void GetPartDetails()
        {
            // Do nothing further if visual styles are not enabled.
            if (!Application::RenderWithVisualStyles)
            {
                return;
            }

            Graphics^ g = this->CreateGraphics();

            // Get the size and offset of the close button.
            if (SetRenderer(windowElements["windowClose"]))
            {
                closeButtonSize =
                    renderer->GetPartSize(g, ThemeSizeType::True);
                closeButtonOffset =
                    renderer->GetPoint(PointProperty::Offset);
            }

            // Get the height of the window caption.
            if (SetRenderer(windowElements["windowCaption"]))
            {
                captionHeight = renderer->GetPartSize(g,
                    ThemeSizeType::True).Height;
            }

            // Get the thickness of the left, bottom,
            // and right window frame.
            if (SetRenderer(windowElements["windowLeft"]))
            {
                frameThickness = renderer->GetPartSize(g,
                    ThemeSizeType::True).Width;
            }

            // Get the size of the resizing gripper.
            if (SetRenderer(windowElements["statusGripper"]))
            {
                gripperSize = renderer->GetPartSize(g,
                    ThemeSizeType::True);
            }

        }

        // Use the part metrics to determine the current size
        // of the rectangles for all of the window parts.
    private:
        void CalculateRectangles()
        {
            int heightMinusFrame =
                ClientRectangle.Height - frameThickness;

            // Calculate the window frame rectangles and add them
            // to the Dictionary of rectangles.
            elementRectangles["windowCaption"] = Rectangle(0, 0,
                ClientRectangle.Width, captionHeight);
            elementRectangles["windowBottom"] = Rectangle(0,
                heightMinusFrame, ClientRectangle.Width, frameThickness);
            elementRectangles["windowLeft"] = Rectangle(0, captionHeight,
                frameThickness, heightMinusFrame - captionHeight);
            elementRectangles["windowRight"] = Rectangle(
                ClientRectangle.Width - frameThickness, captionHeight,
                frameThickness, heightMinusFrame - captionHeight);

            // Calculate the window button rectangle and add it
            // to the Dictionary of rectangles.
            elementRectangles["windowClose"] =
                Rectangle(ClientRectangle.Right +
                    closeButtonOffset.X - closeButtonSize.Width - frameThickness, closeButtonOffset.Y,
                    closeButtonSize.Width, closeButtonSize.Height);

            // Calculate the status bar rectangles and add them
            // to the Dictionary of rectangles.
            elementRectangles["statusBar"] =
                Rectangle(frameThickness,
                    heightMinusFrame - statusHeight,
                    ClientRectangle.Width - (2 * frameThickness),
                    statusHeight);
            elementRectangles["statusGripper"] =
                Rectangle(ClientRectangle.Right -
                gripperSize.Width - frameThickness,
                heightMinusFrame - gripperSize.Height,
                gripperSize.Width, gripperSize.Height);
        }

    protected:
        virtual void OnPaint(PaintEventArgs^ e) override
        {
            __super::OnPaint(e);

            // Ensure that visual styles are supported.
            if (!Application::RenderWithVisualStyles)
            {
                this->Text = "Visual styles are not enabled.";
                TextRenderer::DrawText(e->Graphics, this->Text,
                    this->Font, this->Location, this->ForeColor);
                return;
            }

            // Set the clip region to define the curved corners
            // of the caption.
            SetClipRegion();

            // Draw each part of the window.
            for each(KeyValuePair<String^, VisualStyleElement^>^ entry
                in windowElements)
            {
                if (SetRenderer(entry->Value))
                {
                    renderer->DrawBackground(e->Graphics,
                        elementRectangles[entry->Key]);
                }
            }

            // Draw the caption text.
            TextRenderer::DrawText(e->Graphics, this->Text, this->Font,
                elementRectangles["windowCaption"], Color::White,
                TextFormatFlags::VerticalCenter |
                TextFormatFlags::HorizontalCenter);
        }
private:
        // Initiate dragging, resizing, or closing the imitation window.
        void ImitationWindow_MouseDown(Object^ sender, MouseEventArgs^ e)
        {
            // The user clicked the close button.
            if (elementRectangles["windowClose"].Contains(e->Location))
            {
                windowElements["windowClose"] =
                    VisualStyleElement::Window::CloseButton::Pressed;
                isClosing = true;
            }

            // The user clicked the status grip.
            else if (elementRectangles["statusGripper"].Contains(e->Location))
            {
                isResizing = true;
                this->Cursor = Cursors::SizeNWSE;
                resizeOffset.X = this->Right - this->Left - e->X;
                resizeOffset.Y = this->Bottom - this->Top - e->Y;
            }

            // The user clicked the window caption.
            else if (elementRectangles["windowCaption"].Contains(e->Location))
            {
                isMoving = true;
                originalClick.X = e->X;
                originalClick.Y = e->Y;
            }

            Invalidate();
        }

        // Stop any current resizing or moving actions.
        void ImitationWindow_MouseUp(Object^ sender, MouseEventArgs^ e)
        {
            // Stop moving the location of the window rectangles.
            if (isMoving)
            {
                isMoving = false;
            }

            // Change the cursor back to the default if the user
            // stops resizing.
            else if (isResizing)
            {
                isResizing = false;
            }

            // Close the application if the user clicks the
            // close button.
            else if (elementRectangles["windowClose"].Contains(e->Location) 
                && isClosing)
            {
                Application::Exit();
            }
        }

        // Handle resizing or moving actions.
        void ImitationWindow_MouseMove(Object^ sender,
            MouseEventArgs^ e)
        {
            // The left mouse button is down.
            if ((::MouseButtons::Left & e->Button) == ::MouseButtons::Left)
            {
                // Calculate the new control size if the user is
                // dragging the resizing grip.
                if (isResizing)
                {
                    this->Width = e->X + resizeOffset.X;
                    this->Height = e->Y + resizeOffset.Y;
                    CalculateRectangles();
                }

                // Calculate the new location of the control if the
                // user is dragging the window caption.
                else if (isMoving)
                {
                    int XChange = this->Location.X + (e->X - originalClick.X);
                    int YChange = this->Location.Y + (e->Y - originalClick.Y);
                    this->Location = Point(XChange, YChange);
                }

                // Cancel the closing action if the user clicked
                // and held down on the close button, and has dragged
                // the pointer outside the button.
                else if (!elementRectangles["windowClose"].Contains(
                    e->Location) && isClosing)
                {
                    isClosing = false;
                    windowElements["windowClose"] =
                        VisualStyleElement::Window::CloseButton::Normal;
                }
            }

            // The left mouse button is not down.
            else
            {
                // Paint the close button hot if the cursor is on it.
                Rectangle^ closeRectangle =
                    elementRectangles["windowClose"];
                if (closeRectangle->Contains(e->Location))
                {
                    windowElements["windowClose"] =
                        VisualStyleElement::Window::CloseButton::Hot;
                }
                else
                {
                    windowElements["windowClose"] =
                        VisualStyleElement::Window::CloseButton::Normal;
                }


                // Use a resizing cursor if the cursor is on the
                // status grip.
                Rectangle^ gripRectangle = elementRectangles["statusGripper"];
                if (gripRectangle->Contains(e->Location))
                {
                    this->Cursor = Cursors::SizeNWSE;
                }
                else
                {
                    this->Cursor = Cursors::Default;
                }
            }

            Invalidate();
        }

        // Calculate and set the clipping region for the control
        // so that the corners of the title bar are rounded.
    private:
        void SetClipRegion()
        {
            if (!Application::RenderWithVisualStyles)
            {
                return;
            }

            Graphics^ g = this->CreateGraphics();
            // Get the current region for the window caption.
            if (SetRenderer(windowElements["windowCaption"]))
            {
                System::Drawing::Region^ clipRegion =
                    renderer->GetBackgroundRegion(g,
                    elementRectangles["windowCaption"]);

                // Get the client rectangle, but exclude the region
                // of the window caption.
                int height = (int)clipRegion->GetBounds(g).Height;
                System::Drawing::Rectangle nonCaptionRect = Rectangle(
                    ClientRectangle.X, ClientRectangle.Y + height,
                    ClientRectangle.Width, ClientRectangle.Height - height);

                // Add the rectangle to the caption region, and
                // make this region the form's clipping region.
                clipRegion->Union(nonCaptionRect);
                this->Region = clipRegion;
            }

        }

        // Set the VisualStyleRenderer to a new element.
    private:
        bool SetRenderer(VisualStyleElement^ element)
        {
            if (!VisualStyleRenderer::IsElementDefined(element))
            {
                return false;
            }

            if (renderer == nullptr)
            {
                renderer = gcnew VisualStyleRenderer(element);
            }
            else
            {
                renderer->SetParameters(element);
            }

            return true;
        }
    };

    public ref class Form1 : public Form
    {
    public:
        Form1() : Form()
        {
            this->Size = System::Drawing::Size(800, 600);
            this->Location = Point(20, 20);
            this->BackColor = Color::DarkGray;
            WindowSimulation^ ws = gcnew WindowSimulation();
            Controls->Add(ws);
        }

    };
}

[STAThread]
int main()
{
    Application::EnableVisualStyles();
    Application::Run(gcnew VisualStyleRendererSample::Form1());
}
using System;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;

namespace VisualStyleRendererSample
{
    class Form1 : Form
    {
        public Form1()
            : base()
        {
            this.Size = new Size(800, 600);
            this.Location = new Point(20, 20);
            this.BackColor = Color.DarkGray;
            WindowSimulation Window1 = new WindowSimulation();
            Controls.Add(Window1);
        }

        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }
    }

    public class WindowSimulation : Control
    {
        private Dictionary<string, VisualStyleElement> windowElements =
            new Dictionary<string, VisualStyleElement>();
        private Dictionary<string, Rectangle> elementRectangles =
            new Dictionary<string, Rectangle>();
        private VisualStyleRenderer renderer = null;

        private Point closeButtonOffset;
        private Size gripperSize;
        private Size closeButtonSize;
        private bool isResizing = false;
        private bool isMoving = false;
        private bool isClosing = false;
        private int captionHeight;
        private int frameThickness;
        private int statusHeight = 22;
        private Point originalClick = new Point();
        private Point resizeOffset = new Point();

        public WindowSimulation()
            : base()
        {
            this.Location = new Point(50, 50);
            this.Size = new Size(350, 300);
            this.BackColor = Color.Azure;
            this.DoubleBuffered = true;
            this.MinimumSize = new Size(300, 200);
            this.Font = SystemFonts.CaptionFont;
            this.Text = "Simulated Window";

            // Insert the VisualStyleElement objects into the Dictionary.
            windowElements.Add("windowCaption",
                VisualStyleElement.Window.Caption.Active);
            windowElements.Add("windowBottom",
                VisualStyleElement.Window.FrameBottom.Active);
            windowElements.Add("windowLeft",
                VisualStyleElement.Window.FrameLeft.Active);
            windowElements.Add("windowRight",
                VisualStyleElement.Window.FrameRight.Active);
            windowElements.Add("windowClose",
                VisualStyleElement.Window.CloseButton.Normal);
            windowElements.Add("statusBar",
                VisualStyleElement.Status.Bar.Normal);
            windowElements.Add("statusGripper",
                VisualStyleElement.Status.Gripper.Normal);

            // Get the sizes and location offsets for the window parts  
            // as specified by the visual style, and then use this 
            // information to calcualate the rectangles for each part.
            GetPartDetails();
            CalculateRectangles();

            this.MouseDown +=
                new MouseEventHandler(ImitationWindow_MouseDown);
            this.MouseUp +=
                new MouseEventHandler(ImitationWindow_MouseUp);
            this.MouseMove +=
                new MouseEventHandler(ImitationWindow_MouseMove);
        }

        // Get the sizes and offsets for the window parts as specified  
        // by the visual style.
        private void GetPartDetails()
        {
            // Do nothing further if visual styles are not enabled.
            if (!Application.RenderWithVisualStyles)
            {
                return;
            }

            using (Graphics g = this.CreateGraphics())
            {
                // Get the size and offset of the close button.
                if (SetRenderer(windowElements["windowClose"]))
                {
                    closeButtonSize =
                        renderer.GetPartSize(g, ThemeSizeType.True);
                    closeButtonOffset =
                        renderer.GetPoint(PointProperty.Offset);
                }

                // Get the height of the window caption.
                if (SetRenderer(windowElements["windowCaption"]))
                {
                    captionHeight = renderer.GetPartSize(g,
                        ThemeSizeType.True).Height;
                }

                // Get the thickness of the left, bottom, 
                // and right window frame.
                if (SetRenderer(windowElements["windowLeft"]))
                {
                    frameThickness = renderer.GetPartSize(g,
                        ThemeSizeType.True).Width;
                }

                // Get the size of the resizing gripper.
                if (SetRenderer(windowElements["statusGripper"]))
                {
                    gripperSize = renderer.GetPartSize(g,
                        ThemeSizeType.True);
                }
            }
        }

        // Use the part metrics to determine the current size 
        // of the rectangles for all of the window parts.
        private void CalculateRectangles()
        {
            int heightMinusFrame =
                ClientRectangle.Height - frameThickness;

            // Calculate the window frame rectangles and add them
            // to the Dictionary of rectangles.
            elementRectangles["windowCaption"] =
                new Rectangle(0, 0,
                ClientRectangle.Width, captionHeight);
            elementRectangles["windowBottom"] =
                new Rectangle(0, heightMinusFrame,
                ClientRectangle.Width, frameThickness);
            elementRectangles["windowLeft"] =
                new Rectangle(0, captionHeight, frameThickness,
                heightMinusFrame - captionHeight);
            elementRectangles["windowRight"] =
                new Rectangle(ClientRectangle.Width - frameThickness,
                captionHeight, frameThickness,
                heightMinusFrame - captionHeight);

            // Calculate the window button rectangle and add it
            // to the Dictionary of rectangles.
            elementRectangles["windowClose"] =
                new Rectangle(ClientRectangle.Right +
                closeButtonOffset.X - closeButtonSize.Width - frameThickness, closeButtonOffset.Y,
                closeButtonSize.Width, closeButtonSize.Height);

            // Calculate the status bar rectangles and add them
            // to the Dictionary of rectangles.
            elementRectangles["statusBar"] =
                new Rectangle(frameThickness,
                heightMinusFrame - statusHeight,
                ClientRectangle.Width - (2 * frameThickness),
                statusHeight);
            elementRectangles["statusGripper"] =
                new Rectangle(ClientRectangle.Right -
                gripperSize.Width - frameThickness,
                heightMinusFrame - gripperSize.Height,
                gripperSize.Width, gripperSize.Height);
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            // Ensure that visual styles are supported.
            if (!Application.RenderWithVisualStyles)
            {
                this.Text = "Visual styles are not enabled.";
                TextRenderer.DrawText(e.Graphics, this.Text,
                    this.Font, this.Location, this.ForeColor);
                return;
            }

            // Set the clip region to define the curved corners 
            // of the caption.
            SetClipRegion();

            // Draw each part of the window.
            foreach (KeyValuePair<string, VisualStyleElement> entry
                in windowElements)
            {
                if (SetRenderer(entry.Value))
                {
                    renderer.DrawBackground(e.Graphics,
                        elementRectangles[entry.Key]);
                }
            }

            // Draw the caption text.
            TextRenderer.DrawText(e.Graphics, this.Text, this.Font,
                elementRectangles["windowCaption"], Color.White,
                TextFormatFlags.VerticalCenter |
                TextFormatFlags.HorizontalCenter);
        }

        // Initiate dragging, resizing, or closing the imitation window.
        void ImitationWindow_MouseDown(object sender, MouseEventArgs e)
        {
            // The user clicked the close button.
            if (elementRectangles["windowClose"].Contains(e.Location))
            {
                windowElements["windowClose"] =
                    VisualStyleElement.Window.CloseButton.Pressed;
                isClosing = true;
            }

            // The user clicked the status grip.
            else if (elementRectangles["statusGripper"].
                Contains(e.Location))
            {
                isResizing = true;
                this.Cursor = Cursors.SizeNWSE;
                resizeOffset.X = this.Right - this.Left - e.X;
                resizeOffset.Y = this.Bottom - this.Top - e.Y;
            }

            // The user clicked the window caption.
            else if (elementRectangles["windowCaption"].
                Contains(e.Location))
            {
                isMoving = true;
                originalClick.X = e.X;
                originalClick.Y = e.Y;
            }

            Invalidate();
        }

        // Stop any current resizing or moving actions.
        void ImitationWindow_MouseUp(object sender, MouseEventArgs e)
        {
            // Stop moving the location of the window rectangles.
            if (isMoving)
            {
                isMoving = false;
            }

            // Change the cursor back to the default if the user 
            // stops resizing.
            else if (isResizing)
            {
                isResizing = false;
            }

            // Close the application if the user clicks the 
            // close button.
            else if (elementRectangles["windowClose"].
                Contains(e.Location) && isClosing)
            {
                Application.Exit();
            }
        }

        // Handle resizing or moving actions.
        void ImitationWindow_MouseMove(object sender,
            MouseEventArgs e)
        {
            // The left mouse button is down.
            if ((MouseButtons.Left & e.Button) == MouseButtons.Left)
            {
                // Calculate the new control size if the user is 
                // dragging the resizing grip.
                if (isResizing)
                {
                    this.Width = e.X + resizeOffset.X;
                    this.Height = e.Y + resizeOffset.Y;
                    CalculateRectangles();
                }

                // Calculate the new location of the control if the  
                // user is dragging the window caption.
                else if (isMoving)
                {
                    int XChange = this.Location.X +
                        (e.X - originalClick.X);
                    int YChange = this.Location.Y +
                        (e.Y - originalClick.Y);
                    this.Location = new Point(XChange, YChange);
                }

                // Cancel the closing action if the user clicked  
                // and held down on the close button, and has dragged   
                // the pointer outside the button.
                else if (!elementRectangles["windowClose"].
                    Contains(e.Location) && isClosing)
                {
                    isClosing = false;
                    windowElements["windowClose"] =
                        VisualStyleElement.Window.CloseButton.Normal;
                }
            }

            // The left mouse button is not down.
            else
            {
                // Paint the close button hot if the cursor is on it.
                Rectangle closeRectangle =
                    elementRectangles["windowClose"];
                windowElements["windowClose"] =
                    closeRectangle.Contains(e.Location) ?
                    VisualStyleElement.Window.CloseButton.Hot :
                    VisualStyleElement.Window.CloseButton.Normal;

                // Use a resizing cursor if the cursor is on the 
                // status grip.
                Rectangle gripRectangle =
                    elementRectangles["statusGripper"];
                this.Cursor = gripRectangle.Contains(e.Location) ?
                    Cursors.SizeNWSE : Cursors.Default;
            }

            Invalidate();
        }

        // Calculate and set the clipping region for the control  
        // so that the corners of the title bar are rounded.
        private void SetClipRegion()
        {
            if (!Application.RenderWithVisualStyles)
            {
                return;
            }

            using (Graphics g = this.CreateGraphics())
            {
                // Get the current region for the window caption.
                if (SetRenderer(windowElements["windowCaption"]))
                {
                    Region clipRegion = renderer.GetBackgroundRegion(
                        g, elementRectangles["windowCaption"]);

                    // Get the client rectangle, but exclude the region 
                    // of the window caption.
                    int height = (int)clipRegion.GetBounds(g).Height;
                    Rectangle nonCaptionRect = new Rectangle(
                        ClientRectangle.X,
                        ClientRectangle.Y + height,
                        ClientRectangle.Width,
                        ClientRectangle.Height - height);

                    // Add the rectangle to the caption region, and  
                    // make this region the form's clipping region.
                    clipRegion.Union(nonCaptionRect);
                    this.Region = clipRegion;
                }
            }
        }

        // Set the VisualStyleRenderer to a new element.
        private bool SetRenderer(VisualStyleElement element)
        {
            if (!VisualStyleRenderer.IsElementDefined(element))
            {
                return false;
            }

            if (renderer == null)
            {
                renderer = new VisualStyleRenderer(element);
            }
            else
            {
                renderer.SetParameters(element);
            }

            return true;
        }
    }
}
Imports System.Text
Imports System.Drawing
Imports System.Drawing.Drawing2D
Imports System.Collections.Generic
Imports System.Windows.Forms
Imports System.Windows.Forms.VisualStyles

Namespace VisualStyleRendererSample

    Class Form1
        Inherits Form

        Public Sub New()
            With Me
                .Size = New Size(800, 600)
                .Location = New Point(20, 20)
                .BackColor = Color.DarkGray
            End With
            Dim Window1 As New ImitationWindow()
            Controls.Add(Window1)
        End Sub

        <STAThread()> _
        Shared Sub Main()
            Application.EnableVisualStyles()
            Application.Run(New Form1())
        End Sub
    End Class

    Public Class ImitationWindow
        Inherits Control

        Private windowElements As _
            New Dictionary(Of String, VisualStyleElement)
        Private elementRectangles As _
            New Dictionary(Of String, Rectangle)
        Private renderer As VisualStyleRenderer = Nothing
        Private closeButtonOffset As Point
        Private gripperSize As Size
        Private closeButtonSize As Size
        Private isResizing As Boolean = False
        Private isMoving As Boolean = False
        Private isClosing As Boolean = False
        Private captionHeight As Integer
        Private frameThickness As Integer
        Private statusHeight As Integer = 22
        Private originalClick As New Point()
        Private resizeOffset As New Point()

        Public Sub New()
            With Me
                .Location = New Point(50, 50)
                .Size = New Size(350, 300)
                .BackColor = Color.Azure
                .DoubleBuffered = True
                .MinimumSize = New Size(300, 200)
                .Font = SystemFonts.CaptionFont
                .Text = "Imitation Window"
            End With

            ' Create a collection of VisualStyleElement objects.
            With windowElements
                .Add("windowCaption", _
                    VisualStyleElement.Window.Caption.Active)
                .Add("windowBottom", _
                    VisualStyleElement.Window.FrameBottom.Active)
                .Add("windowLeft", _
                    VisualStyleElement.Window.FrameLeft.Active)
                .Add("windowRight", _
                    VisualStyleElement.Window.FrameRight.Active)
                .Add("windowClose", _
                    VisualStyleElement.Window.CloseButton.Normal)
                .Add("statusBar", _
                    VisualStyleElement.Status.Bar.Normal)
                .Add("statusGripper", _
                    VisualStyleElement.Status.Gripper.Normal)
            End With

            ' Get the sizes and location offsets for the window parts  
            ' as specified by the visual style, and then use this   
            ' information to calcualate the rectangles for each part.
            GetPartDetails()
            CalculateRectangles()
        End Sub

        ' Get the sizes and offsets for the window parts as specified 
        ' by the visual style.
        Private Sub GetPartDetails()
            ' Do nothing further if visual styles are not enabled.
            If Not Application.RenderWithVisualStyles Then
                Return
            End If

            Using g As Graphics = Me.CreateGraphics()
                ' Get the size and offset of the close button.
                If SetRenderer(windowElements("windowClose")) Then
                    closeButtonSize = _
                        renderer.GetPartSize(g, ThemeSizeType.True)
                    closeButtonOffset = _
                        renderer.GetPoint(PointProperty.Offset)
                End If

                ' Get the height of the window caption.
                If SetRenderer(windowElements("windowCaption")) Then
                    captionHeight = renderer.GetPartSize(g, _
                        ThemeSizeType.True).Height
                End If

                ' Get the thickness of the left, bottom, and right 
                ' window frame.
                If SetRenderer(windowElements("windowLeft")) Then
                    frameThickness = renderer.GetPartSize(g, _
                        ThemeSizeType.True).Width
                End If

                ' Get the size of the resizing gripper.
                If SetRenderer(windowElements("statusGripper")) Then
                    gripperSize = renderer.GetPartSize(g, _
                        ThemeSizeType.True)
                End If
            End Using
        End Sub

        ' Use the part metrics to determine the current size of the 
        ' rectangles for all of the window parts.
        Private Sub CalculateRectangles()

            Dim heightMinusFrame As Integer = _
                ClientRectangle.Height - frameThickness

            ' Calculate the window frame rectangles and add them
            ' to the Dictionary of rectangles.
            elementRectangles("windowCaption") = _
                New Rectangle(0, 0, ClientRectangle.Width, _
                captionHeight)
            elementRectangles("windowBottom") = _
                New Rectangle(0, heightMinusFrame, _
                ClientRectangle.Width, frameThickness)
            elementRectangles("windowLeft") = _
                New Rectangle(0, captionHeight, frameThickness, _
                heightMinusFrame - captionHeight)
            elementRectangles("windowRight") = _
                New Rectangle(ClientRectangle.Width - frameThickness, _
                captionHeight, frameThickness, _
                heightMinusFrame - captionHeight)

            ' Calculate the window button rectangle and add it
            ' to the Dictionary of rectangles.
            elementRectangles("windowClose") = _
                New Rectangle(ClientRectangle.Right + _
                closeButtonOffset.X - closeButtonSize.Width - frameThickness, closeButtonOffset.Y, _
                closeButtonSize.Width, closeButtonSize.Height)

            ' Calculate the status bar rectangles and add them
            ' to the Dictionary of rectangles.
            elementRectangles("statusBar") = _
                New Rectangle(frameThickness, _
                heightMinusFrame - statusHeight, _
                ClientRectangle.Width - 2 * frameThickness, _
                statusHeight)
            elementRectangles("statusGripper") = _
                New Rectangle(ClientRectangle.Right - _
                gripperSize.Width - frameThickness, _
                heightMinusFrame - gripperSize.Height, _
                gripperSize.Width, gripperSize.Height)
        End Sub

        Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
            MyBase.OnPaint(e)

            ' Ensure that visual styles are supported.
            If Not Application.RenderWithVisualStyles Then
                Me.Text = "Visual styles are not enabled."
                TextRenderer.DrawText(e.Graphics, Me.Text, Me.Font, _
                    Me.Location, Me.ForeColor)
                Return
            End If

            ' Set the clip region to define the curved corners of 
            ' the caption.
            SetClipRegion()

            ' Draw each part of the window.
            Dim entry As KeyValuePair(Of String, VisualStyleElement)
            For Each entry In windowElements
                If SetRenderer(entry.Value) Then
                    renderer.DrawBackground(e.Graphics, _
                        elementRectangles(entry.Key))
                End If
            Next entry

            ' Draw the caption text.
            TextRenderer.DrawText(e.Graphics, Me.Text, Me.Font, _
                elementRectangles("windowCaption"), Color.White, _
                TextFormatFlags.VerticalCenter Or _
                TextFormatFlags.HorizontalCenter)
        End Sub

        ' Initiate dragging, resizing, or closing the imitation window.
        Private Sub ImitationWindow_MouseDown(ByVal sender As Object, _
            ByVal e As MouseEventArgs) Handles Me.MouseDown

            ' The user clicked the close button.
            If elementRectangles("windowClose"). _
                Contains(e.Location) Then

                windowElements("windowClose") = _
                    VisualStyleElement.Window.CloseButton.Pressed
                isClosing = True

            ' The user clicked the status grip.
            ElseIf elementRectangles("statusGripper"). _
                Contains(e.Location) Then

                isResizing = True
                Me.Cursor = Cursors.SizeNWSE
                resizeOffset.X = Me.Right - Me.Left - e.X
                resizeOffset.Y = Me.Bottom - Me.Top - e.Y

            ' The user clicked the window caption.
            ElseIf elementRectangles("windowCaption"). _
                Contains(e.Location) Then

                isMoving = True
                originalClick.X = e.X
                originalClick.Y = e.Y
            End If
            Invalidate()
        End Sub

        ' Stop any current resizing or moving actions.
        Private Sub ImitationWindow_MouseUp(ByVal sender As Object, _
            ByVal e As MouseEventArgs) Handles Me.MouseUp

            ' Stop moving the location of the window rectangles.
            If isMoving Then
                isMoving = False

            ' Change the cursor back to the default if the 
            ' user stops resizing.
            ElseIf isResizing Then
                isResizing = False

            ' Close the application if the user clicks the 
            ' close button.
            ElseIf elementRectangles("windowClose"). _
                Contains(e.Location) And isClosing Then
                Application.Exit()
            End If
        End Sub

        ' Handle resizing or moving actions.
        Private Sub ImitationWindow_MouseMove(ByVal sender As Object, _
            ByVal e As MouseEventArgs) Handles Me.MouseMove

            ' The left mouse button is down.
            If (MouseButtons.Left And e.Button) = _
                MouseButtons.Left Then

                ' Calculate the new control size if the user is  
                ' dragging the resizing grip.
                If isResizing Then
                    Me.Width = e.X + resizeOffset.X
                    Me.Height = e.Y + resizeOffset.Y
                    CalculateRectangles()

                ' Calculate the new location of the control if   
                ' the user is dragging the window caption.
                ElseIf isMoving Then
                    Dim XChange As Integer = Me.Location.X + _
                        (e.X - originalClick.X)
                    Dim YChange As Integer = Me.Location.Y + _
                        (e.Y - originalClick.Y)
                    Me.Location = New Point(XChange, YChange)

                ' Cancel the closing action if the user clicked and  
                ' held down on the close button, and has dragged the   
                ' pointer outside the button.
                ElseIf Not elementRectangles("windowClose"). _
                    Contains(e.Location) And isClosing Then

                    isClosing = False
                    windowElements("windowClose") = _
                        VisualStyleElement.Window.CloseButton.Normal
                End If

            ' The left mouse button is not down.
            Else
                ' Paint the close button hot if the cursor is on it.
                If elementRectangles("windowClose"). _
                    Contains(e.Location) Then
                    windowElements("windowClose") = _
                        VisualStyleElement.Window.CloseButton.Hot
                Else
                    windowElements("windowClose") = _
                        VisualStyleElement.Window.CloseButton.Normal
                End If

                ' Use a resizing cursor if the cursor is on the 
                ' status grip.
                If elementRectangles("statusGripper"). _
                    Contains(e.Location) Then
                    Me.Cursor = Cursors.SizeNWSE
                Else
                    Me.Cursor = Cursors.Default
                End If
            End If
            Invalidate()
        End Sub

        ' Calculate and set the clipping region for the control  
        ' so that the corners of the title bar are rounded.
        Private Sub SetClipRegion()
            If Not Application.RenderWithVisualStyles Then
                Return
            End If

            Using g As Graphics = Me.CreateGraphics()
                ' Get the current region for the window caption.
                If SetRenderer(windowElements("windowCaption")) Then
                    Dim clipRegion As Region = _
                        renderer.GetBackgroundRegion(g, _
                        elementRectangles("windowCaption"))

                    ' Get the client rectangle, but exclude the   
                    ' region of the window caption.
                    Dim height As Integer = _
                        CInt(clipRegion.GetBounds(g).Height)
                    Dim nonCaptionRect As _
                        New Rectangle(ClientRectangle.X, _
                        ClientRectangle.Y + height, _
                        ClientRectangle.Width, _
                        ClientRectangle.Height - height)

                    ' Add the rectangle to the caption region, and  
                    ' make this region the form's clipping region.
                    clipRegion.Union(nonCaptionRect)
                    Me.Region = clipRegion
                End If
            End Using
        End Sub

        ' Set the VisualStyleRenderer to a new element.
        Private Function SetRenderer(ByVal element As _
            VisualStyleElement) As Boolean

            If Not VisualStyleRenderer.IsElementDefined(element) Then
                Return False
            End If

            If renderer Is Nothing Then
                renderer = New VisualStyleRenderer(element)
            Else
                renderer.SetParameters(element)
            End If

            Return True
        End Function

    End Class
End Namespace

注釈

System.Windows.Forms.VisualStyles 名前空間は、ビジュアル スタイルでサポートされているすべてのコントロールとユーザー インターフェイス (UI) 要素を表す VisualStyleElement オブジェクトを公開します。 特定の要素に関する情報を描画または取得するには、目的の要素に VisualStyleRenderer を設定する必要があります。 VisualStyleRenderer は、VisualStyleRenderer コンストラクター内の指定した VisualStyleElement に自動的に設定されますが、SetParameters メソッドを呼び出すことによって、既存の VisualStyleRenderer を別の要素に設定することもできます。

要素を描画するには、DrawBackground メソッドを使用します。 VisualStyleRenderer クラスには、現在のビジュアル スタイルによって要素がどのように定義されるかに関する情報を提供するメソッド (GetColorGetEnumValueなど) も含まれています。

VisualStyleRenderer コンストラクターと VisualStyleRenderer メソッドの多くは、オペレーティング システムでビジュアル スタイルが有効になっていて、ビジュアル スタイルがアプリケーション ウィンドウのクライアント領域に適用されない限り、例外をスローします。 これらの条件を確認するには、staticIsSupported プロパティを使用します。

VisualStyleRenderer クラスは、Windows プラットフォーム SDK の Windows シェル部分からビジュアル スタイル (UxTheme) API の機能をラップします。

コンストラクター

VisualStyleRenderer(String, Int32, Int32)

指定したクラス、パーツ、および状態の値を使用して、VisualStyleRenderer クラスの新しいインスタンスを初期化します。

VisualStyleRenderer(VisualStyleElement)

指定した VisualStyleElementを使用して、VisualStyleRenderer クラスの新しいインスタンスを初期化します。

プロパティ

Class

現在の visual スタイル要素のクラス名を取得します。

Handle

visual スタイル要素の現在のクラスの一意識別子を取得します。

IsSupported

オペレーティング システムがビジュアル スタイルを使用してコントロールを描画するかどうかを指定する値を取得します。

LastHResult

VisualStyleRenderer クラスによってカプセル化されたネイティブ ビジュアル スタイル (UxTheme) API メソッドによって返される最後のエラー コードを取得します。

Part

現在の visual スタイル要素の一部を取得します。

State

現在の visual スタイル要素の状態を取得します。

メソッド

DrawBackground(IDeviceContext, Rectangle)

指定した外接する四角形内に、現在の visual スタイル要素の背景イメージを描画します。

DrawBackground(IDeviceContext, Rectangle, Rectangle)

指定した外接する四角形内に現在の visual スタイル要素の背景画像を描画し、指定したクリッピング四角形にクリップします。

DrawEdge(IDeviceContext, Rectangle, Edges, EdgeStyle, EdgeEffects)

指定した外接する四角形の 1 つ以上のエッジを描画します。

DrawImage(Graphics, Rectangle, Image)

指定した境界内に指定したイメージを描画します。

DrawImage(Graphics, Rectangle, ImageList, Int32)

指定した境界内の指定した ImageList からイメージを描画します。

DrawParentBackground(IDeviceContext, Rectangle, Control)

コントロールの親の背景を指定された領域に描画します。

DrawText(IDeviceContext, Rectangle, String)

既定の書式設定を使用して、指定した境界内にテキストを描画します。

DrawText(IDeviceContext, Rectangle, String, Boolean)

無効なテキストを表示するオプションを使用して、指定した境界内にテキストを描画します。

DrawText(IDeviceContext, Rectangle, String, Boolean, TextFormatFlags)

無効なテキストを表示し、他のテキスト書式を適用するオプションを使用して、指定した外接する四角形にテキストを描画します。

Equals(Object)

指定したオブジェクトが現在のオブジェクトと等しいかどうかを判断します。

(継承元 Object)
GetBackgroundContentRectangle(IDeviceContext, Rectangle)

現在の visual スタイル要素の背景のコンテンツ領域を返します。

GetBackgroundExtent(IDeviceContext, Rectangle)

現在の visual スタイル要素の背景領域全体を返します。

GetBackgroundRegion(IDeviceContext, Rectangle)

現在の visual スタイル要素の背景の領域を返します。

GetBoolean(BooleanProperty)

現在の visual スタイル要素の指定したブール型プロパティの値を返します。

GetColor(ColorProperty)

現在の visual スタイル要素の指定した color プロパティの値を返します。

GetEnumValue(EnumProperty)

現在の visual スタイル要素の指定した列挙型プロパティの値を返します。

GetFilename(FilenameProperty)

現在の visual スタイル要素の指定したファイル名プロパティの値を返します。

GetFont(IDeviceContext, FontProperty)

現在の visual スタイル要素の指定したフォント プロパティの値を返します。

GetHashCode()

既定のハッシュ関数として機能します。

(継承元 Object)
GetInteger(IntegerProperty)

現在の visual スタイル要素の指定した整数プロパティの値を返します。

GetMargins(IDeviceContext, MarginProperty)

現在の visual スタイル要素の指定した余白プロパティの値を返します。

GetPartSize(IDeviceContext, Rectangle, ThemeSizeType)

指定した図面境界を使用して、現在の表示スタイル パーツの指定したサイズ プロパティの値を返します。

GetPartSize(IDeviceContext, ThemeSizeType)

現在の表示スタイル パーツの指定したサイズ プロパティの値を返します。

GetPoint(PointProperty)

現在の visual スタイル要素の指定したポイント プロパティの値を返します。

GetString(StringProperty)

現在の visual スタイル要素の指定した文字列プロパティの値を返します。

GetTextExtent(IDeviceContext, Rectangle, String, TextFormatFlags)

指定した最初の外接する四角形内の現在の visual スタイル要素のフォントで描画された場合の、指定した文字列のサイズと位置を返します。

GetTextExtent(IDeviceContext, String, TextFormatFlags)

現在の visual スタイル要素のフォントで描画された場合の、指定した文字列のサイズと位置を返します。

GetTextMetrics(IDeviceContext)

現在の visual スタイル要素によって指定されたフォントに関する情報を取得します。

GetType()

現在のインスタンスの Type を取得します。

(継承元 Object)
HitTestBackground(Graphics, Rectangle, Region, Point, HitTestOptions)

現在の visual スタイル要素の背景と指定した境界内にポイントが含まれているかどうかを示すヒット テスト コードを返します。

HitTestBackground(IDeviceContext, Rectangle, IntPtr, Point, HitTestOptions)

現在の visual スタイル要素の背景と指定した領域内にポイントが含まれているかどうかを示すヒット テスト コードを返します。

HitTestBackground(IDeviceContext, Rectangle, Point, HitTestOptions)

現在の visual スタイル要素の背景にポイントが含まれているかどうかを示すヒット テスト コードを返します。

IsBackgroundPartiallyTransparent()

現在の visual スタイル要素の背景に、半透明またはアルファ ブレンドの要素があるかどうかを示します。

IsElementDefined(VisualStyleElement)

指定した visual スタイル要素が現在の表示スタイルによって定義されているかどうかを判断します。

MemberwiseClone()

現在の Objectの簡易コピーを作成します。

(継承元 Object)
SetParameters(String, Int32, Int32)

この VisualStyleRenderer を、指定したクラス、パーツ、および状態の値で表される visual スタイル要素に設定します。

SetParameters(VisualStyleElement)

この VisualStyleRenderer を、指定した VisualStyleElementで表される visual スタイル要素に設定します。

ToString()

現在のオブジェクトを表す文字列を返します。

(継承元 Object)

適用対象

こちらもご覧ください