Export (0) Print
Expand All

UITypeEditor Class

Provides a base class that can be used to design value editors that can provide a user interface (UI) for representing and editing the values of objects of the supported data types.

Namespace: System.Drawing.Design
Assembly: System.Drawing (in system.drawing.dll)

public class UITypeEditor
public class UITypeEditor
public class UITypeEditor
Not applicable.

The UITypeEditor class provides a base class that you can derive from and extend to implement a custom type editor for the design-time environment. Typically, your custom type editor interacts with the PropertyGrid control.

Custom type editors are useful in situations where a text-box value editor is insufficient to effectively select the values of certain types.

To implement a custom design-time UI type editor, you must perform the following steps:

  • Define a class that derives from UITypeEditor.

  • Override the EditValue method to handle the user interface, user input processing, and value assignment.

  • Override the GetEditStyle method to inform the Properties window of the type of editor style that the editor will use.

You can add additional support for painting a value's representation in the Properties window by performing the following steps:

  • Override the GetPaintValueSupported method to indicate that the editor supports displaying the value's representation.

  • Override the PaintValue method to implement the display of the value's representation.

  • Override the UITypeEditor constructor method if the editor should have initialization behavior.

NoteNote:

The UITypeEditor class does not support right-to-left (RTL) layouts.

For more information about enhancing design-time support, see Extending Design-Time Support. For more information on implementing a UITypeEditor, see User Interface Type Editors Overview.

The following code example demonstrates that a UITypeEditor can be associated with an integer, double, or float property using an EditorAttribute to provide an angle selection interface from the Properties window in design mode. This example uses the IWindowsFormsEditorService interface to display a drop-down control in the Properties window in design mode. Compile the code and add the assembly to the Toolbox using the Customize Toolbox command on the Tools menu of Visual Studio. Create an instance of the AngleTestControl and click the drop-down button next to the Angle property in the Properties window to configure the property using the editor.

using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;

namespace AngleEditor
{
    // This UITypeEditor can be associated with Int32, Double and Single
    // properties to provide a design-mode angle selection interface.
    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")] 
    public class AngleEditor : System.Drawing.Design.UITypeEditor
    {        
        public AngleEditor()
        {
        }

        // Indicates whether the UITypeEditor provides a form-based (modal) dialog, 
        // drop down dialog, or no UI outside of the properties window.
        public override System.Drawing.Design.UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.DropDown;
        }

        // Displays the UI for value selection.
        public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
        {            
            // Return the value if the value is not of type Int32, Double and Single.
            if( value.GetType() != typeof(double) && value.GetType() != typeof(float) && value.GetType() != typeof(int) )
                return value;

            // Uses the IWindowsFormsEditorService to display a 
            // drop-down UI in the Properties window.
            IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
            if( edSvc != null )
            {
                // Display an angle selection control and retrieve the value.
                AngleControl angleControl = new AngleControl((double)value);
                edSvc.DropDownControl( angleControl );

                // Return the value in the appropraite data format.
                if( value.GetType() == typeof(double) )
                    return angleControl.angle;
                else if( value.GetType() == typeof(float) )
                    return (float)angleControl.angle;
                else if( value.GetType() == typeof(int) )
                    return (int)angleControl.angle;
            }
            return value;
        }

        // Draws a representation of the property's value.
        public override void PaintValue(System.Drawing.Design.PaintValueEventArgs e)
        {
            int normalX = (e.Bounds.Width/2);
            int normalY = (e.Bounds.Height/2);
            
            // Fill background and ellipse and center point.
            e.Graphics.FillRectangle(new SolidBrush(Color.DarkBlue), e.Bounds.X, e.Bounds.Y, e.Bounds.Width, e.Bounds.Height);            
            e.Graphics.FillEllipse(new SolidBrush(Color.White), e.Bounds.X+1, e.Bounds.Y+1, e.Bounds.Width-3, e.Bounds.Height-3);
            e.Graphics.FillEllipse(new SolidBrush(Color.SlateGray), normalX+e.Bounds.X-1, normalY+e.Bounds.Y-1, 3, 3);
            
            // Draw line along the current angle.
            double radians = ((double)e.Value*Math.PI) / (double)180;
            e.Graphics.DrawLine( new Pen(new SolidBrush(Color.Red), 1), normalX+e.Bounds.X, normalY+e.Bounds.Y, 
                e.Bounds.X+ ( normalX + (int)( (double)normalX * Math.Cos( radians ) ) ),
                e.Bounds.Y+ ( normalY + (int)( (double)normalY * Math.Sin( radians ) ) ) );
        }
        
