This documentation is archived and is not being maintained.

AccessibleObject Class

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

Namespace: System.Windows.Forms
Assembly: System.Windows.Forms (in system.windows.forms.dll)

[ComVisibleAttribute(true)] 
public ref class AccessibleObject : public StandardOleMarshalObject, IReflect, IAccessible
/** @attribute ComVisibleAttribute(true) */ 
public class AccessibleObject extends StandardOleMarshalObject implements IReflect, IAccessible
ComVisibleAttribute(true) 
public class AccessibleObject extends StandardOleMarshalObject implements IReflect, IAccessible
Not applicable.

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 more information about accessibility, including information about accessibility applications, see the documentation for Microsoft Accessibility in the MSDN library or at the Microsoft Web site.

NoteNote:

To use the AccessibleObject, you must add a reference to the Accessibility assembly installed with the .NET Framework. Windows Forms only supports Active Accessibility 2.0.

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

The following code 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. Because the chart legend is not an actual Control -based control, but instead is drawn by the chart control, it does not have 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.

#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 ref class ChartControl: public System::Windows::Forms::UserControl
{
public:
   ref class ChartControlAccessibleObject;

   // forward declaration
   // Inner Class that represents a legend for a curve in the chart.
   ref class CurveLegend
   {

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

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


      private:

         property ChartControlAccessibleObject^ ChartControl 
         {

            // Private property that helps get the reference to the parent ChartControl.
            ChartControlAccessibleObject^ get()
            {
               return dynamic_cast<ChartControlAccessibleObject^>(Parent);
            }

         }

      internal:

         property int ID 
         {

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

               }
               return  -1;
            }

         }

      public:

         property Rectangle Bounds 
         {

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

         }

         property String^ Name 
         {

            // Gets or sets the Name for the CurveLegend. This is used by accessibility programs.
            virtual String^ get() override
            {
               return curveLegend->Name;
            }

            virtual void set( String^ value ) override
            {
               curveLegend->Name = value;
            }

         }

         property AccessibleObject^ Parent 
         {

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

         }

         property System::Windows::Forms::AccessibleRole Role 
         {

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

         }

         property AccessibleStates State 
         {

            // Gets the state based on the selection for the CurveLegend.
            // This is used by accessibility programs.
            virtual AccessibleStates get() override
            {
               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.
         virtual AccessibleObject^ Navigate( AccessibleNavigation navdir ) override
         {
            
            // 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.
         virtual void Select( AccessibleSelection selection ) override
         {
            
            // Uses the internal SelectChild helper function that exists
            // on ChartControlAccessibleObject.
            ChartControl->SelectChild( this, selection );
         }

      };


   private:

      // class CurveLgendAccessibleObject
      String^ name;
      ChartControl^ chart;
      CurveLegendAccessibleObject^ accObj;
      bool selected;
      Point location;

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


      property AccessibleObject^ AccessibilityObject 
      {

         // Gets the accessibility object for the curve legend.
         AccessibleObject^ get()
         {
            if ( accObj == nullptr )
            {
               accObj = gcnew CurveLegendAccessibleObject( this );
            }

            return accObj;
         }

      }

      property Rectangle Bounds 
      {

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

      }

      property Point Location 
      {

         // Gets or sets the location for the curve legend.
         Point get()
         {
            return location;
         }

         void set( 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 );
         }

      }

      property String^ Name 
      {

         // Gets or sets the Name for the curve legend.
         String^ get()
         {
            return name;
         }

         void set( 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 );
            }
         }

      }

      property bool Selected 
      {

         // Gets or sets the Selected state for the curve legend.
         bool get()
         {
            return selected;
         }

         void set( 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 );
            }
         }

      }

      property System::Drawing::Size Size 
      {

         // Gets the Size for the curve legend.
         System::Drawing::Size get()
         {
            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 );
         }

      }

   };


