Export (0) Print
Expand All

AccessibleObject Class

Provides information that accessibility applications use to adjust an application's UI for users with impairments.

For a list of all members of this type, see AccessibleObject Members.

System.Object
   System.MarshalByRefObject
      System.Windows.Forms.AccessibleObject
         System.Windows.Forms.Control.ControlAccessibleObject
         System.Windows.Forms.Design.ControlDesigner.ControlDesignerAccessibleObject

[Visual Basic]
<ComVisible(True)>
Public Class AccessibleObject
   Inherits MarshalByRefObject
   Implements IReflect, IAccessible
[C#]
[ComVisible(true)]
public class AccessibleObject : MarshalByRefObject, IReflect,
   IAccessible
[C++]
[ComVisible(true)]
public __gc class AccessibleObject : public MarshalByRefObject,
   IReflect, IAccessible
[JScript]
public
   ComVisible(true)
class AccessibleObject extends MarshalByRefObject implements
   IReflect, IAccessible

Thread Safety

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

Remarks

Accessibility applications can adjust features of the application to improve usability for users with disabilities.

For users who are visually impaired, you can adjust software and operating system features to comply with their needs. For example, you can enlarge text and images and render them with a contrast. In addition, you can accommodate color-blindness with the appropriate use of colors. For users who are severely visually impaired, computers are accessible with screen review aids that translate on-screen text to speech or to a dynamic, refreshable, Braille display.

For users who are hard of hearing, you can design programs that use visual cues, such as a flashing toolbar; or you can display spoken messages as text. For example, when turned on, the SoundSentry feature, an accessibility option in Control Panel, provides a visual warning whenever the system makes an alarm sound.

For users with motion disabilities, you can design controls that refine or eliminate keyboard and mouse use, thereby improving computer accessibility. Control Panel offers assistance. For example, one alternative is to use the numeric keypad instead of the mouse for navigation. Another option, called StickyKeys, enables users who cannot hold down two or more keys at a time (such as CTRL+P) to get the same result by typing one key at a time.

For users with cognitive and language disabilities, you can design software programs to better accommodate their needs. For example, using conspicuous or cued sequencing, uncomplicated displays, fewer words, and a reading level targeted to elementary school standards can benefit these users.

For users with seizure disorders, you can design software programs to eliminate seizure provoking patterns.

For an overview on accessibility, including additional information on accessibility applications, see the documentation for Microsoft Accessibility in the MSDN library or at the Microsoft Web site.

Notes to Inheritors:  When you inherit from this class, you can override all the members.

Note   To use the AccessibleObject, you must add a reference to the Accessibility assembly installed with the .NET Framework.

Example

[Visual Basic, C#, C++] The following example demonstrates the creation of an accessibility-aware chart control, using the AccessibleObject and Control.ControlAccessibleObject classes to expose accessible information. The control plots two curves along with a legend. The ChartControlAccessibleObject class, which derives from ControlAccessibleObject, is used in the CreateAccessibilityInstance method to provide custom accessible information for the chart control. Since the chart legend is not an actual Control-based control, but instead is drawn by the chart control, it does not any built-in accessible information. Because of this, the ChartControlAccessibleObject class overrides the GetChild method to return the CurveLegendAccessibleObject that represents accessible information for each part of the legend. When an accessible-aware application uses this control, the control can provide the necessary accessible information.

[Visual Basic] 
Option Explicit

Imports System
Imports System.Drawing
Imports System.Windows.Forms

Namespace ChartControlNameSpace
    
    Public Class Form1 
        Inherits System.Windows.Forms.Form

        ' Test out the Chart Control.
        Private chart1 As ChartControl

        <System.STAThread()> _
        Public Shared Sub Main()
            System.Windows.Forms.Application.Run(New Form1())
        End Sub 'Main

        Public Sub New() 
            ' Create a chart control and add it to the form.
            Me.chart1 = New ChartControl()
            Me.ClientSize = New System.Drawing.Size(920, 566)

            Me.chart1.Location = New System.Drawing.Point(47, 16)
            Me.chart1.Size = New System.Drawing.Size(600, 400)

            Me.Controls.Add(Me.chart1)
        End Sub
    End Class

    ' Declares a chart control that demonstrates Accessibility in Windows Forms.
    Public Class ChartControl
        Inherits System.Windows.Forms.UserControl

        Private legend1 As CurveLegend
        Private legend2 As CurveLegend
        
        Public Sub New()
            ' The ChartControl draws the chart in the OnPaint override.
            SetStyle(ControlStyles.ResizeRedraw, True)
            SetStyle(ControlStyles.DoubleBuffer, True)
            SetStyle(ControlStyles.AllPaintingInWmPaint, True)
            
            Me.BackColor = System.Drawing.Color.White
            Me.Name = "ChartControl"

            ' The CurveLengend is not Control-based, it just
            ' represent the parts of the legend.
            legend1 = New CurveLegend(Me, "A")
            legend1.Location = New Point(20, 30)
            legend2 = New CurveLegend(Me, "B")
            legend2.Location = New Point(20, 50)
        End Sub 'New
              
        ' Overridden to return the custom AccessibleObject 
        ' for the entire chart.
        Protected Overrides Function CreateAccessibilityInstance() As AccessibleObject
            Return New ChartControlAccessibleObject(Me)
        End Function 

        Protected Overrides Sub OnPaint(e As PaintEventArgs)
            ' The ChartControl draws the chart in the OnPaint override.
            MyBase.OnPaint(e)
            
            Dim bounds As Rectangle = Me.ClientRectangle
            Dim border As Integer = 5
            
            ' Draw the legends first.
            Dim format As New StringFormat()
            format.Alignment = StringAlignment.Center
            format.LineAlignment = StringAlignment.Center
            
            If Not (legend1 Is Nothing) Then
                If legend1.Selected Then
                    e.Graphics.FillRectangle(New SolidBrush(Color.Blue), legend1.Bounds)
                Else
                    e.Graphics.DrawRectangle(Pens.Blue, legend1.Bounds)
                End If
                e.Graphics.DrawString(legend1.Name, Me.Font, Brushes.Black, RectangleF.op_Implicit(legend1.Bounds), format)
            End If
            If Not (legend2 Is Nothing) Then
                If legend2.Selected Then
                    e.Graphics.FillRectangle(New SolidBrush(Color.Red), legend2.Bounds)
                Else
                    e.Graphics.DrawRectangle(Pens.Red, legend2.Bounds)
                End If
                e.Graphics.DrawString(legend2.Name, Me.Font, Brushes.Black, RectangleF.op_Implicit(legend2.Bounds), format)
            End If
            
            ' Chart out the actual curves that represent data in the Chart.
            bounds.Inflate(-border, -border)
            Dim curve1() As Point = {New Point(bounds.Left, bounds.Bottom), _
                                     New Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5), _
                                     New Point(bounds.Right - bounds.Width / 3,(bounds.Top + bounds.Bottom) / 2), _
                                     New Point(bounds.Right, bounds.Top)}

            Dim curve2() As Point = {New Point(bounds.Left, bounds.Bottom - bounds.Height / 3), _
                                     New Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5), _
                                     New Point(bounds.Right - bounds.Width / 3,(bounds.Top + bounds.Bottom) / 2), _
                                     New Point(bounds.Right, bounds.Top + bounds.Height / 2)}
            
            ' Draw the actual curve only if it is selected.
            If legend1.Selected Then
                e.Graphics.DrawCurve(Pens.Blue, curve1)
            End If
            If legend2.Selected Then
                e.Graphics.DrawCurve(Pens.Red, curve2)
            End If 
            e.Graphics.DrawRectangle(Pens.Blue, bounds)
        End Sub 'OnPaint
        
        ' Handle the QueryAccessibilityHelp event.
        Private Sub ChartControl_QueryAccessibilityHelp(sender As Object, _
                           e As System.Windows.Forms.QueryAccessibilityHelpEventArgs) Handles MyBase.QueryAccessibilityHelp
            e.HelpString = "Displays chart data"
        End Sub 

        ' Handle the Click event for the chart. 
        ' Toggle the selection of whatever legend was clicked.     
        Private Sub ChartControl_Click(sender As Object, e As System.EventArgs) Handles MyBase.Click

            Dim pt As Point = Me.PointToClient(Control.MousePosition)
            If legend1.Bounds.Contains(pt) Then
                legend1.Selected = Not legend1.Selected
            Else
                If legend2.Bounds.Contains(pt) Then
                    legend2.Selected = Not legend2.Selected
                End If
            End If
        End Sub 'ChartControl_Click

        ' Get an array of the CurveLengends used in the Chart.
        Public ReadOnly Property Legends() As CurveLegend()
            Get
                Return New CurveLegend() {legend1, legend2}
            End Get
        End Property
        
        Protected Sub ExposeAccessibilityNotifyClients(ByVal accEvent As AccessibleEvents, ByVal childID As Integer)
            AccessibilityNotifyClients(accEvent, childID) 
        End Sub

        ' Inner Class ChartControlAccessibleObject represents accessible information 
        ' associated with the ChartControl.
        ' The ChartControlAccessibleObject is returned in the         ' ChartControl.CreateAccessibilityInstance override.
        Public Class ChartControlAccessibleObject
            Inherits Control.ControlAccessibleObject

            Private chartControl As ChartControl
            
            Public Sub New(ctrl As ChartControl)
                MyBase.New(ctrl)
                chartControl = ctrl
            End Sub 'New
            
            ' Get the role for the Chart. This is used by accessibility programs.            
            Public Overrides ReadOnly Property Role() As AccessibleRole
                Get
                    Return System.Windows.Forms.AccessibleRole.Chart
                End Get
            End Property
            
            ' Get the state for the Chart. This is used by accessibility programs.            
            Public Overrides ReadOnly Property State() As AccessibleStates
                Get
                    Return AccessibleStates.ReadOnly
                End Get
            End Property                        
            
            ' The CurveLegend objects are "child" controls in terms of accessibility so 
            ' return the number of ChartLengend objects.            
            Public Overrides Function GetChildCount() As Integer
                Return chartControl.Legends.Length
            End Function 
            
            ' Get the Accessibility object of the child CurveLegend idetified by index.
            Public Overrides Function GetChild(index As Integer) As AccessibleObject
                If index >= 0 And index < chartControl.Legends.Length Then
                    Return chartControl.Legends(index).AccessibilityObject
                End If
                Return Nothing
            End Function 
            
            ' Helper function that is used by the CurveLegend's accessibility object
            ' to navigate between sibiling controls. Specifically, this function is used in
            ' the CurveLegend.CurveLegendAccessibleObject.Navigate function.
            Friend Function NavigateFromChild(child As CurveLegend.CurveLegendAccessibleObject, _
                                            navdir As AccessibleNavigation) As AccessibleObject
                Select Case navdir
                    Case AccessibleNavigation.Down, AccessibleNavigation.Next
                            Return GetChild(child.ID + 1)
                    
                    Case AccessibleNavigation.Up, AccessibleNavigation.Previous
                            Return GetChild(child.ID - 1)
                End Select
                Return Nothing
            End Function            

            ' Helper function that is used by the CurveLegend's accessibility object
            ' to select a specific CurveLegend control. Specifically, this function is used 
            ' in the CurveLegend.CurveLegendAccessibleObject.Select function.            
            Friend Sub SelectChild(child As CurveLegend.CurveLegendAccessibleObject, selection As AccessibleSelection)
                Dim childID As Integer = child.ID
                
                ' Determine which selection action should occur, based on the
                ' AccessibleSelection value.
                If (selection And AccessibleSelection.TakeSelection) <> 0 Then
                    Dim i As Integer
                    For i = 0 To chartControl.Legends.Length - 1
                        If i = childID Then
                            chartControl.Legends(i).Selected = True
                        Else
                            chartControl.Legends(i).Selected = False
                        End If
                    Next i
                    
                    ' AccessibleSelection.AddSelection means that the CurveLegend will be selected.
                    If (selection And AccessibleSelection.AddSelection) <> 0 Then
                        chartControl.Legends(childID).Selected = True
                    End If

                    ' AccessibleSelection.AddSelection means that the CurveLegend will be unselected.                    
                    If (selection And AccessibleSelection.RemoveSelection) <> 0 Then
                        chartControl.Legends(childID).Selected = False
                    End If
                End If
            End Sub 'SelectChild
        End Class 'ChartControlAccessibleObject

        ' Inner Class that represents a legend for a curve in the chart.
        Public Class CurveLegend
            Private m_name As String
            Private chart As ChartControl
            Private accObj As CurveLegendAccessibleObject
            Private m_selected As Boolean = True
            Private m_location As Point
            
            Public Sub New(chart As ChartControl, name As String)
                Me.chart = chart
                Me.m_name = name
            End Sub 'New

            ' Gets the accessibility object for the curve legend.            
            Public ReadOnly Property AccessibilityObject() As AccessibleObject
                Get
                    If accObj Is Nothing Then
                        accObj = New CurveLegendAccessibleObject(Me)
                    End If
                    Return accObj
                End Get
            End Property
            
            ' Gets the bounds for the curve legend.            
            Public ReadOnly Property Bounds() As Rectangle
                Get
                    Return New Rectangle(Location, Size)
                End Get
            End Property

            ' Gets or sets the location for the curve legend.            
            Public Property Location() As Point
                Get
                    Return m_location
                End Get
                Set
                    m_location = value
                    chart.Invalidate()

                    ' Notifies the chart of the location change. This is used for
                    ' the accessibility information. AccessibleEvents.LocationChange
                    ' tells the chart the reason for the notification.
                    chart.ExposeAccessibilityNotifyClients(AccessibleEvents.LocationChange, _
                            CType(AccessibilityObject, CurveLegendAccessibleObject).ID)
                End Set
            End Property
            
            ' Gets or sets the Name for the curve legend.            
            Public Property Name() As String
                Get
                    Return m_name
                End Get
                Set
                    If m_name <> value Then
                        m_name = value
                        chart.Invalidate()

                        ' Notifies the chart of the name change. This is used for
                        ' the accessibility information. AccessibleEvents.NameChange
                        ' tells the chart the reason for the notification. 
                        chart.ExposeAccessibilityNotifyClients(AccessibleEvents.NameChange, _
                                CType(AccessibilityObject, CurveLegendAccessibleObject).ID)
                    End If
                End Set
            End Property
            
            ' Gets or sets the Selected state for the curve legend.            
            Public Property Selected() As Boolean
                Get
                    Return m_selected
                End Get
                Set
                    If m_selected <> value Then
                        m_selected = value
                        chart.Invalidate()

                        ' Notifies the chart of the selection value change. This is used for
                        ' the accessibility information. The AccessibleEvents value varies
                        ' on whether the selection is true (AccessibleEvents.SelectionAdd) or 
                        ' false (AccessibleEvents.SelectionRemove). 
                        If m_selected Then
                            chart.ExposeAccessibilityNotifyClients(AccessibleEvents.SelectionAdd, _
                                    CType(AccessibilityObject, CurveLegendAccessibleObject).ID) 
                        Else
                            chart.ExposeAccessibilityNotifyClients(AccessibleEvents.SelectionRemove, _
                                    CType(AccessibilityObject, CurveLegendAccessibleObject).ID) 
                        End If
                    End If
                End Set
            End Property
            
            ' Gets the Size for the curve legend.            
            Public ReadOnly Property Size() As Size
                Get
                    Dim legendHeight As Integer = chart.Font.Height + 4
                    Dim g As Graphics = chart.CreateGraphics()
                    Dim legendWidth As Integer = CInt(g.MeasureString(Name, chart.Font).Width) + 4
                    
                    Return New Size(legendWidth, legendHeight)
                End Get
            End Property
            
            
            ' Inner class CurveLegendAccessibleObject represents accessible information 
            ' associated with the CurveLegend object.
            Public Class CurveLegendAccessibleObject
                Inherits AccessibleObject

                Private curveLegend As CurveLegend
                
                Public Sub New(curveLegend As CurveLegend)
                    Me.curveLegend = curveLegend
                End Sub 'New
                
                ' Private property that helps get the reference to the parent ChartControl.                
                Private ReadOnly Property ChartControl() As ChartControlAccessibleObject
                    Get
                        Return CType(Parent, ChartControlAccessibleObject)
                    End Get
                End Property

                ' Friend helper function that returns the ID for this CurveLegend.                
                Friend ReadOnly Property ID() As Integer
                    Get
                        Dim i As Integer
                        For i = 0 To (ChartControl.GetChildCount()) - 1
                            If ChartControl.GetChild(i) Is Me Then
                                Return i
                            End If
                        Next i
                        Return - 1
                    End Get
                End Property
                
                ' Gets the Bounds for the CurveLegend. This is used by accessibility programs.
                Public Overrides ReadOnly Property Bounds() As Rectangle
                    Get
                        ' The bounds is in screen coordinates.
                        Dim loc As Point = curveLegend.Location
                        Return New Rectangle(curveLegend.chart.PointToScreen(loc), curveLegend.Size)
                    End Get
                End Property

                ' Gets or sets the Name for the CurveLegend. This is used by accessibility programs.                
                Public Overrides Property Name() As String
                    Get
                        Return curveLegend.Name
                    End Get
                    Set
                        curveLegend.Name = value
                    End Set
                End Property
                
                ' Gets the Curve Legend Parent's Accessible object.
                ' This is used by accessibility programs.                
                Public Overrides ReadOnly Property Parent() As AccessibleObject
                    Get
                        Return curveLegend.chart.AccessibilityObject
                    End Get
                End Property
                
                ' Gets the role for the CurveLegend. This is used by accessibility programs.                
                Public Overrides ReadOnly Property Role() As AccessibleRole
                    Get
                        Return System.Windows.Forms.AccessibleRole.StaticText
                    End Get
                End Property

                ' Gets the state based on the selection for the CurveLegend. 
                ' This is used by accessibility programs.                
                Public Overrides ReadOnly Property State() As AccessibleStates
                    Get
                        Dim stateTemp As AccessibleStates = AccessibleStates.Selectable
                        If curveLegend.Selected Then
                            stateTemp = stateTemp Or AccessibleStates.Selected
                        End If
                        Return stateTemp
                    End Get
                End Property
                
                ' Navigates through siblings of this CurveLegend. This is used by accessibility programs.                
                Public Overrides Function Navigate(navdir As AccessibleNavigation) As AccessibleObject
                    ' Use the Friend NavigateFromChild helper function that exists
                    ' on ChartControlAccessibleObject.
                    Return ChartControl.NavigateFromChild(Me, navdir)
                End Function
                
                ' Selects or unselects this CurveLegend. This is used by accessibility programs.
                Public Overrides Sub [Select](selection As AccessibleSelection)

                    ' Use the internal SelectChild helper function that exists
                    ' on ChartControlAccessibleObject.
                    ChartControl.SelectChild(Me, selection)
                End Sub

            End Class 'CurveLegendAccessibleObject

        End Class 'CurveLegend

    End Class 'ChartControl