        // Indicates whether the UITypeEditor supports painting a 
        // representation of a property's value.
        public override bool GetPaintValueSupported(System.ComponentModel.ITypeDescriptorContext context)
        {
            return true;
        }
    }

    // Provides a user interface for adjusting an angle value.
    internal class AngleControl : System.Windows.Forms.UserControl
    {
        // Stores the angle.
        public double angle;
        // Stores the rotation offset.
        private int rotation = 0;
        // Control state tracking variables.
        private int dbx = -10;
        private int dby = -10;
        private int overButton = -1;
        
        public AngleControl(double initial_angle)
        {
            this.angle = initial_angle;                 
            this.SetStyle( ControlStyles.AllPaintingInWmPaint, true );
        }

        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            // Set angle origin point at center of control.
            int originX = (this.Width/2);
            int originY = (this.Height/2);            
            
            // Fill background and ellipse and center point.
            e.Graphics.FillRectangle(new SolidBrush(Color.DarkBlue), 0, 0, this.Width, this.Height);
            e.Graphics.FillEllipse(new SolidBrush(Color.White), 1, 1, this.Width-3, this.Height-3);            
            e.Graphics.FillEllipse(new SolidBrush(Color.SlateGray), originX-1, originY-1, 3, 3);
            
            // Draw angle markers.
            int startangle = (270-rotation)%360;
            e.Graphics.DrawString(startangle.ToString(), new Font("Arial", 8), new SolidBrush(Color.DarkGray), (this.Width/2)-10, 10);
            startangle = (startangle+90)%360;
            e.Graphics.DrawString(startangle.ToString(), new Font("Arial", 8), new SolidBrush(Color.DarkGray), this.Width-18, (this.Height/2)-6);
            startangle = (startangle+90)%360;
            e.Graphics.DrawString(startangle.ToString(), new Font("Arial", 8), new SolidBrush(Color.DarkGray), (this.Width/2)-6, this.Height-18);
            startangle = (startangle+90)%360;
            e.Graphics.DrawString(startangle.ToString(), new Font("Arial", 8), new SolidBrush(Color.DarkGray), 10, (this.Height/2)-6);

            // Draw line along the current angle.         
            double radians = ((((angle+rotation)+360)%360)*Math.PI) / (double)180;
            e.Graphics.DrawLine( new Pen(new SolidBrush(Color.Red), 1), originX, originY, 
                originX + (int)( (double)originX * (double)Math.Cos( radians )   ),
                originY + (int)( (double)originY * (double)Math.Sin( radians ) ) );
            
            // Output angle information.
            e.Graphics.FillRectangle(new SolidBrush(Color.Gray), this.Width-84, 3, 82, 13);
            e.Graphics.DrawString("Angle: "+angle.ToString("F4"), new Font("Arial", 8), new SolidBrush(Color.Yellow), this.Width-84, 2);
            // Draw square at mouse position of last angle adjustment.
            e.Graphics.DrawRectangle(new Pen(new SolidBrush(Color.Black), 1), dbx-2, dby-2, 4, 4);
            // Draw rotation adjustment buttons.
            if( overButton == 1 )
            {
                e.Graphics.FillRectangle(new SolidBrush(Color.Green), this.Width-28, this.Height-14, 12, 12);
                e.Graphics.FillRectangle(new SolidBrush(Color.Gray), 2, this.Height-13, 110, 12);    
                e.Graphics.DrawString("Rotate 90 degrees left", new Font("Arial", 8), new SolidBrush(Color.White), 2, this.Height-14);
            }
            else            
                e.Graphics.FillRectangle(new SolidBrush(Color.DarkGreen), this.Width-28, this.Height-14, 12, 12);
            if( overButton == 2 )
            {
                e.Graphics.FillRectangle(new SolidBrush(Color.Green), this.Width-14, this.Height-14, 12, 12);
                e.Graphics.FillRectangle(new SolidBrush(Color.Gray), 2, this.Height-13, 116, 12);    
                e.Graphics.DrawString("Rotate 90 degrees right", new Font("Arial", 8), new SolidBrush(Color.White), 2, this.Height-14);
            }
            else
                e.Graphics.FillRectangle(new SolidBrush(Color.DarkGreen), this.Width-14, this.Height-14, 12, 12);
            e.Graphics.DrawEllipse(new Pen(new SolidBrush(Color.White), 1), this.Width-11, this.Height-11, 6, 6);
            e.Graphics.DrawEllipse(new Pen(new SolidBrush(Color.White), 1), this.Width-25, this.Height-11, 6, 6);
            if( overButton == 1 )
                e.Graphics.FillRectangle(new SolidBrush(Color.Green), this.Width-25, this.Height-6, 4, 4);
            else
                e.Graphics.FillRectangle(new SolidBrush(Color.DarkGreen), this.Width-25, this.Height-6, 4, 4);
            if( overButton == 2 )
                e.Graphics.FillRectangle(new SolidBrush(Color.Green), this.Width-8, this.Height-6, 4, 4);
            else
                e.Graphics.FillRectangle(new SolidBrush(Color.DarkGreen), this.Width-8, this.Height-6, 4, 4);
            e.Graphics.FillPolygon(new SolidBrush(Color.White), new Point[] { new Point(this.Width-7, this.Height-8), new Point(this.Width-3, this.Height-8), new Point(this.Width-5, this.Height-4) });
            e.Graphics.FillPolygon(new SolidBrush(Color.White), new Point[] { new Point(this.Width-26, this.Height-8), new Point(this.Width-21, this.Height-8), new Point(this.Width-25, this.Height-4) });            
        }

        protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
        {            
            // Handle rotation adjustment button clicks.
            if( e.X >= this.Width-28 && e.X <= this.Width-2 && e.Y >= this.Height-14 && e.Y <= this.Height-2 )
            {
                if( e.X <= this.Width-16 )
                    rotation -= 90;
                else if( e.X >= this.Width-14 )
                    rotation += 90;
                if( rotation < 0 )
                    rotation += 360;
                rotation = rotation%360;
                dbx=-10;
                dby=-10;
            }
            else
                UpdateAngle(e.X, e.Y);                
            this.Refresh();        
        }

        protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
        {
            if( e.Button == MouseButtons.Left )
            {
                UpdateAngle(e.X, e.Y);                                        
                overButton = -1;                
            }
            else if( e.X >= this.Width-28 && e.X <= this.Width-16 && e.Y >= this.Height-14 && e.Y <= this.Height-2 )
                overButton = 1;
            else if( e.X >= this.Width-14 && e.X <= this.Width-2 && e.Y >= this.Height-14 && e.Y <= this.Height-2 )
                overButton = 2;
            else
                overButton = -1;
            this.Refresh();
        }

        private void UpdateAngle(int mx, int my)
        {
            // Store mouse coordinates.
            dbx = mx;
            dby = my;

            // Translate y coordinate input to GetAngle function to correct for ellipsoid distortion.
            double widthToHeightRatio =  (double)this.Width/(double)this.Height;                        
            int tmy;
            if( my == 0 )
                tmy = my;
            else if( my < this.Height/2 )
                tmy = (this.Height/2)-(int)(((this.Height/2)-my)*widthToHeightRatio);                
            else
                tmy = (this.Height/2)+(int)((double)(my-(this.Height/2))*widthToHeightRatio);
            
            // Retrieve updated angle based on rise over run.
            angle = (GetAngle(this.Width/2, this.Height/2, mx, tmy)-rotation)%360;                                    
        }

        private double GetAngle(int x1, int y1, int x2, int y2)
        {  
            double degrees;
           
            // Avoid divide by zero run values.
            if( x2-x1 == 0 )
            {
                if( y2 > y1 )
                    degrees = 90;
                else
                    degrees = 270;
            }
            else
            {
                // Calculate angle from offset.
                double riseoverrun = (double)(y2-y1)/(double)(x2-x1);
                double radians = Math.Atan( riseoverrun );
                degrees = radians * ((double)180/Math.PI);
                
                // Handle quadrant specific transformations.       
                if( (x2-x1) < 0 || (y2-y1) < 0 )
                    degrees += 180;
                if( (x2-x1) > 0 && (y2-y1) < 0 )
                    degrees -= 180;
                if( degrees < 0 )
                    degrees += 360;
            }
            return degrees;
        }
    }

    public class AngleEditorTestControl : System.Windows.Forms.UserControl
    {
        private double int_angle;

        [BrowsableAttribute(true)]
        [EditorAttribute(typeof(AngleEditor), typeof(System.Drawing.Design.UITypeEditor))]        
        public double Angle
        {
            get
            { return int_angle; }
            set
            { int_angle = value; }
        }        

        public AngleEditorTestControl()
        {
            int_angle = 90;
            this.Size = new Size(190, 42);
            this.BackColor = Color.Beige;			
        }

        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            if( this.DesignMode )
            {
                e.Graphics.DrawString("Use the Properties Window to access", new Font("Arial", 8), new SolidBrush(Color.Black), 3,2);
                e.Graphics.DrawString("the AngleEditor UITypeEditor by", new Font("Arial", 8), new SolidBrush(Color.Black), 3,14);
                e.Graphics.DrawString("configuring the \"Angle\" property.", new Font("Arial", 8), new SolidBrush(Color.Black), 3,26);
            }
            else
                e.Graphics.DrawString("This example requires design mode.", new Font("Arial", 8), new SolidBrush(Color.Black), 3,2);
        }
    }
}