private:

   // class CurveLegend
   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 = "ChartControl";
      this->Click += gcnew System::EventHandler( this, &ChartControl::ChartControl_Click );
      this->QueryAccessibilityHelp += gcnew System::Windows::Forms::QueryAccessibilityHelpEventHandler( this, &ChartControl::ChartControl_QueryAccessibilityHelp );
      
      // The CurveLengend is not Control-based, it just
      // represents the parts of the legend.
      legend1 = gcnew CurveLegend( this,"A" );
      legend1->Location = Point(20,30);
      legend2 = gcnew CurveLegend( this,"B" );
      legend2->Location = Point(20,50);
   }



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

   virtual void OnPaint( PaintEventArgs^ e ) override
   {
      
      // 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 = gcnew StringFormat;
      format->Alignment = StringAlignment::Center;
      format->LineAlignment = StringAlignment::Center;
      if ( legend1 != nullptr )
      {
         if ( legend1->Selected )
         {
            e->Graphics->FillRectangle( gcnew 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 != nullptr )
      {
         if ( legend2->Selected )
         {
            e->Graphics->FillRectangle( gcnew 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 );
      array<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)};
      array<Point>^curve1 = temp1;
      array<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)};
      array<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.
   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
   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;
      }
   }


public:

   property array<CurveLegend^>^ Legends 
   {

      // Gets an array of CurveLengends used in the Chart.
      array<CurveLegend^>^ get()
      {
         array<CurveLegend^>^temp3 = {legend1,legend2};
         return temp3;
      }

   }

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

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


      property System::Windows::Forms::AccessibleRole Role 
      {

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

      }

      property AccessibleStates State 
      {

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

      }

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


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

         return nullptr;
      }


   internal:

      // 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.
      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 nullptr;
      }


      // 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) != (AccessibleSelection)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) != (AccessibleSelection)0 )
            {
               chartControl->Legends[ childID ]->Selected = true;
            }
            
            // AccessibleSelection->AddSelection means that the CurveLegend will be unselected.
            if ( (selection & AccessibleSelection::RemoveSelection) != (AccessibleSelection)0 )
            {
               chartControl->Legends[ childID ]->Selected = false;
            }
         }
      }

   };

   // class ChartControlAccessibleObject
};


// class ChartControl
public ref class Form1: public System::Windows::Forms::Form
{
private:

   // Test out the Chart Control.
   ChartControl^ chart1;

public:
   Form1()
   {
      
      // Create a chart control and add it to the form.
      this->chart1 = gcnew 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( gcnew Form1 );
}


package ChartControl;

import System.*;
import System.Drawing.*;
import System.Windows.Forms.*;

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

    /** @attribute STAThread()
     */
    public static void main(String[] args)
    {
        Application.Run(new Form1());
    } //main

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

        this.chart1.set_Location(new System.Drawing.Point(47, 16));
        this.chart1.set_Size(new System.Drawing.Size(600, 400));
        this.get_Controls().Add(this.chart1);
    } //Form1
} //Form1

