class/System.Windows/System.Windows.Automation.Peers/FrameworkElementAutomationPeer.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2008 Novell, Inc. (http://www.novell.com)
  21 //
  22 // Contact:
  23 //   Moonlight Team (moonlight-list@lists.ximian.com)
  24 //
  25
  26 using System;
  27 using System.Collections.Generic;
  28 using System.Windows;
  29 using System.Windows.Automation;
  30 using System.Windows.Controls;
  31 using System.Windows.Markup;
  32 using System.Windows.Media;
  33 using System.Linq;
  34
  35 namespace System.Windows.Automation.Peers {
  36
  37         public class FrameworkElementAutomationPeer : AutomationPeer {
  38
  39                 private FrameworkElement owner;
  40
  41                 public FrameworkElementAutomationPeer (FrameworkElement owner)
  42                 {
  43                         if (owner == null)
  44                                 throw new NullReferenceException ("owner");
  45                         this.owner = owner;
  46
  47                         // Default Automation events
  48                         owner.SizeChanged += (o, s) => {
  49                                 Point location = GetLocation (owner);
  50                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.BoundingRectangleProperty,
  51                                                            new Rect (0, 0, s.PreviousSize.Width, s.PreviousSize.Height),
  52                                                            new Rect (location.X, location.Y, s.NewSize.Width, s.NewSize.Height));
  53                         };
  54
  55                         Control control = owner as Control;
  56                         if (control != null)
  57                                 control.IsEnabledChanged += (o, e) => {
  58                                         RaisePropertyChangedEvent (AutomationElementIdentifiers.IsEnabledProperty,
  59                                                                    e.OldValue,
  60                                                                    e.NewValue);
  61                                 };
  62
  63                         // SWA.AutomationProperties events
  64                         owner.AcceleratorKeyChanged += (o, e) => {
  65                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.AcceleratorKeyProperty,
  66                                                            e.OldValue,
  67                                                            e.NewValue);
  68                         };
  69                         owner.AccessKeyChanged += (o, e) => {
  70                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.AccessKeyProperty,
  71                                                            e.OldValue,
  72                                                            e.NewValue);
  73                         };
  74                         owner.AutomationIdChanged += (o, e) => {
  75                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.AutomationIdProperty,
  76                                                            e.OldValue,
  77                                                            e.NewValue);
  78                         };
  79                         owner.HelpTextChanged += (o, e) => {
  80                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.HelpTextProperty,
  81                                                            e.OldValue,
  82                                                            e.NewValue);
  83                         };
  84                         owner.IsRequiredForFormChanged += (o, e) => {
  85                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.IsRequiredForFormProperty,
  86                                                            e.OldValue,
  87                                                            e.NewValue);
  88                         };
  89                         owner.ItemStatusChanged += (o, e) => {
  90                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.ItemStatusProperty,
  91                                                            e.OldValue,
  92                                                            e.NewValue);
  93                         };
  94                         owner.ItemTypeChanged += (o, e) => {
  95                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.ItemTypeProperty,
  96                                                            e.OldValue,
  97                                                            e.NewValue);
  98                         };
  99                         // LabeledBy and Name properties are "special" because they somehow depend on each other.
 100                         owner.LabeledByChanged += (o, e) => {
 101                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.LabeledByProperty,
 102                                                            e.OldValue,
 103                                                            e.NewValue);
 104                                 // Name property
 105                                 UIElement labeledByOld = e.OldValue as UIElement;
 106                                 if (labeledByOld != null) {
 107                                         FrameworkElementAutomationPeer peer
 108                                                 = FrameworkElementAutomationPeer.CreatePeerForElement (labeledByOld) as FrameworkElementAutomationPeer;
 109                                         if (peer != null)
 110                                                 peer.NameChanged -= LabeledBy_NameChanged;
 111                                 }
 112                                 UIElement labeledByNew = e.NewValue as UIElement;
 113                                 if (labeledByNew != null) {
 114                                         FrameworkElementAutomationPeer peer
 115                                                 = FrameworkElementAutomationPeer.CreatePeerForElement (labeledByNew) as FrameworkElementAutomationPeer;
 116                                         if (peer != null)
 117                                                 peer.NameChanged += LabeledBy_NameChanged;
 118                                 }
 119                                 RaiseNameChanged ();
 120                         };
 121                         owner.NameChanged += (o, e) => RaiseNameChanged ();
 122                 }
 123
 124                 public UIElement Owner {
 125                         get { return owner; }
 126                 }
 127
 128                 protected override string GetNameCore ()
 129                 {
 130                         return owner.GetValue (AutomationProperties.NameProperty) as string ?? string.Empty;
 131                 }
 132
 133                 protected override string GetItemTypeCore ()
 134                 {
 135                         return owner.GetValue (AutomationProperties.ItemTypeProperty) as string ?? string.Empty;
 136                 }
 137
 138                 protected override AutomationPeer GetLabeledByCore ()
 139                 {
 140                         UIElement labeledBy = owner.GetValue (AutomationProperties.LabeledByProperty) as UIElement;
 141                         if (labeledBy != null)
 142                                 return FrameworkElementAutomationPeer.CreatePeerForElement (labeledBy);
 143                         else
 144                                 return null;
 145                 }
 146
 147                 protected override List<AutomationPeer> GetChildrenCore ()
 148                 {
 149                         return ChildrenCore;
 150                 }
 151
 152                 public override object GetPattern (PatternInterface pattern)
 153                 {
 154                         return null;
 155                 }
 156
 157                 public static AutomationPeer FromElement (UIElement element)
 158                 {
 159                         if (element == null)
 160                                 throw new ArgumentNullException ("element");
 161                         return element.AutomationPeer;
 162                 }
 163
 164                 protected override string GetAcceleratorKeyCore ()
 165                 {
 166                         return owner.GetValue (AutomationProperties.AcceleratorKeyProperty) as string ?? string.Empty;
 167                 }
 168
 169                 protected override string GetAccessKeyCore ()
 170                 {
 171                         return owner.GetValue (AutomationProperties.AccessKeyProperty) as string ?? string.Empty;
 172                 }
 173
 174                 protected override AutomationControlType GetAutomationControlTypeCore ()
 175                 {
 176                         // Some Peers don't override GetAutomationControlTypeCore and return something different to Custom
 177                         // for example: TextBoxAutomationPeer
 178                         return AutomationControlTypeCore.HasValue ? AutomationControlTypeCore.Value : AutomationControlType.Custom;
 179                 }
 180
 181                 protected override string GetAutomationIdCore ()
 182                 {
 183                         return owner.GetValue (AutomationProperties.AutomationIdProperty) as string ?? string.Empty;
 184                 }
 185
 186                 protected override Rect GetBoundingRectangleCore ()
 187                 {
 188                         if (VisualTreeHelper.GetParent (owner) == null)
 189                                 return new Rect (0, 0, 0, 0);
 190
 191                         return GetBoundingRectangleFrom (owner);
 192                 }
 193
 194                 protected override string GetClassNameCore ()
 195                 {
 196                         return ClassNameCore ?? string.Empty;
 197                 }
 198
 199                 protected override Point GetClickablePointCore ()
 200                 {
 201                         return new Point (0, 0);
 202                 }
 203
 204                 protected override string GetHelpTextCore ()
 205                 {
 206                         return owner.GetValue (AutomationProperties.HelpTextProperty) as string ?? string.Empty;
 207                 }
 208
 209                 protected override string GetItemStatusCore ()
 210                 {
 211                         return owner.GetValue (AutomationProperties.ItemStatusProperty) as string ?? string.Empty;
 212                 }
 213
 214                 protected override string GetLocalizedControlTypeCore ()
 215                 {
 216                         // LAMESPEC: http://msdn.microsoft.com/en-us/library/ms743581.aspx
 217                         // "CamelCase" literal values should be "camel case", not "camelcase"
 218                         return GetAutomationControlType ().ToString ().ToLower ();
 219                 }
 220
 221                 protected override AutomationOrientation GetOrientationCore ()
 222                 {
 223                         return AutomationOrientation.None;
 224                 }
 225
 226                 protected override bool HasKeyboardFocusCore ()
 227                 {
 228                         return owner == System.Windows.Input.FocusManager.GetFocusedElement ();
 229                 }
 230
 231                 protected override bool IsContentElementCore ()
 232                 {
 233                         return true;
 234                 }
 235
 236                 protected override bool IsControlElementCore ()
 237                 {
 238                         return true;
 239                 }
 240
 241                 protected override bool IsEnabledCore ()
 242                 {
 243                         Control ownerAsControl = owner as Control;
 244                         if (ownerAsControl != null)
 245                                 return ownerAsControl.IsEnabled;
 246
 247                         // Fall back to default value
 248                         return true;
 249                 }
 250
 251                 protected override bool IsKeyboardFocusableCore ()
 252                 {
 253                         return false;
 254                 }
 255
 256                 protected override bool IsOffscreenCore ()
 257                 {
 258                         return false;
 259                 }
 260
 261                 protected override bool IsPasswordCore ()
 262                 {
 263                         return PasswordCore;
 264                 }
 265
 266                 protected override bool IsRequiredForFormCore ()
 267                 {
 268                         bool? isRequired = (bool?) owner.GetValue (AutomationProperties.IsRequiredForFormProperty);
 269                         return isRequired.HasValue ? isRequired.Value : false;
 270                 }
 271
 272                 protected override void SetFocusCore ()
 273                 {
 274                         Control ownerAsControl = owner as Control;
 275                         if (ownerAsControl != null)
 276                                 ownerAsControl.Focus ();
 277                 }
 278
 279                 public static AutomationPeer CreatePeerForElement (UIElement element)
 280                 {
 281                         if (element == null)
 282                                 throw new ArgumentNullException ("element");
 283                         if (element.AutomationPeer == null) {
 284                                 element.AutomationPeer = element.CreateAutomationPeer ();
 285                                 // We need to cache old values to raise PropertyChanged events
 286                                 // when calling AutomationPeer.InvalidatePeer()
 287                                 if (element.AutomationPeer != null)
 288                                         element.AutomationPeer.CacheMainProperties ();
 289                         }
 290                         return element.AutomationPeer;
 291                 }
 292
 293                 internal override AutomationPeer GetParentCore ()
 294                 {
 295                         return GetParentPeer (owner);
 296                 }
 297
 298                 #region Private Methods
 299
 300                 private AutomationPeer GetParentPeer (FrameworkElement element)
 301                 {
 302                         // We are returning parents of children already instantiated.
 303                         if (element == null)
 304                                 return null;
 305
 306                         FrameworkElement parent = VisualTreeHelper.GetParent (element) as FrameworkElement;
 307                         if (parent == null)
 308                                 return null;
 309
 310                         // Some parents don't return an Automation Peer (for example: Border or Panel subclasses)
 311                         // We need to create the Peer because some Peers return children that don't
 312                         // necesarily return this peer when calling GetParent
 313                         // (for example: ListBox when Template is not null)
 314                         AutomationPeer peer = FrameworkElementAutomationPeer.CreatePeerForElement (parent);
 315                         if (peer == null)
 316                                 return GetParentPeer (parent);
 317                         else
 318                                 return peer;
 319                 }
 320
 321                 #endregion
 322
 323                 #region Internal properties
 324
 325                 // Internal properties used by Peers that don't override XXXXCore and return something else
 326                 // than FrameworkElementAutomationPeer's default value.
 327
 328                 internal virtual AutomationControlType? AutomationControlTypeCore {
 329                         get { return null; }
 330                 }
 331
 332                 internal virtual string ClassNameCore {
 333                         get { return null; }
 334                 }
 335
 336                 internal virtual List<AutomationPeer> ChildrenCore {
 337                         get { return GetChildrenRecursively (owner); }
 338                 }
 339
 340                 internal virtual bool PasswordCore {
 341                         get { return false; }
 342                 }
 343
 344                 #endregion
 345
 346                 #region Internal methods
 347
 348                 internal static List<AutomationPeer> GetChildrenRecursively (UIElement uielement)
 349                 {
 350                         List<AutomationPeer> children = new List<AutomationPeer> ();
 351                         int childrenCount = VisualTreeHelper.GetChildrenCount (uielement);
 352
 353                         for (int child = 0; child < childrenCount; child++) {
 354                                 UIElement element = VisualTreeHelper.GetChild (uielement, child) as UIElement;
 355                                 if (element == null)
 356                                         continue;
 357
 358                                 AutomationPeer peer
 359                                         = FrameworkElementAutomationPeer.CreatePeerForElement (element);
 360                                 if (peer != null)
 361                                         children.Add (peer);
 362                                 else {
 363                                         List<AutomationPeer> returnedChildren
 364                                                 = GetChildrenRecursively (element);
 365                                         if (returnedChildren != null)
 366                                                 children.AddRange (returnedChildren);
 367                                 }
 368                         }
 369
 370                         if (children.Count == 0)
 371                                 return null;
 372
 373                         return children;
 374                 }
 375
 376                 internal Point GetLocation (FrameworkElement owner)
 377                 {
 378                         if (VisualTreeHelper.GetParent (owner) == null)
 379                                 return new Point (0, 0);
 380
 381                         Point point = new Point (0, 0);
 382                         try {
 383                                 // This happens when an item is not visible yet but exists, for
 384                                 // example ListBoxItems in ComboBox when Template is not null
 385                                 point = owner.TransformToVisual (Application.Current.RootVisual).Transform (new Point ());
 386                         } catch (ArgumentException) { }
 387
 388                         return point;
 389                 }
 390
 391                 internal Rect GetBoundingRectangleFrom (FrameworkElement owner)
 392                 {
 393                         Point location = GetLocation (owner);
 394
 395                         double width = (double) owner.GetValue (FrameworkElement.WidthProperty);
 396                         double height = (double) owner.GetValue (FrameworkElement.HeightProperty);
 397
 398                         if (double.IsNaN (width))
 399                                 width = 0;
 400                         if (double.IsNaN (height))
 401                                 height = 0;
 402
 403                         // Some Controls may not be honoring the specified Height or Width and would
 404                         // use a different value, that's why we need to test these properties too,
 405                         // Examples of those Controls are TextBlock and Image.
 406                         if (height == 0)
 407                                 height = (double) owner.GetValue (FrameworkElement.ActualHeightProperty);
 408                         if (width == 0)
 409                                 width = (double) owner.GetValue (FrameworkElement.ActualWidthProperty);
 410
 411                         return new Rect (location.X, location.Y, width, height);
 412                 }
 413
 414                 internal event EventHandler NameChanged;
 415
 416                 private void LabeledBy_NameChanged (object sender, EventArgs args)
 417                 {
 418                         RaiseNameChanged ();
 419                 }
 420
 421                 // Raises UIA Event (NameProperty) and internal event (NameChanged)
 422                 // NOTE: This method MUST BE called by AutomationPeers overriding GetNameCore().
 423                 internal override void RaiseNameChanged ()
 424                 {
 425                         IAutomationCacheProperty cachedProperty
 426                                 = GetCachedProperty (AutomationElementIdentifiers.NameProperty);
 427                         string newValue = GetName ();
 428                         if (!object.Equals (newValue, cachedProperty.OldValue)) {
 429                                 RaisePropertyChangedEvent (AutomationElementIdentifiers.NameProperty,
 430                                                            cachedProperty.OldValue,
 431                                                            newValue);
 432                                 if (NameChanged != null)
 433                                         NameChanged (this, EventArgs.Empty);
 434                         }
 435
 436                 }
 437
 438                 #endregion
 439         }
 440
 441 }