package AngleEditor; 

import System.*;
import System.ComponentModel.*;
import System.Drawing.*;
import System.Drawing.Design.*;
import System.Windows.Forms.*;
import System.Windows.Forms.Design.*;
import System.Security.Permissions.*;

// This UITypeEditor can be associated with Int32, Double and Single
// properties to provide a design-mode angle selection interface.
/** @attribute PermissionSet(SecurityAction.Demand, Name = "FullTrust")
 */
public class AngleEditor extends System.Drawing.Design.UITypeEditor
{
    public AngleEditor()
    {
    } //AngleEditor

    // Indicates whether the UITypeEditor provides a form-based (modal) 
    //  dialog, drop down dialog, or no UI outside of the properties window.
    
    public System.Drawing.Design.UITypeEditorEditStyle GetEditStyle(
        System.ComponentModel.ITypeDescriptorContext context)
    {
        return UITypeEditorEditStyle.DropDown;
    } //GetEditStyle

    // Displays the UI for value selection.
    public Object EditValue(System.ComponentModel.ITypeDescriptorContext 
        context, System.IServiceProvider provider, Object value)
    {
        // Return the value if the value is not of type Int32, Double 
        // and Single.
        if (!value.GetType().Equals(double.class.ToType()) 
            && !value.GetType().Equals(float.class.ToType()) 
            && !value.GetType().Equals(int.class.ToType())) {
            
            return value;
        }

        // Uses the IWindowsFormsEditorService to display a 
        // drop-down UI in the Properties window.
        IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)
            provider.GetService(IWindowsFormsEditorService.class.ToType());
        if (edSvc != null) {
            // Display an angle selection control and retrieve the value.
            AngleControl angleControl = 
                new AngleControl(Convert.ToDouble(value));
            edSvc.DropDownControl(angleControl);

            // Return the value in the appropraite data format.
            if (value.GetType().Equals(double.class.ToType())) {
                return (System.Double)(angleControl.angle);
            }
            else {
                if (value.GetType().Equals(float.class.ToType())) {
                    return (System.Single)(angleControl.angle);
                }
                else {
                    if (value.GetType().Equals(int.class.ToType())) {
                        return (Int32)(angleControl.angle);
                    }
                }
            }
        }
        return value;
    } //EditValue

    // Draws a representation of the property's value.
    public void PaintValue(System.Drawing.Design.PaintValueEventArgs e)
    {
        int normalX = e.get_Bounds().get_Width() / 2;
        int normalY = e.get_Bounds().get_Height() / 2;

        // Fill background and ellipse and center point.
        e.get_Graphics().FillRectangle(new SolidBrush(Color.get_DarkBlue()), 
            e.get_Bounds().get_X(), e.get_Bounds().get_Y(),
            e.get_Bounds().get_Width(), e.get_Bounds().get_Height());
        e.get_Graphics().FillEllipse(new SolidBrush(Color.get_White()), 
            e.get_Bounds().get_X() + 1, e.get_Bounds().get_Y() + 1, 
            e.get_Bounds().get_Width() - 3, e.get_Bounds().get_Height() - 3);
        e.get_Graphics().FillEllipse(new SolidBrush(Color.get_SlateGray()), 
            normalX + e.get_Bounds().get_X() - 1, 
            normalY + e.get_Bounds().get_Y() - 1, 3, 3);

        // Draw line along the current angle.
        double radians = (double)(System.Double)(e.get_Value()) 
            * System.Math.PI / (double)(180);
        e.get_Graphics().DrawLine(new Pen(new SolidBrush(Color.get_Red()), 1),
            normalX + e.get_Bounds().get_X(), 
            normalY + e.get_Bounds().get_Y(), 
            e.get_Bounds().get_X() 
            + (normalX + (int)((double)(normalX) * System.Math.Cos(radians))), 
            e.get_Bounds().get_Y() 
            + (normalY + (int)((double)(normalY) * System.Math.Sin(radians))));
    } //PaintValue

    // Indicates whether the UITypeEditor supports painting a 
    // representation of a property's value.
    public boolean GetPaintValueSupported(
        System.ComponentModel.ITypeDescriptorContext context)
    {
        return true;
    } //GetPaintValueSupported
} //AngleEditor
   