// Declare a chart control that demonstrates accessibility in Windows Forms.
public class ChartControl extends 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.set_BackColor(System.Drawing.Color.get_White());
        this.set_Name("ChartControl");
        this.add_Click(new System.EventHandler(this.ChartControl_Click));
        this.add_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.set_Location(new Point(20, 30));
        legend2 = new CurveLegend(this, "B");
        legend2.set_Location(new Point(20, 50));
    } //ChartControl

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

    protected void OnPaint(PaintEventArgs e)
    {
        // The ChartControl draws the chart in the OnPaint override.
        super.OnPaint(e);
        Rectangle bounds = this.get_ClientRectangle();
        int border = 5;
        // Draws the legends first.
        StringFormat format = new StringFormat();
        format.set_Alignment(StringAlignment.Center);
        format.set_LineAlignment(StringAlignment.Center);

        if (legend1 != null) {
            if (legend1.get_Selected()) {
                e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Blue()),
                    legend1.get_Bounds());
            }
            else {
                e.get_Graphics().DrawRectangle(Pens.get_Blue(), 
                    legend1.get_Bounds());
            }
            e.get_Graphics().DrawString(legend1.get_Name(), this.get_Font(), 
                Brushes.get_Black(), 
                RectangleF.op_Implicit(legend1.get_Bounds()), format);
        }
        if (legend2 != null) {
            if (legend2.get_Selected()) {
                e.get_Graphics().FillRectangle(new SolidBrush(Color.get_Red()), 
                    legend2.get_Bounds());
            }
            else {
                e.get_Graphics().DrawRectangle(Pens.get_Red(),
                    legend2.get_Bounds());
            }
            e.get_Graphics().DrawString(legend2.get_Name(), this.get_Font(),
                Brushes.get_Black(), 
                RectangleF.op_Implicit(legend2.get_Bounds()), format);
        }

        // Charts out the actual curves that represent data in the Chart.
        bounds.Inflate(-border, -border);
        Point curve1[] = new Point[] { new Point(bounds.get_Left(), 
            bounds.get_Bottom()), 
            new Point(bounds.get_Left() + bounds.get_Width() / 3,
            bounds.get_Top() + bounds.get_Height() / 5), 
            new Point(bounds.get_Right() - bounds.get_Width() / 3, 
            (bounds.get_Top() + bounds.get_Bottom()) / 2), 
            new Point(bounds.get_Right(), bounds.get_Top()) };

        Point curve2[] = new Point[] { new Point(bounds.get_Left(), 
            bounds.get_Bottom() - bounds.get_Height() / 3), 
            new Point(bounds.get_Left() + bounds.get_Width() / 3, 
            bounds.get_Top() + bounds.get_Height() / 5), 
            new Point(bounds.get_Right() - bounds.get_Width() / 3, 
            (bounds.get_Top() + bounds.get_Bottom()) / 2), 
            new Point(bounds.get_Right(), 
            bounds.get_Top() + bounds.get_Height() / 2) };

        // Draws the actual curve only if it is selected.
        if (legend1.get_Selected()) {
            e.get_Graphics().DrawCurve(Pens.get_Blue(), curve1);
        }
        if (legend2.get_Selected()) {
            e.get_Graphics().DrawCurve(Pens.get_Red(), curve2);
        }
        e.get_Graphics().DrawRectangle(Pens.get_Blue(), bounds);
    } //OnPaint

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

    // 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.get_MousePosition());
        if (legend1.get_Bounds().Contains(pt)) {
            legend1.set_Selected(!(legend1.get_Selected()));
        }
        else {
            if (legend2.get_Bounds().Contains(pt)) {
                legend2.set_Selected(!(legend2.get_Selected()));
            }
        }
    } //ChartControl_Click

    // Gets an array of CurveLengends used in the Chart.
    /** @property 
     */
    public CurveLegend[] get_Legends()
    {
        return new CurveLegend[] { legend1, legend2 };
    } //get_Legends

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

        public ChartControlAccessibleObject(ChartControl ctrl)
        {
            super(ctrl);
            chartControl = ctrl;
        } //ChartControlAccessibleObject

        // Gets the role for the Chart. This is used by accessibility programs.
        /** @property 
         */
        public AccessibleRole get_Role()
        {
            return AccessibleRole.Chart;
        } //get_Role

        // Gets the state for the Chart. This is used by accessibility programs.
        /** @property 
         */
        public AccessibleStates get_State()
        {
            return AccessibleStates.ReadOnly;
        } //get_State

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

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

        // 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.
        AccessibleObject NavigateFromChild(
            CurveLegend.CurveLegendAccessibleObject child, 
            AccessibleNavigation navDir)
        {
            if (navDir.Equals(AccessibleNavigation.Down) 
                || navDir.Equals(AccessibleNavigation.Next)) {
                return GetChild(child.get_ID() + 1);
            }
            else {
                if (navDir.Equals(AccessibleNavigation.Up) 
                    || navDir.Equals(AccessibleNavigation.Previous)) {
                    return GetChild(child.get_ID() - 1);
                }
            }
            return null;
        } //NavigateFromChild

        // 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.
        public void SelectChild(CurveLegend.CurveLegendAccessibleObject child, 
            AccessibleSelection selection)
        {
            int childID = child.get_ID();

            // Determine which selection action should occur, based on the
            // AccessibleSelection value.
            if (Convert.ToInt32(selection & AccessibleSelection.TakeSelection)
                != 0) {
                for (int i = 0; i < chartControl.get_Legends().get_Length(); 
                    i++) {
                    if (i == childID) {
                        ((CurveLegend)chartControl.get_Legends().get_Item(i)).
                            set_Selected(true);
                    }
                    else {
                        ((CurveLegend)chartControl.get_Legends().get_Item(i)).
                            set_Selected(false);
                    }
                }

                // AccessibleSelection.AddSelection means that the CurveLegend 
                // will be selected.
                if (Convert.ToInt32(selection & AccessibleSelection.AddSelection)
                    != 0) {
                    ((CurveLegend)chartControl.get_Legends().get_Item(childID)).
                        set_Selected(true);
                }

                // AccessibleSelection.AddSelection means that the CurveLegend 
                // will be unselected.
                if (Convert.ToInt32(selection & 
                    AccessibleSelection.RemoveSelection) != 0) {
                    ((CurveLegend)chartControl.get_Legends().get_Item(childID)).
                        set_Selected(false);
                }
            }
        } //SelectChild
    } //ChartControlAccessibleObject

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

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

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

        // Gets the bounds for the curve legend.
        /** @property 
         */
        public Rectangle get_Bounds()
        {
            return new Rectangle(get_Location(), get_Size());
        } //get_Bounds

        // Gets or sets the location for the curve legend.
        /** @property 
         */
        public Point get_Location()
        {
            return location;
        } //get_Location

        /** @property 
         */
        public 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, 
                ((CurveLegendAccessibleObject)get_AccessibilityObject()).
                get_ID());
        } //set_Location

        // Gets or sets the Name for the curve legend.
        /** @property 
         */
        public String get_Name()
        {
            return name;
        } //get_Name

        /** @property 
         */
        public void set_Name(String value)
        {
            if (!name.Equals(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)get_AccessibilityObject()).
                    get_ID());
            }
        } //set_Name

        // Gets or sets the Selected state for the curve legend.
        /** @property 
         */
        public boolean get_Selected()
        {
            return selected;
        } //get_Selected

        /** @property 
         */
        public void set_Selected(boolean 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, 
                    ((CurveLegendAccessibleObject)get_AccessibilityObject()).
                    get_ID());
            }
        } //set_Selected

        // Gets the Size for the curve legend.
        /** @property 
         */
        public Size get_Size()
        {
            int legendHeight = chart.get_Font().get_Height() + 4;
            Graphics g = chart.CreateGraphics();
            int legendWidth = (int)(g.MeasureString(get_Name(), 
                chart.get_Font()).get_Width()) + 4;

            return new Size(legendWidth, legendHeight);
        } //get_Size

        // Inner class CurveLegendAccessibleObject represents accessible 
        // information associated with the CurveLegend object.
        public static class CurveLegendAccessibleObject extends AccessibleObject
        {
            private CurveLegend curveLegend;

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

            // Private property that helps get the reference to the parent 
            // ChartControl.
            /** @property 
             */
            private ChartControlAccessibleObject get_ChartControl()
            {
                return (ChartControlAccessibleObject)get_Parent();
            } //get_ChartControl

            // Internal helper function that returns the ID for this CurveLegend.
            /** @property 
             */
            int get_ID()
            {
                for (int i = 0; i < get_ChartControl().GetChildCount(); i++) {
                    if (get_ChartControl().GetChild(i).Equals(this)) {
                        return i;
                    }
                }
                return -1;
            } //get_ID

            // Gets the Bounds for the CurveLegend. 
            // This is used by accessibility programs.
            /** @property 
             */
            public Rectangle get_Bounds()
            {
                // The bounds is in screen coordinates.
                Point loc = curveLegend.get_Location();
                return new Rectangle(curveLegend.chart.PointToScreen(loc),
                    curveLegend.get_Size());
            } //get_Bounds

            // Gets or sets the Name for the CurveLegend. 
            // This is used by accessibility programs.
            /** @property 
             */
            public String get_Name()
            {
                return curveLegend.get_Name();
            } //get_Name

            /** @property 
             */
            public void set_Name(String value)
            {
                curveLegend.set_Name(value);
            } //set_Name

            // Gets the Curve Legend Parent's Accessible object.
            // This is used by accessibility programs.
            /** @property 
             */
            public AccessibleObject get_Parent()
            {
                return curveLegend.chart.get_AccessibilityObject();
            } //get_Parent

            // Gets the role for the CurveLegend. 
            // This is used by accessibility programs.
            /** @property 
             */
            public AccessibleRole get_Role()
            {
                return AccessibleRole.StaticText;
            } //get_Role

            // Gets the state based on the selection for the CurveLegend. 
            // This is used by accessibility programs.
            /** @property 
             */
            public AccessibleStates get_State()
            {
                AccessibleStates state = AccessibleStates.Selectable;
                if (curveLegend.get_Selected()) {
                    state = state | AccessibleStates.Selected;
                }
                return state;
            } //get_State

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

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

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 CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, 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
Show: