Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

AccessibleObject classe

 

Date de publication : novembre 2016

Fournit des informations utilisées par les applications d’accessibilité pour adapter l’interface utilisateur d’une application aux personnes présentant un handicap.

Espace de noms:   System.Windows.Forms
Assembly:  System.Windows.Forms (dans System.Windows.Forms.dll)


[ComVisibleAttribute(true)]
public class AccessibleObject : StandardOleMarshalObject, IReflect, 
	IAccessible

NomDescription
System_CAPS_pubmethodAccessibleObject()

Initialise une nouvelle instance de la classe AccessibleObject.

NomDescription
System_CAPS_pubpropertyBounds

Obtient l'emplacement et la taille de l'objet accessible.

System_CAPS_pubpropertyDefaultAction

Obtient une chaîne qui décrit l’action par défaut de l’objet. Les objets n'ont pas tous une action par défaut.

System_CAPS_pubpropertyDescription

Obtient une chaîne qui décrit l’apparence visuelle de l’objet spécifié. Pas tous les objets ont une description.

System_CAPS_pubpropertyHelp

Obtient une description de ce que fait l’objet ou comment il est utilisé.

System_CAPS_pubpropertyKeyboardShortcut

Obtient la touche de raccourci ou d’une clé d’accès de l’objet accessible.

System_CAPS_pubpropertyName

Obtient ou définit le nom de l'objet.

System_CAPS_pubpropertyParent

Obtient le parent d'un objet accessible.

System_CAPS_pubpropertyRole

Obtient le rôle de l'objet accessible.

System_CAPS_pubpropertyState

Obtient l’état de l’objet accessible.

System_CAPS_pubpropertyValue

Obtient ou définit la valeur d’un objet accessible.

NomDescription
System_CAPS_pubmethodCreateObjRef(Type)

Crée un objet qui contient toutes les informations requises pour générer un proxy permettant de communiquer avec un objet distant.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodDoDefaultAction()

Effectue l’action par défaut associée à cet objet accessible.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodGetChild(Int32)

Récupère l’enfant accessible correspondant à l’index spécifié.

System_CAPS_pubmethodGetChildCount()

Récupère le nombre d’enfants qui appartiennent à un objet accessible.

System_CAPS_pubmethodGetFocused()

Récupère l’objet qui a le focus clavier.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetHelpTopic(String)

Obtient un identificateur pour un identificateur de rubrique d’aide et le chemin d’accès au fichier d’aide associé à cet objet accessible.

System_CAPS_pubmethodGetLifetimeService()

Récupère l’objet de service de durée de vie actuelle qui contrôle la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodGetSelected()

Récupère l’enfant actuellement sélectionné.

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodHitTest(Int32, Int32)

Récupère l'objet enfant qui est situé aux coordonnées d'écran spécifiées.

System_CAPS_pubmethodInitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Crée une copie superficielle d’actuel MarshalByRefObject objet.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodNavigate(AccessibleNavigation)

Navigue vers un autre objet accessible.

System_CAPS_pubmethodSelect(AccessibleSelection)

Modifie la sélection ou déplace le focus clavier de l’objet accessible.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodUseStdAccessibleObjects(IntPtr)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Associe un objet à une instance d’un AccessibleObject basé sur le handle de l’objet.

System_CAPS_protmethodUseStdAccessibleObjects(IntPtr, Int32)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Associe un objet à une instance d’un AccessibleObject basé sur le handle et l’id d’objet de l’objet.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIAccessible.accDoDefaultAction(Object)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Effectue l’action par défaut de l’objet spécifié. Les objets n'ont pas tous une action par défaut. Pour obtenir une description de ce membre, consultez IAccessible.accDoDefaultAction.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIAccessible.accHitTest(Int32, Int32)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient l’objet enfant situé aux coordonnées d’écran spécifiées. Pour obtenir une description de ce membre, consultez IAccessible.accHitTest.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIAccessible.accLocation(Int32, Int32, Int32, Int32, Object)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient l’emplacement d’affichage de l’objet actuel. Pour obtenir une description de ce membre, consultez IAccessible.accLocation.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIAccessible.accNavigate(Int32, Object)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Navigue vers un objet accessible par rapport à l’objet actuel. Pour obtenir une description de ce membre, consultez IAccessible.accNavigate.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIAccessible.accSelect(Int32, Object)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Modifie la sélection ou déplace le focus clavier de l’objet accessible. Pour obtenir une description de ce membre, consultez IAccessible.accSelect.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetField(String, BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient le System.Reflection.FieldInfo de l’objet correspondant au champ spécifié et l’indicateur de liaison. Pour obtenir une description de ce membre, consultez IReflect.GetField.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetFields(BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un tableau de System.Reflection.FieldInfo objets correspondant à tous les champs de la classe actuelle. Pour obtenir une description de ce membre, consultez IReflect.GetFields.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetMember(String, BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un tableau de System.Reflection.MemberInfo objets correspondant à tous les membres publics ou à tous les membres qui correspondent à un nom spécifié. Pour obtenir une description de ce membre, consultez IReflect.GetMember.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetMembers(BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un tableau de System.Reflection.MemberInfo objets correspondant à tous les membres publics ou à tous les membres de la classe actuelle. Pour obtenir une description de ce membre, consultez IReflect.GetMembers.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetMethod(String, BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un System.Reflection.MethodInfo objet correspondant à une méthode spécifiée avec spécifié les contraintes de recherche. Pour obtenir une description de ce membre, consultez IReflect.GetMethod.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un System.Reflection.MethodInfo objet correspondant à une méthode spécifiée, à l’aide d’un tableau de Type choisir à partir de votre des méthodes surchargées. Pour obtenir une description de ce membre, consultez IReflect.GetMethod.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetMethods(BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un tableau de System.Reflection.MethodInfo objets avec toutes les méthodes publiques ou toutes les méthodes de la classe actuelle. Pour obtenir une description de ce membre, consultez IReflect.GetMethods.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetProperties(BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un tableau de System.Reflection.PropertyInfo objets correspondant à toutes les propriétés publiques ou à toutes les propriétés de la classe actuelle. Pour obtenir une description de ce membre, consultez IReflect.GetProperties.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetProperty(String, BindingFlags)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un System.Reflection.PropertyInfo objet correspondant à une propriété spécifiée avec spécifié les contraintes de recherche. Pour obtenir une description de ce membre, consultez IReflect.GetProperty.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient un System.Reflection.PropertyInfo objet correspondant à une propriété spécifiée avec spécifié les contraintes de recherche. Pour obtenir une description de ce membre, consultez IReflect.GetProperty.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflect.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Appelle un membre spécifié. Pour obtenir une description de ce membre, consultez IReflect.InvokeMember.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAccessible.accChildCount

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient le nombre d’interfaces enfants qui appartiennent à cet objet. Pour obtenir une description de ce membre, consultez IAccessible.accChildCount.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAccessible.accFocus

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient l’objet qui a le focus clavier. Pour obtenir une description de ce membre, consultez IAccessible.accFocus.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAccessible.accParent

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient le parent un objet accessible de cet objet. Pour obtenir une description de ce membre, consultez IAccessible.accParent.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAccessible.accSelection

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient l’enfant sélectionné les objets d’un objet accessible. Pour obtenir une description de ce membre, consultez IAccessible.accSelection.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReflect.UnderlyingSystemType

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Obtient le type sous-jacent qui représente le IReflect objet. Pour obtenir une description de ce membre, consultez IReflect.UnderlyingSystemType.