// Provides a user interface for adjusting an angle value.
class AngleControl extends System.Windows.Forms.UserControl
{
    // Stores the angle.
    public double angle;

    // Stores the rotation offset.
    private int rotation = 0;

    // Control state tracking variables.
    private int dbX = -10;
    private int dbY = -10;
    private int overButton = -1;

    public AngleControl(double initialAngle)
    {
        this.angle = initialAngle;
        this.SetStyle(ControlStyles.OptimizedDoubleBuffer 
            | ControlStyles.AllPaintingInWmPaint, true);
    } //AngleControl

    protected void OnPaint(System.Windows.Forms.PaintEventArgs e)
    {
        // Set angle origin point at center of control.
        int originX = this.get_Width() / 2;
        int originY = this.get_Height() / 2;

        // Fill background and ellipse and center point.
        e.get_Graphics().FillRectangle(new SolidBrush(Color.get_DarkBlue()), 
            0, 0, this.get_Width(), this.get_Height());
        e.get_Graphics().FillEllipse(new SolidBrush(Color.get_White()), 1, 1, 
            this.get_Width() - 3, this.get_Height() - 3);
        e.get_Graphics().FillEllipse(new SolidBrush(Color.get_SlateGray()), 
            originX - 1, originY - 1, 3, 3);

        // Draw angle markers.
        int startAngle = (270 - rotation) % 360;
        e.get_Graphics().DrawString(System.Convert.ToString(startAngle), 
            new Font("Arial", 8), new SolidBrush(Color.get_DarkGray()), 
            this.get_Width() / 2 - 10, 10);
        startAngle = (startAngle + 90) % 360;
        e.get_Graphics().DrawString(System.Convert.ToString(startAngle), 
            new Font("Arial", 8), new SolidBrush(Color.get_DarkGray()), 
            this.get_Width() - 18, this.get_Height() / 2 - 6);
        startAngle = (startAngle + 90) % 360;
        e.get_Graphics().DrawString(System.Convert.ToString(startAngle), 
            new Font("Arial", 8), new SolidBrush(Color.get_DarkGray()), 
            this.get_Width() / 2 - 6, this.get_Height() - 18);
        startAngle = (startAngle + 90) % 360;
        e.get_Graphics().DrawString(System.Convert.ToString(startAngle), 
            new Font("Arial", 8), new SolidBrush(Color.get_DarkGray()), 10, 
            this.get_Height() / 2 - 6);

        // Draw line along the current angle.         
        double radians = ((angle + rotation + 360) % 360) * System.Math.PI 
            / (double)180;
        e.get_Graphics().DrawLine(new Pen(new SolidBrush(Color.get_Red()), 1), 
            originX, originY, 
            originX + (int)((double)(originX) * (double)
            (System.Math.Cos(radians))), originY + (int)((double)(originY) 
            * (double)(System.Math.Sin(radians))));

        // Output angle information.
        e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Gray()), 
            this.get_Width() - 84, 3, 82, 13);
        e.get_Graphics().DrawString("Angle: " + System.Convert.ToString(angle), 
            new Font("Arial", 8), new SolidBrush(Color.get_Yellow()), 
            this.get_Width() - 84, 2);

        // Draw square at mouse position of last angle adjustment.
        e.get_Graphics().DrawRectangle(new Pen(new SolidBrush(
            Color.get_Black()), 1), dbX - 2, dbY - 2, 4, 4);

        // Draw rotation adjustment buttons.
        if (overButton == 1) {
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Green()), 
                this.get_Width() - 28, this.get_Height() - 14, 12, 12);
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Gray()), 2, 
                this.get_Height() - 13, 110, 12);
            e.get_Graphics().DrawString("Rotate 90 degrees left", 
                new Font("Arial", 8), new SolidBrush(Color.get_White()), 2, 
                this.get_Height() - 14);
        }
        else {
            e.get_Graphics().FillRectangle(
                new SolidBrush(Color.get_DarkGreen()), 
                this.get_Width() - 28, this.get_Height() - 14, 12, 12);
        }
        if (overButton == 2) {
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Green()), 
                this.get_Width() - 14, this.get_Height() - 14, 12, 12);
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Gray()), 2, 
                this.get_Height() - 13, 116, 12);
            e.get_Graphics().DrawString("Rotate 90 degrees right", 
                new Font("Arial", 8), new SolidBrush(Color.get_White()), 2, 
                this.get_Height() - 14);
        }
        else {
            e.get_Graphics().FillRectangle(
                new SolidBrush(Color.get_DarkGreen()), 
                this.get_Width() - 14, this.get_Height() - 14, 12, 12);
        }

        e.get_Graphics().DrawEllipse(new Pen(new SolidBrush(Color.get_White()),
            1), this.get_Width() - 11, this.get_Height() - 11, 6, 6);
        e.get_Graphics().DrawEllipse(new Pen(new SolidBrush(Color.get_White()),
            1), this.get_Width() - 25, this.get_Height() - 11, 6, 6);
        
        if (overButton == 1) {
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Green()), 
                this.get_Width() - 25, this.get_Height() - 6, 4, 4);
        }
        else {
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_DarkGreen()), 
                this.get_Width() - 25, this.get_Height() - 6, 4, 4);
        }
        if (overButton == 2) {
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Green()), 
                this.get_Width() - 8, this.get_Height() - 6, 4, 4);
        }
        else {
            e.get_Graphics().FillRectangle(new SolidBrush(Color.get_DarkGreen()), 
                this.get_Width() - 8, this.get_Height() - 6, 4, 4);
        }

        e.get_Graphics().FillPolygon(new SolidBrush(Color.get_White()), 
            new Point[] { 
            new Point(this.get_Width() - 7, this.get_Height() - 8), 
            new Point(this.get_Width() - 3, this.get_Height() - 8), 
            new Point(this.get_Width() - 5, this.get_Height() - 4) });
        e.get_Graphics().FillPolygon(new SolidBrush(Color.get_White()), 
            new Point[] { 
            new Point(this.get_Width() - 26, this.get_Height() - 8), 
            new Point(this.get_Width() - 21, this.get_Height() - 8), 
            new Point(this.get_Width() - 25, this.get_Height() - 4) });
    } //OnPaint

    protected void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
    {
        // Handle rotation adjustment button clicks.
        if (e.get_X() >= this.get_Width() - 28 
            && e.get_X() <= this.get_Width() - 2 
            && e.get_Y() >= this.get_Height() - 14 
            && e.get_Y() <= this.get_Height() - 2) {
            
            if (e.get_X() <= this.get_Width() - 16) {
                rotation -= 90;
            }
            else {
                if (e.get_X() >= this.get_Width() - 14) {
                    rotation += 90;
                }
            }
            if (rotation < 0) {
                rotation += 360;
            }
            rotation = rotation % 360;
            dbX = -10;
            dbY = -10;
        }
        else {
            UpdateAngle(e.get_X(), e.get_Y());
        }
        this.Refresh();
    } //OnMouseDown

    protected void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
    {
        if (e.get_Button().Equals(MouseButtons.Left)) {
            UpdateAngle(e.get_X(), e.get_Y());
            overButton = -1;
        }
        else {
            if (e.get_X() >= this.get_Width() - 28 
                && e.get_X() <= this.get_Width() - 16 
                && e.get_Y() >= this.get_Height() - 14 
                && e.get_Y() <= this.get_Height() - 2) {
                
                overButton = 1;
            }
            else {
                if (e.get_X() >= this.get_Width() - 14 
                    && e.get_X() <= this.get_Width() - 2 
                    && e.get_Y() >= this.get_Height() - 14 
                    && e.get_Y() <= this.get_Height() - 2) {
                    
                    overButton = 2;
                }
                else {
                    overButton = -1;
                }
            }
        }
        this.Refresh();
    } //OnMouseMove

    private void UpdateAngle(int mX, int mY)
    {
        // Store mouse coordinates.
        dbX = mX;
        dbY = mY;

        // Translate y coordinate input to GetAngle function to correct for 
        // ellipsoid distortion.
        double widthToHeightRatio = 
            (double)(this.get_Width()) / (double)(this.get_Height());
        int tmY;
        if (mY == 0) {
            tmY = mY;
        }
        else {
            if (mY < this.get_Height() / 2) {
                tmY = this.get_Height() / 2 
                    - (int)((this.get_Height() / 2 - mY) * widthToHeightRatio);
            }
            else {
                tmY = this.get_Height() / 2 + (int)((double)
                    (mY - this.get_Height() / 2) * widthToHeightRatio);
            }
        } 
        // Retrieve updated angle based on rise over run.
        angle = (GetAngle(this.get_Width() / 2, this.get_Height() / 2, mX, 
            tmY) - rotation) % 360;
    } //UpdateAngle

    private double GetAngle(int x1, int y1, int x2, int y2)
    {
        double degrees;

        // Avoid divide by zero run values.
        if (x2 - x1 == 0) {
            if (y2 > y1) {
                degrees = 90;
            }
            else {
                degrees = 270;
            }
        }
        else {
            // Calculate angle from offset.
            double riseOverRun = (double)(y2 - y1) / (double)(x2 - x1);
            double radians = System.Math.Atan(riseOverRun);
            degrees = radians * (double)(180) / System.Math.PI;

            // Handle quadrant specific transformations.       
            if (x2 - x1 < 0 || y2 - y1 < 0) {
                degrees += 180;
            }
            if (x2 - x1 > 0 && y2 - y1 < 0) {
                degrees -= 180;
            }
            if (degrees < 0) {
                degrees += 360;
            }
        }
        return degrees;
    } //GetAngle
} //AngleControl
   
