TrackBarRenderer TrackBarRenderer TrackBarRenderer TrackBarRenderer Class

정의

비주얼 스타일을 사용하여 트랙 표시줄 컨트롤을 렌더링하는 데 사용되는 메서드를 제공합니다.Provides methods used to render a track bar control with visual styles. 이 클래스는 상속될 수 없습니다.This class cannot be inherited.

public ref class TrackBarRenderer sealed
public sealed class TrackBarRenderer
type TrackBarRenderer = class
Public NotInheritable Class TrackBarRenderer
상속
TrackBarRendererTrackBarRendererTrackBarRendererTrackBarRenderer

예제

다음 코드 예제를 사용 하는 사용자 지정 컨트롤을 만드는 방법을 보여 줍니다는 TrackBarRenderer 마우스 클릭에 응답 하는 가로 트랙 표시줄을 그리는 방법입니다.The following code example demonstrates how to create a custom control that uses the TrackBarRenderer methods to draw a horizontal track bar that responds to mouse clicks.

#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 TrackBarRendererSample
{
    ref class CustomTrackBar : public Control
    {
    private:
        int numberTicks;
        Rectangle trackRectangle;
        Rectangle ticksRectangle;
        Rectangle thumbRectangle;
        int currentTickPosition;
        float tickSpace;
        bool thumbClicked;
        TrackBarThumbState thumbState;

    public:
        CustomTrackBar(int ticks, System::Drawing::Size trackBarSize)
        {
            this->Location = Point(10, 10);
            this->Size = trackBarSize;
            this->numberTicks = ticks;
            this->BackColor = Color::DarkCyan;
            this->DoubleBuffered = true;
            numberTicks = 10;
            thumbState = TrackBarThumbState::Normal;

            // Calculate the initial sizes of the bar,
            // thumb and ticks.
            SetupTrackBar();
        }

        // Calculate the sizes of the bar, thumb, and ticks rectangle.
    private:
        void SetupTrackBar()
        {
            if (!TrackBarRenderer::IsSupported)
            {
                return;
            }

            Graphics^ g = this->CreateGraphics();

            // Calculate the size of the track bar.
            trackRectangle.X = ClientRectangle.X + 2;
            trackRectangle.Y = ClientRectangle.Y + 28;
            trackRectangle.Width = ClientRectangle.Width - 4;
            trackRectangle.Height = 4;

            // Calculate the size of the rectangle in which to
            // draw the ticks.
            ticksRectangle.X = trackRectangle.X + 4;
            ticksRectangle.Y = trackRectangle.Y - 8;
            ticksRectangle.Width = trackRectangle.Width - 8;
            ticksRectangle.Height = 4;

            tickSpace = ((float)ticksRectangle.Width - 1) /
                ((float)numberTicks - 1);

            // Calculate the size of the thumb.
            thumbRectangle.Size =
                TrackBarRenderer::GetTopPointingThumbSize(g,
                TrackBarThumbState::Normal);

            thumbRectangle.X = CurrentTickXCoordinate();
            thumbRectangle.Y = trackRectangle.Y - 8;
        }

    private:
        int CurrentTickXCoordinate()
        {
            if (tickSpace == 0)
            {
                return 0;
            }
            else
            {
                return ((int)Math::Round(tickSpace) *
                    currentTickPosition);
            }
        }

        // Draw the track bar.
    protected:
        virtual void OnPaint(PaintEventArgs^ e) override
        {
            if (!TrackBarRenderer::IsSupported)
            {
                this->Parent->Text = "CustomTrackBar Disabled";
                return;
            }

            this->Parent->Text = "CustomTrackBar Enabled";
            TrackBarRenderer::DrawHorizontalTrack(e->Graphics,
                trackRectangle);
            TrackBarRenderer::DrawTopPointingThumb(e->Graphics,
                thumbRectangle, thumbState);
            TrackBarRenderer::DrawHorizontalTicks(e->Graphics,
                ticksRectangle, numberTicks, EdgeStyle::Raised);
        }

        // Determine whether the user has clicked the track bar thumb.
    protected:
        virtual void OnMouseDown(MouseEventArgs^ e) override
        {
            if (!TrackBarRenderer::IsSupported)
            {
                return;
            }
            if (this->thumbRectangle.Contains(e->Location))
            {
                thumbClicked = true;
                thumbState = TrackBarThumbState::Pressed;
            }

            this->Invalidate();
        }

        // Redraw the track bar thumb if the user has moved it.
    protected:
        virtual void OnMouseUp(MouseEventArgs^ e) override
        {
            if (!TrackBarRenderer::IsSupported)
            {
                return;
            }
            if (thumbClicked == true)
            {
                if (e->Location.X > trackRectangle.X &&
                    e->Location.X < (trackRectangle.X +
                    trackRectangle.Width - thumbRectangle.Width))
                {
                    thumbClicked = false;
                    thumbState = TrackBarThumbState::Hot;
                    this->Invalidate();
                }

                thumbClicked = false;
            }
        }

        // Track cursor movements.
    protected:
        virtual void OnMouseMove(MouseEventArgs^ e) override
        {
            if (!TrackBarRenderer::IsSupported)
            {
                return;
            }
            // The user is moving the thumb.
            if (thumbClicked == true)
            {
                // Track movements to the next tick to the right, if
                // the cursor has moved halfway to the next tick.
                if (currentTickPosition < numberTicks - 1 &&
                    e->Location.X > CurrentTickXCoordinate() +
                    (int)(tickSpace))
                {
                    currentTickPosition++;
                }

                // Track movements to the next tick to the left, if
                // cursor has moved halfway to the next tick.
                else if (currentTickPosition > 0 &&
                    e->Location.X < CurrentTickXCoordinate() -
                    (int)(tickSpace / 2))
                {
                    currentTickPosition--;
                }

                thumbRectangle.X = CurrentTickXCoordinate();
            }

            // The cursor is passing over the track.
            else
            {
                if (thumbRectangle.Contains(e->Location))
                {
                    thumbState = TrackBarThumbState::Hot;
                }
                else
                {
                    thumbState = TrackBarThumbState::Normal;
                }
            }

            Invalidate();
        }
    };

    ref class Form1 : public Form
    {
    public:
        Form1()
        {
            CustomTrackBar^ TrackBar1 = gcnew CustomTrackBar(19,
                System::Drawing::Size(300, 50));
            this->Width = 500;
            this->Controls->Add(TrackBar1);
        }
    };
}

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

namespace TrackBarRendererSample
{
    class Form1 : Form
    {
        public Form1()
        {
            CustomTrackBar TrackBar1 = new CustomTrackBar(19,
                new Size(300, 50));
            this.Width = 500;
            this.Controls.Add(TrackBar1);
        }

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

    class CustomTrackBar : Control
    {
        private int numberTicks = 10;
        private Rectangle trackRectangle = new Rectangle();
        private Rectangle ticksRectangle = new Rectangle();
        private Rectangle thumbRectangle = new Rectangle();
        private int currentTickPosition = 0;
        private float tickSpace = 0;
        private bool thumbClicked = false;
        private TrackBarThumbState thumbState =
            TrackBarThumbState.Normal;

        public CustomTrackBar(int ticks, Size trackBarSize)
        {
            this.Location = new Point(10, 10);
            this.Size = trackBarSize;
            this.numberTicks = ticks;
            this.BackColor = Color.DarkCyan;
            this.DoubleBuffered = true;

            // Calculate the initial sizes of the bar, 
            // thumb and ticks.
            SetupTrackBar();
        }

        // Calculate the sizes of the bar, thumb, and ticks rectangle.
        private void SetupTrackBar()
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            using (Graphics g = this.CreateGraphics())
            {
                // Calculate the size of the track bar.
                trackRectangle.X = ClientRectangle.X + 2;
                trackRectangle.Y = ClientRectangle.Y + 28;
                trackRectangle.Width = ClientRectangle.Width - 4;
                trackRectangle.Height = 4;

                // Calculate the size of the rectangle in which to 
                // draw the ticks.
                ticksRectangle.X = trackRectangle.X + 4;
                ticksRectangle.Y = trackRectangle.Y - 8;
                ticksRectangle.Width = trackRectangle.Width - 8;
                ticksRectangle.Height = 4;

                tickSpace = ((float)ticksRectangle.Width - 1) /
                    ((float)numberTicks - 1);

                // Calculate the size of the thumb.
                thumbRectangle.Size =
                    TrackBarRenderer.GetTopPointingThumbSize(g,
                    TrackBarThumbState.Normal);

                thumbRectangle.X = CurrentTickXCoordinate();
                thumbRectangle.Y = trackRectangle.Y - 8;
            }
        }