End Namespace 'ChartControlNameSpace

[C#] 
using System;
using System.Drawing;
using System.Windows.Forms;

namespace ChartControl
{
    public class Form1 : System.Windows.Forms.Form
    {
        // Test out the Chart Control.
        private ChartControl chart1;

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

        public Form1() {
            // Create a chart control and add it to the form.
            this.chart1 = new ChartControl();
            this.ClientSize = new System.Drawing.Size(920, 566);

            this.chart1.Location = new System.Drawing.Point(47, 16);
            this.chart1.Size = new System.Drawing.Size(600, 400);

            this.Controls.Add(this.chart1);
        }
    }

    // Declare a chart control that demonstrates accessibility in Windows Forms.
    public class ChartControl : System.Windows.Forms.UserControl
    {
        private CurveLegend legend1;
        private CurveLegend legend2; 

        public ChartControl()
        {
            // The ChartControl draws the chart in the OnPaint override.
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.DoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);

            this.BackColor = System.Drawing.Color.White;
            this.Name = "ChartControl";

            this.Click += new System.EventHandler(this.ChartControl_Click);
            this.QueryAccessibilityHelp += 
                new System.Windows.Forms.QueryAccessibilityHelpEventHandler(
                                        this.ChartControl_QueryAccessibilityHelp);

            // The CurveLengend is not Control-based, it just
            // represents the parts of the legend.
            legend1 = new CurveLegend(this, "A");
            legend1.Location = new Point(20, 30);
            legend2 = new CurveLegend(this, "B");        
            legend2.Location = new Point(20, 50);
        }

        // Overridden to return the custom AccessibleObject 
        // for the entire chart.
        protected override AccessibleObject CreateAccessibilityInstance() 
        {            
            return new ChartControlAccessibleObject(this);
        }

        protected override void OnPaint(PaintEventArgs e) 
        {
            // The ChartControl draws the chart in the OnPaint override.
            base.OnPaint(e);

            Rectangle bounds = this.ClientRectangle;
            int border = 5;

            // Draws the legends first.
            StringFormat format = new StringFormat();
            format.Alignment = StringAlignment.Center;
            format.LineAlignment = StringAlignment.Center;
            
            if (legend1 != null) {
                if (legend1.Selected) {
                    e.Graphics.FillRectangle(new SolidBrush(Color.Blue), legend1.Bounds);
                } else {
                    e.Graphics.DrawRectangle(Pens.Blue, legend1.Bounds);
                }

                e.Graphics.DrawString(legend1.Name, this.Font, Brushes.Black, legend1.Bounds, format);                
            }
            if (legend2 != null) {
                if (legend2.Selected) {
                    e.Graphics.FillRectangle(new SolidBrush(Color.Red), legend2.Bounds);
                } else {
                    e.Graphics.DrawRectangle(Pens.Red, legend2.Bounds);
                }
                e.Graphics.DrawString(legend2.Name, this.Font, Brushes.Black, legend2.Bounds, format);
            }            

            // Charts out the actual curves that represent data in the Chart.
            bounds.Inflate(-border, -border);
            Point[] curve1 = new Point[] {new Point(bounds.Left, bounds.Bottom),
                            new Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5),
                            new Point(bounds.Right - bounds.Width / 3, (bounds.Top + bounds.Bottom) / 2),
                            new Point(bounds.Right, bounds.Top)};

            Point[] curve2 = new Point[] {new Point(bounds.Left, bounds.Bottom - bounds.Height / 3),
                            new Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5),
                            new Point(bounds.Right - bounds.Width / 3, (bounds.Top + bounds.Bottom) / 2),
                            new Point(bounds.Right, bounds.Top + bounds.Height / 2)};

            // Draws the actual curve only if it is selected.
            if (legend1.Selected) e.Graphics.DrawCurve(Pens.Blue, curve1);
            if (legend2.Selected) e.Graphics.DrawCurve(Pens.Red, curve2);

            e.Graphics.DrawRectangle(Pens.Blue, bounds);            
        }

        // Handles the QueryAccessibilityHelp event.
        private void ChartControl_QueryAccessibilityHelp(object sender, 
                                    System.Windows.Forms.QueryAccessibilityHelpEventArgs e)
        {            
            e.HelpString = "Displays chart data";
        }          

        // Handles the Click event for the chart. 
        // Toggles the selection of whatever legend was clicked on
        private void ChartControl_Click(object sender, System.EventArgs e)
        {
            Point pt = this.PointToClient(Control.MousePosition);
            if (legend1.Bounds.Contains(pt)) {
                legend1.Selected = !legend1.Selected;

            } else if (legend2.Bounds.Contains(pt)) {
                legend2.Selected = !legend2.Selected;
            }
        }

        // Gets an array of CurveLengends used in the Chart.
        public CurveLegend[] Legends
        {   
            get {                
                return new CurveLegend[] { legend1, legend2 };
            }            
        }                

        // Inner class ChartControlAccessibleObject represents accessible information associated with the ChartControl.
        // The ChartControlAccessibleObject is returned in the ChartControl.CreateAccessibilityInstance override.
        public class ChartControlAccessibleObject : ControlAccessibleObject
        {
            ChartControl chartControl;

            public ChartControlAccessibleObject(ChartControl ctrl) : base(ctrl) 
            {
                chartControl = ctrl;
            }

            // Gets the role for the Chart. This is used by accessibility programs.
            public override AccessibleRole Role
            {  
                get {
                    return AccessibleRole.Chart;
                }
            }

            // Gets the state for the Chart. This is used by accessibility programs.
            public override AccessibleStates State
            {  
                get {                    
                    return AccessibleStates.ReadOnly;
                }
            }

            // The CurveLegend objects are "child" controls in terms of accessibility so 
            // return the number of ChartLengend objects.
            public override int GetChildCount()
            {  
                return chartControl.Legends.Length;
            }

            // Gets the Accessibility object of the child CurveLegend idetified by index.
            public override AccessibleObject GetChild(int index)
            {  
                if (index >= 0 && index < chartControl.Legends.Length) {
                    return chartControl.Legends[index].AccessibilityObject;
                }                
                return null;
            }

            // Helper function that is used by the CurveLegend's accessibility object
            // to navigate between sibiling controls. Specifically, this function is used in
            // the CurveLegend.CurveLegendAccessibleObject.Navigate function.
            internal AccessibleObject NavigateFromChild(CurveLegend.CurveLegendAccessibleObject child, 
                                                        AccessibleNavigation navdir) 
            {  
                switch(navdir) {
                    case AccessibleNavigation.Down:
                    case AccessibleNavigation.Next:
                        return GetChild(child.ID + 1);
                        
                    case AccessibleNavigation.Up:
                    case AccessibleNavigation.Previous:
                        return GetChild(child.ID - 1);                        
                }
                return null;
            }

            // Helper function that is used by the CurveLegend's accessibility object
            // to select a specific CurveLegend control. Specifically, this function is used
            // in the CurveLegend.CurveLegendAccessibleObject.Select function.
            internal void SelectChild(CurveLegend.CurveLegendAccessibleObject child, AccessibleSelection selection) 
            {   
                int childID = child.ID;

                // Determine which selection action should occur, based on the
                // AccessibleSelection value.
                if ((selection & AccessibleSelection.TakeSelection) != 0) {
                    for(int i = 0; i < chartControl.Legends.Length; i++) {
                        if (i == childID) {
                            chartControl.Legends[i].Selected = true;                        
                        } else {
                            chartControl.Legends[i].Selected = false;
                        }
                    }

                    // AccessibleSelection.AddSelection means that the CurveLegend will be selected.
                    if ((selection & AccessibleSelection.AddSelection) != 0) {
                        chartControl.Legends[childID].Selected = true;                        
                    }

                    // AccessibleSelection.AddSelection means that the CurveLegend will be unselected.
                    if ((selection & AccessibleSelection.RemoveSelection) != 0) {
                        chartControl.Legends[childID].Selected = false;                        
                    }
                }            
            }
        }

        // Inner Class that represents a legend for a curve in the chart.
        public class CurveLegend 
        {
            private string name;
            private ChartControl chart;
            private CurveLegendAccessibleObject accObj;
            private bool selected = true;
            private Point location;

            public CurveLegend(ChartControl chart, string name) 
            {
                this.chart = chart;
                this.name = name;
            }

            // Gets the accessibility object for the curve legend.
            public AccessibleObject AccessibilityObject
            {
                get {
                    if (accObj == null) {
                        accObj = new CurveLegendAccessibleObject(this);
                    }
                    return accObj;
                }
            }
            
            // Gets the bounds for the curve legend.
            public Rectangle Bounds
            {   
                get {
                    return new Rectangle(Location, Size);
                }
            }

            // Gets or sets the location for the curve legend.
            public Point Location
            {   
                get {
                    return location;
                }
                set {
                    location = value;
                    chart.Invalidate();

                    // Notifies the chart of the location change. This is used for
                    // the accessibility information. AccessibleEvents.LocationChange
                    // tells the chart the reason for the notification.

                    chart.AccessibilityNotifyClients(AccessibleEvents.LocationChange, 
                        ((CurveLegendAccessibleObject)AccessibilityObject).ID);
                }
            }            
        
            // Gets or sets the Name for the curve legend.
            public string Name
            {   
                get {
                    return name;
                }
                set {
                    if (name != value) 
                    {
                        name = value;
                        chart.Invalidate();

                        // Notifies the chart of the name change. This is used for
                        // the accessibility information. AccessibleEvents.NameChange
                        // tells the chart the reason for the notification.

                        chart.AccessibilityNotifyClients(AccessibleEvents.NameChange, 
                            ((CurveLegendAccessibleObject)AccessibilityObject).ID);
                    }
                }
            }

            // Gets or sets the Selected state for the curve legend.
            public bool Selected
            {   
                get {
                    return selected;
                }
                set {
                    if (selected != value) 
                    {
                        selected = value;
                        chart.Invalidate();

                        // Notifies the chart of the selection value change. This is used for
                        // the accessibility information. The AccessibleEvents value depends upon
                        // if the selection is true (AccessibleEvents.SelectionAdd) or 
                        // false (AccessibleEvents.SelectionRemove).
                        chart.AccessibilityNotifyClients(
                            selected ? AccessibleEvents.SelectionAdd : AccessibleEvents.SelectionRemove, 
                            ((CurveLegendAccessibleObject)AccessibilityObject).ID);
                    }
                }
            }

            // Gets the Size for the curve legend.
            public Size Size
            {   
                get {                    
                    int legendHeight = chart.Font.Height + 4;
                    Graphics g = chart.CreateGraphics();
                    int legendWidth = (int)g.MeasureString(Name, chart.Font).Width + 4;            

                    return new Size(legendWidth, legendHeight);
                }
            }
    
            // Inner class CurveLegendAccessibleObject represents accessible information 
            // associated with the CurveLegend object.
            public class CurveLegendAccessibleObject : AccessibleObject
            {
                private CurveLegend curveLegend;

                public CurveLegendAccessibleObject(CurveLegend curveLegend) : base() 
                {
                    this.curveLegend = curveLegend;                    
                }                

                // Private property that helps get the reference to the parent ChartControl.
                private ChartControlAccessibleObject ChartControl
                {   
                    get {
                        return Parent as ChartControlAccessibleObject;
                    }
                }

                // Internal helper function that returns the ID for this CurveLegend.
                internal int ID
                {
                    get {
                        for(int i = 0; i < ChartControl.GetChildCount(); i++) {
                            if (ChartControl.GetChild(i) == this) {
                                return i;
                            }
                        }
                        return -1;
                    }
                }

                // Gets the Bounds for the CurveLegend. This is used by accessibility programs.
                public override Rectangle Bounds
                {
                    get {                        
                        // The bounds is in screen coordinates.
                        Point loc = curveLegend.Location;
                        return new Rectangle(curveLegend.chart.PointToScreen(loc), curveLegend.Size);
                    }
                }

                // Gets or sets the Name for the CurveLegend. This is used by accessibility programs.
                public override string Name
                {
                    get {
                        return curveLegend.Name;
                    }
                    set {
                        curveLegend.Name = value;                        
                    }
                }

                // Gets the Curve Legend Parent's Accessible object.
                // This is used by accessibility programs.
                public override AccessibleObject Parent
                {
                    get {
                        return curveLegend.chart.AccessibilityObject;
                    }
                }

                // Gets the role for the CurveLegend. This is used by accessibility programs.
                public override AccessibleRole Role 
                {
                    get {
                        return AccessibleRole.StaticText;
                    }
                }

                // Gets the state based on the selection for the CurveLegend. 
                // This is used by accessibility programs.
                public override AccessibleStates State 
                {
                    get {
                        AccessibleStates state = AccessibleStates.Selectable;
                        if (curveLegend.Selected) 
                        {
                            state |= AccessibleStates.Selected;
                        }
                        return state;
                    }
                }

                // Navigates through siblings of this CurveLegend. This is used by accessibility programs.
                public override AccessibleObject Navigate(AccessibleNavigation navdir) 
                {
                    // Uses the internal NavigateFromChild helper function that exists
                    // on ChartControlAccessibleObject.
                    return ChartControl.NavigateFromChild(this, navdir);
                }

                // Selects or unselects this CurveLegend. This is used by accessibility programs.
                public override void Select(AccessibleSelection selection) 
                {
                    // Uses the internal SelectChild helper function that exists
                    // on ChartControlAccessibleObject.
                    ChartControl.SelectChild(this, selection);
                }
            }
        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <Accessibility.dll>
#using <System.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;

// Declare a chart control that demonstrates accessibility in Windows Forms.
public __gc class ChartControl : public System::Windows::Forms::UserControl {
public:
   __gc class ChartControlAccessibleObject; // forward declaration

   // Inner Class that represents a legend for a curve in the chart.
public:
   __gc class CurveLegend {

      // Inner class CurveLegendAccessibleObject represents accessible information
      // associated with the CurveLegend object.
   public:
      __gc class CurveLegendAccessibleObject : public AccessibleObject {
      private:
         CurveLegend*  curveLegend;

      public:
         CurveLegendAccessibleObject(CurveLegend* curveLegend) : AccessibleObject() {
            this->curveLegend = curveLegend;
         }

         // Private property that helps get the reference to the parent ChartControl.
      private:
         __property ChartControlAccessibleObject* get_ChartControl() {
            return dynamic_cast<ChartControlAccessibleObject*>(Parent);
         }


         // Internal helper function that returns the ID for this CurveLegend.
      public private:
         __property int get_ID() {
            for (int i = 0; i < ChartControl->GetChildCount(); i++) {
               if (ChartControl->GetChild(i) == this) {
                  return i;
               }
            }
            return -1;
         }

         // Gets the Bounds for the CurveLegend. This is used by accessibility programs.
      public:
         __property Rectangle get_Bounds() {
            // The bounds is in screen coordinates.
            Point loc = curveLegend->Location;
            return Rectangle(curveLegend->chart->PointToScreen(loc), curveLegend->Size);
         }

         // Gets or sets the Name for the CurveLegend. This is used by accessibility programs.
         __property String* get_Name() {
            return curveLegend->Name;
         }
         __property void set_Name(String* value) {
            curveLegend->Name = value;
         }

         // Gets the Curve Legend Parent's Accessible object.
         // This is used by accessibility programs.
         __property AccessibleObject* get_Parent() {
            return curveLegend->chart->AccessibilityObject;
         }

         // Gets the role for the CurveLegend. This is used by accessibility programs.
         __property System::Windows::Forms::AccessibleRole get_Role() {
            return AccessibleRole::StaticText;
         }

         // Gets the state based on the selection for the CurveLegend.
         // This is used by accessibility programs.
         __property AccessibleStates get_State() {
            AccessibleStates state = AccessibleStates::Selectable;
            if (curveLegend->Selected) {
               state = static_cast<AccessibleStates>( state | AccessibleStates::Selected );
            }
            return state;
         }

         // Navigates through siblings of this CurveLegend. This is used by accessibility programs.
         AccessibleObject* Navigate(AccessibleNavigation navdir) {
            // Uses the internal NavigateFromChild helper function that exists
            // on ChartControlAccessibleObject.
            return ChartControl->NavigateFromChild(this, navdir);
         }

         // Selects or unselects this CurveLegend. This is used by accessibility programs.
         void Select(AccessibleSelection selection) {
            // Uses the internal SelectChild helper function that exists
            // on ChartControlAccessibleObject.
            ChartControl->SelectChild(this, selection);
         }
      }; // class CurveLgendAccessibleObject

   private:
      String*  name;
      ChartControl*  chart;
      CurveLegendAccessibleObject*  accObj;
      bool  selected;
      Point  location;

   public:
      CurveLegend(ChartControl* chart, String* name) {
         this->chart = chart;
         this->name = name;
         selected = true;
      }

      // Gets the accessibility object for the curve legend.
      __property AccessibleObject* get_AccessibilityObject() {
         if (accObj == 0) {
            accObj = new CurveLegendAccessibleObject(this);
         }
         return accObj;
      }

      // Gets the bounds for the curve legend.
      __property Rectangle get_Bounds() {
         return Rectangle(Location, Size);
      }

      // Gets or sets the location for the curve legend.
      __property Point get_Location() {
         return location;
      }
      __property void set_Location(Point value) {
         location = value;
         chart->Invalidate();

         // Notifies the chart of the location change. This is used for
         // the accessibility information. AccessibleEvents::LocationChange
         // tells the chart the reason for the notification.

         chart->AccessibilityNotifyClients(AccessibleEvents::LocationChange,
            (dynamic_cast<CurveLegendAccessibleObject*>(AccessibilityObject))->ID);
      }

      // Gets or sets the Name for the curve legend.
      __property String* get_Name() {
         return name;
      }
      __property void set_Name(String* value) {
         if (name != value) {
            name = value;
            chart->Invalidate();

            // Notifies the chart of the name change. This is used for
            // the accessibility information. AccessibleEvents::NameChange
            // tells the chart the reason for the notification.

            chart->AccessibilityNotifyClients(AccessibleEvents::NameChange,
               (dynamic_cast<CurveLegendAccessibleObject*>(AccessibilityObject))->ID);
         }
      }

      // Gets or sets the Selected state for the curve legend.
      __property bool get_Selected() {
         return selected;
      }
      __property void set_Selected(bool value) {
         if (selected != value) {
            selected = value;
            chart->Invalidate();

            // Notifies the chart of the selection value change. This is used for
            // the accessibility information. The AccessibleEvents value depends upon
            // if the selection is true (AccessibleEvents::SelectionAdd) or
            // false (AccessibleEvents::SelectionRemove).
            chart->AccessibilityNotifyClients(selected ? AccessibleEvents::SelectionAdd : AccessibleEvents::SelectionRemove,
               (dynamic_cast<CurveLegendAccessibleObject*>(AccessibilityObject))->ID);
         }
      }


      // Gets the Size for the curve legend.
      __property System::Drawing::Size get_Size() {
         int legendHeight = chart->Font->Height + 4;
         Graphics* g = chart->CreateGraphics();
         int legendWidth = (int)g->MeasureString(Name, chart->Font).Width + 4;

         return System::Drawing::Size(legendWidth, legendHeight);
      }

   }; // class CurveLegend

private:
   CurveLegend*  legend1;
   CurveLegend*  legend2;

public:
   ChartControl() {
      // The ChartControl draws the chart in the OnPaint .
      SetStyle(ControlStyles::ResizeRedraw, true);
      SetStyle(ControlStyles::DoubleBuffer, true);
      SetStyle(ControlStyles::AllPaintingInWmPaint, true);

      this->BackColor = System::Drawing::Color::White;
      this->Name = S"ChartControl";

      this->Click += new System::EventHandler(this, &ChartControl::ChartControl_Click);
      this->QueryAccessibilityHelp +=
         new System::Windows::Forms::QueryAccessibilityHelpEventHandler(this, &ChartControl::ChartControl_QueryAccessibilityHelp);

      // The CurveLengend is not Control-based, it just
      // represents the parts of the legend.
      legend1 = new CurveLegend(this, S"A");
      legend1->Location = Point(20, 30);
      legend2 = new CurveLegend(this, S"B");
      legend2->Location = Point(20, 50);
   }

   // Overridden to return the custom AccessibleObject
   // for the entire chart.
protected:
   AccessibleObject* CreateAccessibilityInstance() {
      return new ChartControlAccessibleObject(this);
   }

   void OnPaint(PaintEventArgs* e) {
      // The ChartControl draws the chart in the OnPaint .
      System::Windows::Forms::UserControl::OnPaint(e);

      Rectangle bounds = this->ClientRectangle;
      int border = 5;

      // Draws the legends first.
      StringFormat* format = new StringFormat();
      format->Alignment = StringAlignment::Center;
      format->LineAlignment = StringAlignment::Center;

      if (legend1 != 0) {
         if (legend1->Selected) {
            e->Graphics->FillRectangle(new SolidBrush(Color::Blue), legend1->Bounds);
         } else {
            e->Graphics->DrawRectangle(Pens::Blue, legend1->Bounds);
         }

         e->Graphics->DrawString(legend1->Name, this->Font, Brushes::Black, RectangleF::op_Implicit(legend1->Bounds), format);
      }
      if (legend2 != 0) {
         if (legend2->Selected) {
            e->Graphics->FillRectangle(new SolidBrush(Color::Red), legend2->Bounds);
         } else {
            e->Graphics->DrawRectangle(Pens::Red, legend2->Bounds);
         }
         e->Graphics->DrawString(legend2->Name, this->Font, Brushes::Black, RectangleF::op_Implicit(legend2->Bounds), format);
      }

      // Charts out the actual curves that represent data in the Chart.
      bounds.Inflate(-border, -border);
      Point temp1[] = {        Point(bounds.Left, bounds.Bottom),
         Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5),
         Point(bounds.Right - bounds.Width / 3, (bounds.Top + bounds.Bottom) / 2),
         Point(bounds.Right, bounds.Top)};
      Point curve1[] = temp1;

      Point temp2[] = {        Point(bounds.Left, bounds.Bottom - bounds.Height / 3),
         Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5),
         Point(bounds.Right - bounds.Width / 3, (bounds.Top + bounds.Bottom) / 2),
         Point(bounds.Right, bounds.Top + bounds.Height / 2)};
      Point curve2[] = temp2;

      // Draws the actual curve only if it is selected.
      if (legend1->Selected) e->Graphics->DrawCurve(Pens::Blue, curve1);
      if (legend2->Selected) e->Graphics->DrawCurve(Pens::Red, curve2);

      e->Graphics->DrawRectangle(Pens::Blue, bounds);
   }

   // Handles the QueryAccessibilityHelp event.