public class AngleEditorTestControl extends System.Windows.Forms.UserControl
{
    private double intAngle;

    /** @attribute BrowsableAttribute(true)
     */
    /** @attribute EditorAttribute(AngleEditor.class, 
        System.Drawing.Design.UITypeEditor.class)
     */
    /** @property 
     */
    public double get_Angle()
    {
        return intAngle;
    } //get_Angle

    /** @property 
     */
    public void set_Angle(double value)
    {
        intAngle = value;
    } //set_Angle

    public AngleEditorTestControl()
    {
        intAngle = 90;
        this.set_Size(new Size(190, 42));
        this.set_BackColor(Color.get_Beige());
    } //AngleEditorTestControl

    protected void OnPaint(System.Windows.Forms.PaintEventArgs e)
    {
        if (this.get_DesignMode()) {
            e.get_Graphics().DrawString("Use the Properties Window to access", 
                new Font("Arial", 8), new SolidBrush(Color.get_Black()), 3, 2);
            e.get_Graphics().DrawString("the AngleEditor UITypeEditor by", 
                new Font("Arial", 8), new SolidBrush(Color.get_Black()), 3, 14);
            e.get_Graphics().DrawString("configuring the \"Angle\" property.", 
                new Font("Arial", 8), new SolidBrush(Color.get_Black()), 3, 26);
        }
        else {
            e.get_Graphics().DrawString("This example requires design mode.", 
                new Font("Arial", 8), new SolidBrush(Color.get_Black()), 3, 2);
        }
    } //OnPaint
} //AngleEditorTestControl

System.Object
  System.Drawing.Design.UITypeEditor
     Derived Classes

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

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

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

Community Additions

ADD
Show:
© 2014 Microsoft