        private int CurrentTickXCoordinate()
        {
            if (tickSpace == 0)
            {
                return 0;
            }
            else
            {
                return ((int)Math.Round(tickSpace) *
                    currentTickPosition);
            }
        }

        // Draw the track bar.
        protected override void OnPaint(PaintEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
            {
                this.Parent.Text = "CustomTrackBar Disabled";
                return;
            }

            this.Parent.Text = "CustomTrackBar Enabled";
            TrackBarRenderer.DrawHorizontalTrack(e.Graphics,
                trackRectangle);
            TrackBarRenderer.DrawTopPointingThumb(e.Graphics,
                thumbRectangle, thumbState);
            TrackBarRenderer.DrawHorizontalTicks(e.Graphics,
                ticksRectangle, numberTicks, EdgeStyle.Raised);
        }

        // Determine whether the user has clicked the track bar thumb.
        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            if (this.thumbRectangle.Contains(e.Location))
            {
                thumbClicked = true;
                thumbState = TrackBarThumbState.Pressed;
            }

            this.Invalidate();
        }

        // Redraw the track bar thumb if the user has moved it.
        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            if (thumbClicked == true)
            {
                if (e.Location.X > trackRectangle.X &&
                    e.Location.X < (trackRectangle.X +
                    trackRectangle.Width - thumbRectangle.Width))
                {
                    thumbClicked = false;
                    thumbState = TrackBarThumbState.Hot;
                    this.Invalidate();
                }

                thumbClicked = false;
            }
        }

        // Track cursor movements.
        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (!TrackBarRenderer.IsSupported)
                return;

            // The user is moving the thumb.
            if (thumbClicked == true)
            {
                // Track movements to the next tick to the right, if 
                // the cursor has moved halfway to the next tick.
                if (currentTickPosition < numberTicks - 1 &&
                    e.Location.X > CurrentTickXCoordinate() +
                    (int)(tickSpace))
                {
                    currentTickPosition++;
                }

                // Track movements to the next tick to the left, if 
                // cursor has moved halfway to the next tick.
                else if (currentTickPosition > 0 &&
                    e.Location.X < CurrentTickXCoordinate() -
                    (int)(tickSpace / 2))
                {
                    currentTickPosition--;
                }

                thumbRectangle.X = CurrentTickXCoordinate();
            }

            // The cursor is passing over the track.
            else
            {
                thumbState = thumbRectangle.Contains(e.Location) ?
                    TrackBarThumbState.Hot : TrackBarThumbState.Normal;
            }

            Invalidate();
        }
    }
}
Imports System.Drawing
Imports System.Windows.Forms
Imports System.Windows.Forms.VisualStyles


Namespace TrackBarRendererSample

    Class Form1
        Inherits Form

        Public Sub New()
            Dim TrackBar1 As New CustomTrackBar(19, New Size(300, 50))
            Me.Width = 500
            Me.Controls.Add(TrackBar1)
        End Sub

        <STAThread()> _
        Shared Sub Main()
            ' Note that the call to EnableVisualStyles below does
            ' not affect whether TrackBarRenderer.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
    End Class

    Class CustomTrackBar
        Inherits Control
        Private numberTicks As Integer = 10
        Private trackRectangle As New Rectangle()
        Private ticksRectangle As New Rectangle()
        Private thumbRectangle As New Rectangle()
        Private currentTickPosition As Integer = 0
        Private tickSpace As Single = 0
        Private thumbClicked As Boolean = False
        Private thumbState As TrackBarThumbState = TrackBarThumbState.Normal

        Public Sub New(ByVal ticks As Integer, ByVal trackBarSize As Size)

            With Me
                .Location = New Point(10, 10)
                .Size = trackBarSize
                .numberTicks = ticks
                .BackColor = Color.DarkCyan
                .DoubleBuffered = True
            End With

            ' Calculate the initial sizes of the bar, 
            ' thumb and ticks.
            SetupTrackBar()
        End Sub

        ' Calculate the sizes of the bar, thumb, and ticks rectangle.
        Private Sub SetupTrackBar()
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            Using g As Graphics = Me.CreateGraphics()
                ' Calculate the size of the track bar.
                trackRectangle.X = ClientRectangle.X + 2
                trackRectangle.Y = ClientRectangle.Y + 28
                trackRectangle.Width = ClientRectangle.Width - 4
                trackRectangle.Height = 4

                ' Calculate the size of the rectangle in which to 
                ' draw the ticks.
                ticksRectangle.X = trackRectangle.X + 4
                ticksRectangle.Y = trackRectangle.Y - 8
                ticksRectangle.Width = trackRectangle.Width - 8
                ticksRectangle.Height = 4

                tickSpace = (CSng(ticksRectangle.Width) - 1) / _
                    (CSng(numberTicks) - 1)

                ' Calculate the size of the thumb.
                thumbRectangle.Size = _
                    TrackBarRenderer.GetTopPointingThumbSize( _
                    g, TrackBarThumbState.Normal)

                thumbRectangle.X = CurrentTickXCoordinate()
                thumbRectangle.Y = trackRectangle.Y - 8
            End Using
        End Sub

        Private Function CurrentTickXCoordinate() As Integer
            If tickSpace = 0 Then
                Return 0
            Else
                Return CInt(Math.Round(tickSpace)) * currentTickPosition
            End If
        End Function

        ' Draw the track bar.
        Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Me.Parent.Text = "CustomTrackBar Disabled"
                Return
            End If

            Me.Parent.Text = "CustomTrackBar Enabled"
            TrackBarRenderer.DrawHorizontalTrack(e.Graphics, _
                trackRectangle)
            TrackBarRenderer.DrawTopPointingThumb(e.Graphics, _
                thumbRectangle, thumbState)
            TrackBarRenderer.DrawHorizontalTicks(e.Graphics, _
                ticksRectangle, numberTicks, EdgeStyle.Raised)
        End Sub

        ' Determine whether the user has clicked the track bar thumb.
        Protected Overrides Sub OnMouseDown(ByVal e As MouseEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            If Me.thumbRectangle.Contains(e.Location) Then
                thumbClicked = True
                thumbState = TrackBarThumbState.Pressed
            End If

            Me.Invalidate()
        End Sub

        ' Redraw the track bar thumb if the user has moved it.
        Protected Overrides Sub OnMouseUp(ByVal e As MouseEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            If thumbClicked = True Then
                If e.Location.X > trackRectangle.X And _
                    e.Location.X < trackRectangle.X + _
                    trackRectangle.Width - thumbRectangle.Width Then

                    thumbClicked = False
                    thumbState = TrackBarThumbState.Hot
                    Me.Invalidate()
                End If
                thumbClicked = False
            End If
        End Sub

        ' Track cursor movements.
        Protected Overrides Sub OnMouseMove(ByVal e As MouseEventArgs)
            If Not TrackBarRenderer.IsSupported Then
                Return
            End If
            ' The user is moving the thumb.
            If thumbClicked = True Then

                ' Track movements to the next tick to the right, if the
                ' cursor has moved halfway to the next tick.
                If currentTickPosition < numberTicks - 1 And _
                    e.Location.X > CurrentTickXCoordinate() + _
                    CInt(tickSpace) Then
                    currentTickPosition += 1

                ' Track movements to the next tick to the left, if 
                ' the cursor has moved halfway to the next tick.
                Else
                    If currentTickPosition > 0 And _
                        e.Location.X < CurrentTickXCoordinate() - _
                        CInt(tickSpace / 2) Then
                        currentTickPosition -= 1
                    End If
                End If
                thumbRectangle.X = CurrentTickXCoordinate()

            ' The cursor is passing over the track.
            Else
                If thumbRectangle.Contains(e.Location) Then
                    thumbState = TrackBarThumbState.Hot
                Else
                    thumbState = TrackBarThumbState.Normal
                End If
            End If

            Invalidate()
        End Sub

    End Class
End Namespace

설명

합니다 TrackBarRenderer 클래스의 집합을 제공 static 운영 체제의 현재 비주얼 스타일을 사용 하 여 트랙 표시줄 컨트롤의 각 부분 렌더링에 사용할 수 있는 방법입니다.The TrackBarRenderer class provides a set of static methods that can be used to render each part of a track bar control with the current visual style of the operating system. 컨트롤 렌더링이란 컨트롤의 사용자 인터페이스를 그리는 것을 말합니다.Rendering a control refers to drawing the user interface of a control. 현재 비주얼 스타일의 모양이 있어야 하는 사용자 지정 컨트롤을 그리는 경우에 유용 합니다.This is useful if you are drawing a custom control that should have the appearance of the current visual style.

운영 체제에서 비주얼 스타일을 사용 하 고 애플리케이션 창의 클라이언트 영역에 비주얼 스타일을 적용 하는 경우이 클래스의 메서드는 현재 비주얼 스타일을 사용 하 여 트랙 표시줄을 그립니다.If visual styles are enabled in the operating system and visual styles are applied to the client area of application windows, the methods in this class will draw the track bar with the current visual style. 이 클래스의 메서드를 발생 시킵니다이 고, 그렇지는 InvalidOperationException합니다.Otherwise, the methods in this class will throw an InvalidOperationException. 이 클래스의 멤버를 사용할 수 있는지 여부를 확인 하려면 값을 확인할 수 있습니다는 IsSupported 속성입니다.To determine whether the members of this class can be used, you can check the value of the IsSupported property.

이 클래스의 함수를 래핑하는 System.Windows.Forms.VisualStyles.VisualStyleRenderer 에서 노출 한 요소 중 하나에 설정 된는 System.Windows.Forms.VisualStyles.VisualStyleElement.TrackBar 클래스입니다.This class wraps the functionality of a System.Windows.Forms.VisualStyles.VisualStyleRenderer that is set to one of the elements exposed by the System.Windows.Forms.VisualStyles.VisualStyleElement.TrackBar class. 자세한 내용은 비주얼 스타일을 사용 하 여 컨트롤 렌더링합니다.For more information, see Rendering Controls with Visual Styles.

속성

IsSupported IsSupported IsSupported IsSupported

비주얼 스타일을 사용하여 트랙 표시줄을 그리는 데 TrackBarRenderer 클래스를 사용할 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the TrackBarRenderer class can be used to draw a track bar with visual styles.

메서드

DrawBottomPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawBottomPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawBottomPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawBottomPointingThumb(Graphics, Rectangle, TrackBarThumbState)

비주얼 스타일을 사용하여 아래쪽 방향 트랙 표시줄 슬라이더(엄지 단추)를 그립니다.Draws a downward-pointing track bar slider (also known as the thumb) with visual styles.

DrawHorizontalThumb(Graphics, Rectangle, TrackBarThumbState) DrawHorizontalThumb(Graphics, Rectangle, TrackBarThumbState) DrawHorizontalThumb(Graphics, Rectangle, TrackBarThumbState) DrawHorizontalThumb(Graphics, Rectangle, TrackBarThumbState)

비주얼 스타일을 사용하여 가로 트랙 표시줄 슬라이더(엄지 단추)를 그립니다.Draws a horizontal track bar slider (also known as the thumb) with visual styles.

DrawHorizontalTicks(Graphics, Rectangle, Int32, EdgeStyle) DrawHorizontalTicks(Graphics, Rectangle, Int32, EdgeStyle) DrawHorizontalTicks(Graphics, Rectangle, Int32, EdgeStyle) DrawHorizontalTicks(Graphics, Rectangle, Int32, EdgeStyle)

비주얼 스타일을 사용하여 지정된 수의 가로 트랙 표시줄 눈금을 그립니다.Draws the specified number of horizontal track bar ticks with visual styles.

DrawHorizontalTrack(Graphics, Rectangle) DrawHorizontalTrack(Graphics, Rectangle) DrawHorizontalTrack(Graphics, Rectangle) DrawHorizontalTrack(Graphics, Rectangle)

비주얼 스타일을 사용하여 가로 트랙 표시줄의 트랙을 그립니다.Draws the track for a horizontal track bar with visual styles.

DrawLeftPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawLeftPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawLeftPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawLeftPointingThumb(Graphics, Rectangle, TrackBarThumbState)

비주얼 스타일을 사용하여 왼쪽 방향 트랙 표시줄 슬라이더(엄지 단추)를 그립니다.Draws a left-pointing track bar slider (also known as the thumb) with visual styles.

DrawRightPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawRightPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawRightPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawRightPointingThumb(Graphics, Rectangle, TrackBarThumbState)

비주얼 스타일을 사용하여 오른쪽 방향 트랙 표시줄 슬라이더(엄지 단추)를 그립니다.Draws a right-pointing track bar slider (also known as the thumb) with visual styles.

DrawTopPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawTopPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawTopPointingThumb(Graphics, Rectangle, TrackBarThumbState) DrawTopPointingThumb(Graphics, Rectangle, TrackBarThumbState)

비주얼 스타일을 사용하여 위쪽 방향 트랙 표시줄 슬라이더(엄지 단추)를 그립니다.Draws an upward-pointing track bar slider (also known as the thumb) with visual styles.

DrawVerticalThumb(Graphics, Rectangle, TrackBarThumbState) DrawVerticalThumb(Graphics, Rectangle, TrackBarThumbState) DrawVerticalThumb(Graphics, Rectangle, TrackBarThumbState) DrawVerticalThumb(Graphics, Rectangle, TrackBarThumbState)

비주얼 스타일을 사용하여 세로 트랙 표시줄 슬라이더(엄지 단추)를 그립니다.Draws a vertical track bar slider (also known as the thumb) with visual styles.

DrawVerticalTicks(Graphics, Rectangle, Int32, EdgeStyle) DrawVerticalTicks(Graphics, Rectangle, Int32, EdgeStyle) DrawVerticalTicks(Graphics, Rectangle, Int32, EdgeStyle) DrawVerticalTicks(Graphics, Rectangle, Int32, EdgeStyle)

비주얼 스타일을 사용하여 지정된 수의 세로 트랙 표시줄 눈금을 그립니다.Draws the specified number of vertical track bar ticks with visual styles.

DrawVerticalTrack(Graphics, Rectangle) DrawVerticalTrack(Graphics, Rectangle) DrawVerticalTrack(Graphics, Rectangle) DrawVerticalTrack(Graphics, Rectangle)

비주얼 스타일을 사용하여 세로 트랙 표시줄의 트랙을 그립니다.Draws the track for a vertical track bar with visual styles.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBottomPointingThumbSize(Graphics, TrackBarThumbState) GetBottomPointingThumbSize(Graphics, TrackBarThumbState) GetBottomPointingThumbSize(Graphics, TrackBarThumbState) GetBottomPointingThumbSize(Graphics, TrackBarThumbState)

아래쪽을 가리키는 트랙 표시줄 슬라이더(엄지 단추)의 크기를 픽셀 단위로 반환합니다.Returns the size, in pixels, of the track bar slider (also known as the thumb) that points down.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(Inherited from Object)
GetLeftPointingThumbSize(Graphics, TrackBarThumbState) GetLeftPointingThumbSize(Graphics, TrackBarThumbState) GetLeftPointingThumbSize(Graphics, TrackBarThumbState) GetLeftPointingThumbSize(Graphics, TrackBarThumbState)

왼쪽을 가리키는 트랙 표시줄 슬라이더(엄지 단추)의 크기를 픽셀 단위로 반환합니다.Returns the size, in pixels, of the track bar slider (also known as the thumb) that points to the left.

GetRightPointingThumbSize(Graphics, TrackBarThumbState) GetRightPointingThumbSize(Graphics, TrackBarThumbState) GetRightPointingThumbSize(Graphics, TrackBarThumbState) GetRightPointingThumbSize(Graphics, TrackBarThumbState)

오른쪽을 가리키는 트랙 표시줄 슬라이더(엄지 단추)의 크기를 픽셀 단위로 반환합니다.Returns the size, in pixels, of the track bar slider (also known as the thumb) that points to the right.

GetTopPointingThumbSize(Graphics, TrackBarThumbState) GetTopPointingThumbSize(Graphics, TrackBarThumbState) GetTopPointingThumbSize(Graphics, TrackBarThumbState) GetTopPointingThumbSize(Graphics, TrackBarThumbState)

위쪽을 가리키는 트랙 표시줄 슬라이더(엄지 단추)의 크기를 픽셀 단위로 반환합니다.Returns the size, in pixels, of the track bar slider (also known as the thumb) that points up.

GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(Inherited from Object)

적용 대상

추가 정보