class/System.Windows/System.Windows/FrameworkElement.cs

   1 //
   2 // FrameworkElement.cs
   3 //
   4 // Contact:
   5 //   Moonlight List (moonlight-list@lists.ximian.com)
   6 //
   7 // Copyright 2008 Novell, Inc.
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using Mono;
  30 using System.Reflection;
  31 using System.Collections.Generic;
  32 using System.Windows.Controls;
  33 using System.Windows.Data;
  34 using System.Windows.Input;
  35 using System.Windows.Markup;
  36 using System.Windows.Media;
  37 using System.Windows.Automation;
  38
  39 namespace System.Windows {
  40         public abstract partial class FrameworkElement : UIElement {
  41
  42                 static FrameworkElement ()
  43                 {
  44                         StyleProperty.Validate = delegate (DependencyObject target, DependencyProperty propety, object value) {
  45                                 Type styleType = ((Style)value).TargetType;
  46                                 if (!styleType.IsAssignableFrom (target.GetType ()))
  47                                         throw new System.Windows.Markup.XamlParseException (string.Format ("Target is of type {0} but the Style requires {1}", target.GetType ().Name, styleType.Name));
  48                         };
  49
  50                         DataContextProperty.AddPropertyChangeCallback (DataContextChanged);
  51                 }
  52
  53                 static void DataContextChanged (DependencyObject sender, DependencyPropertyChangedEventArgs args)
  54                 {
  55                         (sender as FrameworkElement).OnDataContextChanged (args.OldValue, args.NewValue);
  56                 }
  57
  58                 void OnDataContextChanged (object oldValue, object newValue)
  59                 {
  60                         InvalidateLocalBindings ();
  61                         InvalidateSubtreeBindings ();
  62                 }
  63
  64                 void InvalidateSubtreeBindings ()
  65                 {
  66                         for (int c = 0; c < VisualTreeHelper.GetChildrenCount (this); c++) {
  67                                 FrameworkElement obj = VisualTreeHelper.GetChild (this, c) as FrameworkElement;
  68                                 if (obj == null)
  69                                         continue;
  70                                 obj.InvalidateLocalBindings ();
  71                                 obj.InvalidateSubtreeBindings ();
  72                         }
  73                 }
  74
  75                 bool invalidatingLocalBindings;
  76
  77                 void InvalidateLocalBindings ()
  78                 {
  79                         if (expressions.Count == 0)
  80                                 return;
  81
  82                         if (invalidatingLocalBindings)
  83                                 return;
  84
  85                         invalidatingLocalBindings = true;
  86
  87                         Dictionary<DependencyProperty, Expression> old = expressions;
  88                         expressions = new Dictionary<DependencyProperty, Expression> ();
  89                         foreach (var keypair in old) {
  90                                 if (keypair.Value is BindingExpressionBase) {
  91                                         BindingExpressionBase beb = (BindingExpressionBase)keypair.Value;
  92                                         beb.Invalidate ();
  93                                         SetValue (keypair.Key, beb);
  94                                 }
  95                                 else if (keypair.Value is TemplateBindingExpression) {
  96                                         // we don't invalidate
  97                                         // templatebinding
  98                                         // expressions, so just add it
  99                                         // back to the expressions
 100                                         // list.
 101                                         expressions.Add (keypair.Key, keypair.Value);
 102                                 }
 103                         }
 104
 105                         invalidatingLocalBindings = false;
 106                 }
 107
 108                 public event EventHandler LayoutUpdated {
 109                         add { Deployment.Current.LayoutUpdated += value; }
 110                         remove { Deployment.Current.LayoutUpdated -= value; }
 111                 }
 112
 113
 114                 /*
 115                  * XXX these are marked internal because making them private seems
 116                  * to cause the GC to collect them
 117                  */
 118                 internal MeasureOverrideCallback measure_cb;
 119                 internal ArrangeOverrideCallback arrange_cb;
 120                 internal GetDefaultTemplateCallback get_default_template_cb;
 121                 internal LoadedCallback loaded_hook_cb;
 122
 123                 Dictionary<DependencyProperty, Expression> expressions = new Dictionary<DependencyProperty, Expression> ();
 124
 125                 private static bool UseNativeLayoutMethod (Type type)
 126                 {
 127                         return type == typeof (FrameworkElement)
 128                                 || type == typeof (Canvas)
 129                                 || type == typeof (Grid);
 130                 }
 131
 132                 bool OverridesGetDefaultTemplate ()
 133                 {
 134                         return this is ContentPresenter
 135                                 || this is ItemsPresenter
 136                                 || this is ItemsControl
 137                                 || this is ContentControl;
 138                 }
 139
 140                 private bool OverridesLayoutMethod (string name)
 141                 {
 142                         var method = GetType ().GetMethod (name, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
 143                         if (method == null)
 144                                 return false;
 145
 146                         if (!method.IsVirtual || !method.IsFamily)
 147                                 return false;
 148
 149                         if (method.ReturnType != typeof (Size))
 150                                 return false;
 151
 152                         if (UseNativeLayoutMethod (method.DeclaringType))
 153                                 return false;
 154
 155                         var parameters = method.GetParameters ();
 156                         if (parameters.Length != 1 || parameters [0].ParameterType != typeof (Size))
 157                                 return false;
 158
 159                         return true;
 160                 }
 161
 162                 private void Initialize ()
 163                 {
 164                         if (OverridesLayoutMethod ("MeasureOverride"))
 165                                 measure_cb = new MeasureOverrideCallback (InvokeMeasureOverride);
 166                         if (OverridesLayoutMethod ("ArrangeOverride"))
 167                                 arrange_cb = new ArrangeOverrideCallback (InvokeArrangeOverride);
 168                         if (OverridesGetDefaultTemplate ())
 169                                 get_default_template_cb = InvokeGetDefaultTemplate;
 170                         loaded_hook_cb = InvokeLoadedHook;
 171                         NativeMethods.framework_element_register_managed_overrides (native, measure_cb, arrange_cb, get_default_template_cb, loaded_hook_cb);
 172                 }
 173
 174                 public object FindName (string name)
 175                 {
 176                         return DepObjectFindName (name);
 177                 }
 178
 179                 internal void SetTemplateBinding (DependencyProperty dp, TemplateBindingExpression tb)
 180                 {
 181                         tb.AttachChangeHandler();
 182                         try {
 183                                 SetValue (dp, tb);
 184                         } catch {
 185                                 // Do nothing here - The DP should still have its default value
 186                         }
 187                 }
 188
 189                 public BindingExpressionBase SetBinding (DependencyProperty dp, Binding binding)
 190                 {
 191                         if (dp == null)
 192                                 throw new ArgumentNullException ("dp");
 193                         if (binding == null)
 194                                 throw new ArgumentNullException ("binding");
 195
 196                         BindingExpression e = new BindingExpression (binding, this, dp);
 197                         binding.Seal ();
 198                         SetValue (dp, e);
 199                         return e;
 200                 }
 201
 202                 protected virtual Size MeasureOverride (Size availableSize)
 203                 {
 204                         return NativeMethods.framework_element_measure_override (native, availableSize);
 205                 }
 206
 207                 protected virtual Size ArrangeOverride (Size finalSize)
 208                 {
 209                         return NativeMethods.framework_element_arrange_override (native, finalSize);
 210                 }
 211
 212                 public DependencyObject Parent {
 213                         get {
 214                                 return NativeDependencyObjectHelper.FromIntPtr (NativeMethods.framework_element_get_logical_parent (native)) as DependencyObject;
 215                         }
 216                 }
 217
 218                 internal DependencyObject SubtreeObject {
 219                         get {
 220                                 return NativeDependencyObjectHelper.FromIntPtr (NativeMethods.uielement_get_subtree_object (native)) as DependencyObject;
 221                         }
 222                 }
 223
 224                 public event EventHandler<ValidationErrorEventArgs> BindingValidationError;
 225
 226                 internal virtual void InvokeOnApplyTemplate ()
 227                 {
 228                         OnApplyTemplate ();
 229                 }
 230
 231                 internal virtual void InvokeLoaded ()
 232                 {
 233                         InvalidateLocalBindings ();
 234                         InvalidateSubtreeBindings ();
 235                 }
 236
 237                 private Size InvokeMeasureOverride (Size availableSize)
 238                 {
 239                         try {
 240                                 return MeasureOverride (availableSize);
 241                         } catch (Exception ex) {
 242                                 try {
 243                                         Console.WriteLine ("Moonlight: Unhandled exception in FrameworkElement.InvokeMeasureOverride: {0}", ex);
 244                                 } catch {
 245                                         // Ignore
 246                                 }
 247                         }
 248                         return new Size ();
 249                 }
 250
 251                 private Size InvokeArrangeOverride (Size finalSize)
 252                 {
 253                         try {
 254                                 return ArrangeOverride (finalSize);
 255                         } catch (Exception ex) {
 256                                 try {
 257                                         Console.WriteLine ("Moonlight: Unhandled exception in FrameworkElement.InvokeArrangeOverride: {0}", ex);
 258                                 } catch {
 259                                         // Ignore
 260                                 }
 261                         }
 262                         return new Size ();
 263                 }
 264
 265                 static IntPtr InvokeGetDefaultTemplate (IntPtr fwe_ptr)
 266                 {
 267                         UIElement root = null;
 268                         try {
 269                                 FrameworkElement element = (FrameworkElement) NativeDependencyObjectHelper.FromIntPtr (fwe_ptr);
 270                                 root = element.GetDefaultTemplate ();
 271                         } catch (Exception ex) {
 272                                 try {
 273                                         Console.WriteLine ("Moonlight: Unhandled exception in FrameworkElement.InvokeGetDefaultTemplate: {0}", ex);
 274                                 } catch {
 275                                         // Ignore
 276                                 }
 277                         }
 278                         return root == null ? IntPtr.Zero : root.native;
 279                 }
 280
 281                 static void InvokeLoadedHook (IntPtr fwe_ptr)
 282                 {
 283                         try {
 284                                 FrameworkElement element = (FrameworkElement) NativeDependencyObjectHelper.FromIntPtr (fwe_ptr);
 285                                 element.InvokeLoaded ();
 286                         } catch (Exception ex) {
 287                                 try {
 288                                         Console.WriteLine ("Moonlight: Unhandled exception in FrameworkElement.InvokeLoaded: {0}", ex);
 289                                 } catch {
 290                                         // Ignore
 291                                 }
 292                         }
 293                 }
 294
 295                 internal virtual UIElement GetDefaultTemplate ()
 296                 {
 297                         return null;
 298                 }
 299
 300                 public virtual void OnApplyTemplate ()
 301                 {
 302                         // according to doc this is not fully implemented since SL templates applies
 303                         // to Control/ContentPresenter and is defined here for WPF compatibility
 304                 }
 305
 306                 internal override void ClearValueImpl (DependencyProperty dp)
 307                 {
 308                         RemoveExpression (dp);
 309                         base.ClearValueImpl (dp);
 310                 }
 311
 312                 internal void RaiseBindingValidationError (ValidationErrorEventArgs e)
 313                 {
 314                         EventHandler <ValidationErrorEventArgs> h = BindingValidationError;
 315                         if (h != null)
 316                                 h (this, e);
 317                 }
 318
 319                 void RemoveExpression (DependencyProperty dp)
 320                 {
 321                         Expression e;
 322                         if (expressions.TryGetValue (dp, out e)) {
 323                                 expressions.Remove (dp);
 324                                 e.Dispose ();
 325                         }
 326                 }
 327
 328                 internal override void SetValueImpl (DependencyProperty dp, object value)
 329                 {
 330                         bool addingExpression = false;
 331                         Expression existing;
 332                         Expression expression = value as Expression;
 333                         BindingExpressionBase bindingExpression = expression as BindingExpressionBase;
 334
 335                         if (bindingExpression != null) {
 336                                 if (string.IsNullOrEmpty (bindingExpression.Binding.Path.Path) &&
 337                                     bindingExpression.Binding.Mode == BindingMode.TwoWay)
 338                                         throw new ArgumentException ("TwoWay bindings require a non-empty Path");
 339                         }
 340
 341                         expressions.TryGetValue (dp, out existing);
 342
 343                         if (expression != null) {
 344                                 if (existing != null)
 345                                         RemoveExpression (dp);
 346                                 expressions.Add (dp, expression);
 347
 348                                 addingExpression = true;
 349                                 value = expression.GetValue (dp);
 350                         } else if (existing != null) {
 351                                 if (existing is BindingExpressionBase) {
 352                                         BindingExpressionBase beb = (BindingExpressionBase)existing;
 353
 354                                         if (beb.Binding.Mode == BindingMode.TwoWay)
 355                                                 beb.SetValue (value);
 356                                         else if (!(beb.UpdatingSource && beb.Binding.Mode == BindingMode.OneWay)) {
 357                                                 RemoveExpression (dp);
 358                                         }
 359                                 }
 360                                 else if (existing is TemplateBindingExpression) {
 361                                         TemplateBindingExpression tb = (TemplateBindingExpression)existing;
 362
 363                                         if (!tb.UpdatingTarget)
 364                                                 RemoveExpression (dp);
 365                                 }
 366                                 else {
 367                                         RemoveExpression (dp);
 368                                 }
 369                         }
 370
 371                         try {
 372                                 base.SetValueImpl (dp, value);
 373                         } catch {
 374
 375                                 if (!addingExpression)
 376                                         throw;
 377                                 else
 378                                         base.SetValueImpl (dp, dp.DefaultValue);
 379                         }
 380                 }
 381
 382                 internal override object ReadLocalValueImpl (DependencyProperty dp)
 383                 {
 384                         Expression expression;
 385                         if (expressions.TryGetValue (dp, out expression))
 386                                 return expression;
 387                         return base.ReadLocalValueImpl (dp);
 388                 }
 389
 390                 #region UIA Events and Methods
 391
 392                 // All events are 1-1 to each attached property defined in:
 393                 // System.Windows.Automation.AutomationProperties
 394
 395                 internal event DependencyPropertyChangedEventHandler AcceleratorKeyChanged;
 396                 internal event DependencyPropertyChangedEventHandler AccessKeyChanged;
 397                 internal event DependencyPropertyChangedEventHandler AutomationIdChanged;
 398                 internal event DependencyPropertyChangedEventHandler HelpTextChanged;
 399                 internal event DependencyPropertyChangedEventHandler IsRequiredForFormChanged;
 400                 internal event DependencyPropertyChangedEventHandler ItemStatusChanged;
 401                 internal event DependencyPropertyChangedEventHandler ItemTypeChanged;
 402                 internal event DependencyPropertyChangedEventHandler LabeledByChanged;
 403                 internal event DependencyPropertyChangedEventHandler NameChanged;
 404
 405                 internal void RaiseAcceleratorKeyChanged (DependencyPropertyChangedEventArgs args)
 406                 {
 407                         if (AcceleratorKeyChanged != null)
 408                                 AcceleratorKeyChanged (this, args);
 409                 }
 410
 411                 internal void RaiseAccessKeyChanged (DependencyPropertyChangedEventArgs args)
 412                 {
 413                         if (AccessKeyChanged != null)
 414                                 AccessKeyChanged (this, args);
 415                 }
 416
 417                 internal void RaiseAutomationIdChanged (DependencyPropertyChangedEventArgs args)
 418                 {
 419                         if (AutomationIdChanged != null)
 420                                 AutomationIdChanged (this, args);
 421                 }
 422
 423                 internal void RaiseHelpTextChanged (DependencyPropertyChangedEventArgs args)
 424                 {
 425                         if (HelpTextChanged != null)
 426                                 HelpTextChanged (this, args);
 427                 }
 428
 429                 internal void RaiseIsRequiredForFormChanged (DependencyPropertyChangedEventArgs args)
 430                 {
 431                         if (IsRequiredForFormChanged != null)
 432                                 IsRequiredForFormChanged (this, args);
 433                 }
 434
 435                 internal void RaiseItemStatusChanged (DependencyPropertyChangedEventArgs args)
 436                 {
 437                         if (ItemStatusChanged != null)
 438                                 ItemStatusChanged (this, args);
 439                 }
 440
 441                 internal void RaiseItemTypeChanged (DependencyPropertyChangedEventArgs args)
 442                 {
 443                         if (ItemTypeChanged != null)
 444                                 ItemTypeChanged (this, args);
 445                 }
 446
 447                 internal void RaiseLabeledByChanged (DependencyPropertyChangedEventArgs args)
 448                 {
 449                         if (LabeledByChanged != null)
 450                                 LabeledByChanged (this, args);
 451                 }
 452
 453                 internal void RaiseNameChanged (DependencyPropertyChangedEventArgs args)
 454                 {
 455                         if (NameChanged != null)
 456                                 NameChanged (this, args);
 457                 }
 458
 459                 #endregion
 460         }
 461 }