Les applications d’accessibilité peuvent ajuster des fonctionnalités de l’application pour améliorer la facilité d’utilisation pour les utilisateurs présentant un handicap.

Pour les utilisateurs malvoyants, vous pouvez ajuster les fonctionnalités de système d’exploitation et logiciels pour répondre à leurs besoins. Par exemple, vous pouvez agrandir le texte et les images et les afficher avec un contraste. En outre, vous pouvez gérer color-blindness avec l’utilisation appropriée de couleurs. Pour les utilisateurs gravement malvoyants, les ordinateurs sont accessibles à l’aide d’Assistants qui convertissent les à l’écran texte vocale ou un affichage Braille dynamique et actualisable.

Pour les utilisateurs qui sont malentendants, vous pouvez concevoir des programmes qui utilisent des signaux visuels, comme une barre d’outils clignotante ; ou bien, vous pouvez afficher les messages verbaux sous forme de texte. Par exemple, le cas d’activation, le SoundSentry fournit des fonctionnalités, une option d’accessibilité dans le panneau de configuration, un avertissement visuel chaque fois que le système émet une alarme sonore.

Pour les utilisateurs présentant un handicap de mouvement, vous pouvez concevoir des contrôles qui restreignent ou éliminent l’utilisation du clavier et de la souris, ce qui améliore l’accessibilité de l’ordinateur. Le panneau de configuration offre une assistance. Par exemple, une solution consiste à utiliser le pavé numérique au lieu de la souris pour la navigation. Une autre option, appelée StickyKeys, permet aux utilisateurs qui ne peut pas contenir deux ou plusieurs touches enfoncées à la fois (par exemple, CTRL + P) pour obtenir le même résultat en tapant une clé à la fois.

Pour les utilisateurs avec cognitifs et d’une incapacité physique de la langue, vous pouvez concevoir des programmes afin de mieux répondre à leurs besoins. Par exemple, à l’aide de la mise en séquence apparent ou signalisé, écrans, moins de mots et un niveau de lecture ciblé scolaire bénéficient ces utilisateurs.

Pour les utilisateurs sujets à, vous pouvez concevoir des logiciels qui éliminent préhension.

Pour plus d’informations sur l’accessibilité, notamment des informations sur les applications d’accessibilité, consultez la documentation Microsoft Accessibility dans MSDN library ou sur le site Web de Microsoft.

System_CAPS_noteRemarque

Pour utiliser le AccessibleObject, vous devez ajouter une référence à la Accessibility assembly installé avec le .NET Framework. Windows Forms prend uniquement en charge Active Accessibility 2.0.

Remarques à l’attention des héritiers :

Lorsque vous héritez de cette classe, vous pouvez remplacer tous les membres.

L’exemple de code suivant illustre la création d’un graphique prenant en charge d’accessibilité de contrôle, à l’aide de la AccessibleObject et Control.ControlAccessibleObject classes à exposer des informations accessibles. Le contrôle trace deux courbes avec une légende. Le ChartControlAccessibleObject (classe), qui dérive de ControlAccessibleObject, est utilisé dans le CreateAccessibilityInstance méthode pour fournir des informations accessibles personnalisées pour le contrôle chart. Étant donné que la légende du graphique n’est pas un réel Control -en fonction de contrôle, mais qu’elle est plutôt dessinée par le contrôle chart, il n’a pas d’informations accessibles intégrées. Pour cette raison, le ChartControlAccessibleObject substitue le GetChild méthode pour retourner le CurveLegendAccessibleObject qui représente des informations accessibles pour chaque partie de la légende. Lorsqu’une application prenant en charge accessible utilise ce contrôle, le contrôle peut fournir les informations accessibles nécessaires.

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);
                }
            }
        }
    }
}

.NET Framework
Disponible depuis 1.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: