C# FrameworkElement.SetValue方法代码示例

        private IList<IMvxUpdateableBinding> GetOrCreateBindingsList(FrameworkElement attachedObject)
        {
            var existing = attachedObject.GetValue(BindingsListProperty) as IList<IMvxUpdateableBinding>;
            if (existing != null)
                return existing;

            // attach the list
            var newList = new List<IMvxUpdateableBinding>();
            attachedObject.SetValue(BindingsListProperty, newList);

            // create a binding watcher for the list
#if WINDOWS_PHONE || WINDOWS_WPF
            var binding = new System.Windows.Data.Binding();
#endif
#if NETFX_CORE
            var binding = new Windows.UI.Xaml.Data.Binding();
#endif
            bool attached = false;
            Action attachAction = () =>
                {
                    if (attached)
                        return;
                    BindingOperations.SetBinding(attachedObject, DataContextWatcherProperty, binding);
                    attached = true;
                };
            Action detachAction = () =>
                {
                    if (!attached)
                        return;
#if WINDOWS_PHONE || NETFX_CORE
                    attachedObject.ClearValue(DataContextWatcherProperty);
#else
                    BindingOperations.ClearBinding(attachedObject, DataContextWatcherProperty);
#endif
                    attached = false;
                };
            attachAction();
            attachedObject.Loaded += (o, args) =>
            {
                attachAction();
            };
            attachedObject.Unloaded += (o, args) =>
            {
                detachAction();
            };

            return newList;
        }

        public static void SetOpen(FrameworkElement element, AnimationDefinition animationDefinition)
        {
            element.SetValue(OpenProperty, animationDefinition);

            if (animationDefinition.OpacityFromZero)
                element.Opacity = 0;

            element.Loaded += async (sender, args) =>
            {
                var idleDefinition = GetIdle(element);
                if (idleDefinition == null)
                {
                    await element.AnimateAsync(animationDefinition);
                }
            };
        }

        partial void InitializeBusyIndicator()
        {
            if (_busyIndicator != null)
            {
                return;
            }

            _grid = new Grid();
            _grid.RowDefinitions.Add(new RowDefinition {Height = new GridLength(1, GridUnitType.Star)});
            _grid.RowDefinitions.Add(new RowDefinition {Height = new GridLength(1, GridUnitType.Auto)});
            _grid.RowDefinitions.Add(new RowDefinition {Height = new GridLength(1, GridUnitType.Auto)});
            _grid.RowDefinitions.Add(new RowDefinition {Height = new GridLength(1, GridUnitType.Star)});

            var backgroundBorder = new Border();
            backgroundBorder.Background = new SolidColorBrush(Colors.Gray);
            backgroundBorder.Opacity = 0.5;
            backgroundBorder.SetValue(Grid.RowSpanProperty, 4);
            _grid.Children.Add(backgroundBorder);

            _statusTextBlock = new TextBlock();
            //_statusTextBlock.Style = (Style)Application.Current.Resources["PhoneTextNormalStyle"];
            _statusTextBlock.HorizontalAlignment = HorizontalAlignment.Center;
            _statusTextBlock.SetValue(Grid.RowProperty, 1);
            _grid.Children.Add(_statusTextBlock);

            _busyIndicator = ConstructorBusyIndicator();
            _busyIndicator.SetValue(Grid.RowProperty, 2);
            _grid.Children.Add(_busyIndicator);

            _containerPopup = new Popup();
            _containerPopup.VerticalAlignment = VerticalAlignment.Center;
            _containerPopup.HorizontalAlignment = HorizontalAlignment.Center;
            _containerPopup.Child = _grid;

            double rootWidth = Window.Current.Bounds.Width;
            double rootHeight = Window.Current.Bounds.Height;

            _busyIndicator.Width = rootWidth;

            _grid.Width = rootWidth;
            _grid.Height = rootHeight;

            _containerPopup.UpdateLayout();
        }

        public static void SetClose(FrameworkElement element, AnimationDefinition animationDefinition)
        {
            element.SetValue(CloseProperty, animationDefinition);

            element.Loaded += (sender, args) =>
            {
                lock (_lockObject)
                {
                    CloseElements.Add(element);
                }
            };
            element.Unloaded += (sender, args) =>
            {
                lock (_lockObject)
                {
                    CloseElements.Remove(element);
                }
            };
        }

        public static void SetIdle(FrameworkElement element, AnimationDefinition animationDefinition)
        {
            element.SetValue(IdleProperty, animationDefinition);
            element.Loaded += async (sender, args) =>
            {
                var openAnimation = GetOpen(element);
                if (openAnimation != null)
                {
                    if (openAnimation.OpacityFromZero)
                        element.Opacity = 0;

                    await element.AnimateAsync(openAnimation);
                }

                animationDefinition.Forever = true;
                await element.AnimateAsync(animationDefinition);
            };

        }

 /// <summary>
 /// Executes the handler the fist time the element is loaded.
 /// </summary>
 /// <param name="element">The element.</param>
 /// <param name="handler">The handler.</param>
 public static void ExecuteOnFirstLoad(FrameworkElement element, Action<FrameworkElement> handler)
 {
     if ((bool) element.GetValue(PreviouslyAttachedProperty)) return;
     element.SetValue(PreviouslyAttachedProperty, true);
     ExecuteOnLoad(element, handler);
 }

        /// <summary>
        /// Executes the handler immediately if the element is loaded, otherwise wires it to the Loaded event.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="handler">The handler.</param>
        /// <returns>true if the handler was executed immediately; false otherwise</returns>
        public static bool ExecuteOnLoad(FrameworkElement element, RoutedEventHandler handler)
        {
#if SILVERLIGHT
            if ((bool)element.GetValue(IsLoadedProperty))
#elif WinRT
            if (IsElementLoaded(element))
#else
            if(element.IsLoaded)
#endif
            {
                handler(element, new RoutedEventArgs());
                return true;
            }
            else
            {
                RoutedEventHandler loaded = null;
                loaded = (s, e) =>
                {
#if SILVERLIGHT
                    element.SetValue(IsLoadedProperty, true);
#endif
                    handler(s, e);
                    element.Loaded -= loaded;
                };

                element.Loaded += loaded;
                return false;
            }
        }

        /// <summary>
        /// Parse metadata from a target FrameworkElement.  This will cache the metadata on the element as an attached property.
        /// </summary>
        /// <param name="element">The target FrameworkElement to pull metadata from.</param>
        /// <param name="forceUpdate">If set, will not pull metadata from cache.</param>
        /// <param name="entity">The entity used.</param>
        /// <param name="bindingExpression">The bindingExpression used.</param>
        /// <returns>Returns the metadata associated with the element.  Will be null if no metadata was found.</returns>
        internal static ValidationMetadata ParseMetadata(FrameworkElement element, bool forceUpdate, out object entity, out BindingExpression bindingExpression)
        {
            entity = null;
            bindingExpression = null;
            if (element == null)
            {
                return null;
            }

            if (!forceUpdate)
            {
                ValidationMetadata existingVMD = element.GetValue(ValidationMetadataProperty) as ValidationMetadata;
                if (existingVMD != null)
                {
                    return existingVMD;
                }
            }

            BindingExpression be = null;
            FieldInfo[] fields = element.GetType().GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
            foreach (FieldInfo field in fields)
            {
                if (field.FieldType == typeof(DependencyProperty))
                {
                    // Found a dependency property
                    be = element.GetBindingExpression((DependencyProperty)field.GetValue(null));
                    if (be != null && be.ParentBinding != null && be.ParentBinding.Path != null)
                    {
                        // Found a BindingExpression, ensure it has valid data
                        entity = be.DataItem != null ? be.DataItem : element.DataContext;
                        if (entity != null)
                        {
                            if (be.ParentBinding.Mode == BindingMode.TwoWay)
                            {
                                bindingExpression = be;
                                // A twoway binding will be automatically chosen and the rest ignored
                                break;
                            }

                            // Perform an arbitrary sort on path (string), so the same dependency property is chosen consistently.
                            // Reflection ordering is not deterministic and if we just pick the first, we could be
                            // matched with different dependency properties depending on the run.
                            if (bindingExpression == null || string.Compare(be.ParentBinding.Path.Path, bindingExpression.ParentBinding.Path.Path, StringComparison.Ordinal) < 0)
                            {
                                bindingExpression = be;
                            }
                        }
                    }
                }
            }
            if (bindingExpression != null)
            {
                ValidationMetadata newVMD = ParseMetadata(bindingExpression.ParentBinding.Path.Path, entity);
                element.SetValue(ValidationMetadataProperty, newVMD);
                return newVMD;
            }
            return null;
        }

		public static void SetTextHintingMode (FrameworkElement target, TextHintingMode textHintingMode)
		{
			target.SetValue (TextOptions.TextHintingModeProperty, textHintingMode);
		}

 public static void SetIsHeaderOf(FrameworkElement element, TreeViewItem value)
 {
     if (element == null)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(IsHeaderOfProperty, value);
 }

        //----------------------------------------------------- 
        //
        //  Constructors 
        // 
        //-----------------------------------------------------
 
        #region Constructors

        /// <summary>
        /// Initialize the TextEditor 
        /// </summary>
        /// <param name="textContainer"> 
        /// TextContainer representing a content to edit. 
        /// </param>
        /// <param name="uiScope"> 
        /// FrameworkElement on which all events for the user interaction will be
        /// processed.
        /// </param>
        /// <param name="isUndoEnabled"> 
        /// If true the TextEditor will enable undo support
        /// </param> 
        internal TextEditor(ITextContainer textContainer, FrameworkElement uiScope, bool isUndoEnabled) 
        {
            // Validate parameters 
            Invariant.Assert(uiScope != null);

            // Set non-zero property defaults.
            _acceptsRichContent = true; 

            // Attach the editor  instance to the scope 
            _textContainer = textContainer; 
            _uiScope = uiScope;
 
            // Enable undo manager for this uiScope
            if (isUndoEnabled && _textContainer is TextContainer)
            {
                ((TextContainer)_textContainer).EnableUndo(_uiScope); 
            }
 
            // Create TextSelection and link it to text container 
            _selection = new TextSelection(this);
            textContainer.TextSelection = _selection; 

            // Create DragDropProcess
            //
 
            _dragDropProcess = new TextEditorDragDrop._DragDropProcess(this);
 
            // By default we use IBeam cursor 
            _cursor = Cursors.IBeam;
 
            // Add InputLanguageChanged event handler
            TextEditorTyping._AddInputLanguageChangedEventHandler(this);

            // Listen to both TextContainer.EndChanging and TextContainer.Changed events 
            TextContainer.Changed += new TextContainerChangedEventHandler(OnTextContainerChanged);
 
            // Add IsEnabled event handler for cleaning the caret element when uiScope is disabled 
            _uiScope.IsEnabledChanged += new DependencyPropertyChangedEventHandler(OnIsEnabledChanged);
 
            // Attach this instance of text editor to its uiScope
            _uiScope.SetValue(TextEditor.InstanceProperty, this);

            // The IsSpellerEnabled property might have been set before this 
            // TextEditor was instantiated -- check if we need to rev
            // up speller support. 
            if ((bool)_uiScope.GetValue(SpellCheck.IsEnabledProperty)) 
            {
                SetSpellCheckEnabled(true); 
                SetCustomDictionaries(true);
            }

            // If no IME/TextServices are installed, we have no native reasources 
            // to clean up at Finalizer.
            if (!TextServicesLoader.ServicesInstalled) 
            { 
                GC.SuppressFinalize(this);
            } 
        }

 public static void SetPropertyBinding(FrameworkElement element, SetterValueBindingHelper value)
 {
     if (null == element)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(PropertyBindingProperty, value);
 }

		private static void SuspendScroll(object sender, RoutedEventArgs e)
		{
            
			var blockingElement = sender as FrameworkElement;

			// Determines the parent Panorama/Pivot control
			if (_internalPanningControl == null)
#if WINDOWS_STORE
                _internalPanningControl = FindAncestor(blockingElement, p => p is Hub || p is FlipView) as FrameworkElement;
#elif WINDOWS_PHONE_APP
                _internalPanningControl = FindAncestor(blockingElement, p => p is Pivot || p is Hub || p is FlipView) as FrameworkElement;
#elif WINDOWS_PHONE
                _internalPanningControl = FindAncestor(blockingElement, p => p is Pivot || p is Panorama) as FrameworkElement;
#endif

			if (_internalPanningControl != null && (bool)_internalPanningControl.GetValue(IsScrollSuspendedProperty))
				return;
			// When the user touches the control...
			var originalSource = e.OriginalSource as DependencyObject;
			if (FindAncestor(originalSource, dobj => (dobj == blockingElement)) != blockingElement)
				return;

			// Mark the parent Panorama/Pivot for scroll suspension
			// and register for touch frame events
			if (_internalPanningControl != null)
				_internalPanningControl.SetValue(IsScrollSuspendedProperty, true);

#if WINDOWS_STORE || WINDOWS_PHONE_APP
            CoreWindow.GetForCurrentThread().PointerReleased += PreventScrollBinding_PointerReleased;
#elif WINDOWS_PHONE
            Touch.FrameReported += TouchFrameReported;
#endif
			if (blockingElement != null)
				blockingElement.IsHitTestVisible = true;

			if (_internalPanningControl != null)
				_internalPanningControl.IsHitTestVisible = false;
		}