private:
   void ChartControl_QueryAccessibilityHelp(Object* /*sender*/,
      System::Windows::Forms::QueryAccessibilityHelpEventArgs* e) {
         e->HelpString = S"Displays chart data";
      }

      // Handles the Click event for the chart.
      // Toggles the selection of whatever legend was clicked on
      void ChartControl_Click(Object* /*sender*/, System::EventArgs* /*e*/) {
         Point pt = this->PointToClient(Control::MousePosition);
         if (legend1->Bounds.Contains(pt)) {
            legend1->Selected = !legend1->Selected;

         } else if (legend2->Bounds.Contains(pt)) {
            legend2->Selected = !legend2->Selected;
         }
      }

      // Gets an array of CurveLengends used in the Chart.
public:
   __property CurveLegend* get_Legends()[] {
      CurveLegend* temp3[] = { legend1, legend2 };
      return temp3;
   }


   // Inner class ChartControlAccessibleObject represents accessible information associated with the ChartControl.
   // The ChartControlAccessibleObject is returned in the ChartControl::CreateAccessibilityInstance .
   __gc class ChartControlAccessibleObject : public ControlAccessibleObject {
      ChartControl* chartControl;

   public:
      ChartControlAccessibleObject(ChartControl* ctrl) : ControlAccessibleObject (ctrl) {
         chartControl = ctrl;
      }

      // Gets the role for the Chart. This is used by accessibility programs.
      __property System::Windows::Forms::AccessibleRole get_Role() {
         return AccessibleRole::Chart;
      }

      // Gets the state for the Chart. This is used by accessibility programs.
      __property AccessibleStates get_State() {
         return AccessibleStates::ReadOnly;
      }

      // The CurveLegend objects are "child" controls in terms of accessibility so
      // return the number of ChartLengend objects.
      int GetChildCount() {
         return chartControl->Legends->Length;
      }

      // Gets the Accessibility object of the child CurveLegend idetified by index.
      AccessibleObject* GetChild(int index) {
         if (index >= 0 && index < chartControl->Legends->Length) {
            return chartControl->Legends[index]->AccessibilityObject;
         }
         return 0;
      }

      // Helper function that is used by the CurveLegend's accessibility object
      // to navigate between sibiling controls. Specifically, this function is used in
      // the CurveLegend::CurveLegendAccessibleObject.Navigate function.
   public private:
      AccessibleObject* NavigateFromChild(CurveLegend::CurveLegendAccessibleObject* child,
         AccessibleNavigation navdir) {
            switch(navdir) {
                    case AccessibleNavigation::Down:
                    case AccessibleNavigation::Next:
                       return GetChild(child->ID + 1);

                    case AccessibleNavigation::Up:
                    case AccessibleNavigation::Previous:
                       return GetChild(child->ID - 1);
            }
            return 0;
         }

         // Helper function that is used by the CurveLegend's accessibility object
         // to select a specific CurveLegend control. Specifically, this function is used
         // in the CurveLegend::CurveLegendAccessibleObject.Select function.
         void SelectChild(CurveLegend::CurveLegendAccessibleObject* child, AccessibleSelection selection) {
            int childID = child->ID;

            // Determine which selection action should occur, based on the
            // AccessibleSelection value.
            if ((selection & AccessibleSelection::TakeSelection) != 0) {
               for (int i = 0; i < chartControl->Legends->Length; i++) {
                  if (i == childID) {
                     chartControl->Legends[i]->Selected = true;
                  } else {
                     chartControl->Legends[i]->Selected = false;
                  }
               }

               // AccessibleSelection->AddSelection means that the CurveLegend will be selected.
               if ((selection & AccessibleSelection::AddSelection) != 0) {
                  chartControl->Legends[childID]->Selected = true;
               }

               // AccessibleSelection->AddSelection means that the CurveLegend will be unselected.
               if ((selection & AccessibleSelection::RemoveSelection) != 0) {
                  chartControl->Legends[childID]->Selected = false;
               }
            }
         }
   }; // class ChartControlAccessibleObject

}; // class ChartControl

public __gc class Form1 : public System::Windows::Forms::Form {
   // Test out the Chart Control.
private:
   ChartControl*  chart1;

public:
   Form1() {
      // Create a chart control and add it to the form.
      this->chart1 = new ChartControl();
      this->ClientSize = System::Drawing::Size(920, 566);
      this->chart1->Location = System::Drawing::Point(47, 16);
      this->chart1->Size = System::Drawing::Size(600, 400);

      this->Controls->Add(this->chart1);
   }
}; // class Form1

[STAThread]
int main() {
   Application::Run(new Form1());
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Namespace: System.Windows.Forms

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

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

See Also

AccessibleObject Members | System.Windows.Forms Namespace

Show:
© 2014 Microsoft