C# UIElement.SetValue方法代码示例

        public void AddElement(UIElement element, int x, int y)
        {
            if(element == null)
                return;

            element.SetValue(ColumnProperty, x);
            element.SetValue(RowProperty, y);
            Children.Add(element);
        }

 public void AddChildInCanvas(UIElement control)
 {
     if (canvas.Children.Count == 0)
     {
         canvas.Children.Add(control);
         control.SetValue(Canvas.LeftProperty, 0d);
         control.SetValue(Canvas.TopProperty, 0d);
     }
 }

        public static void AddChild(this Grid grid, UIElement control, int row, int column)
        {
            control.SetValue(Grid.RowProperty, row);
            control.SetValue(Grid.ColumnProperty, column);

            grid.Children.Add(control);
        }

        public CompletionControl(UIElement view, ICompletionSession session)
        {
            InitializeComponent();

            _view = view;
            _warning.Foreground = SystemColors.HotTrackBrush;
            _warning.Text = J.Tools.Resources.WarningAnalysisNotCurrent;

            if (session.TextView.GetAnalyzer().InterpreterFactory.IsAnalysisCurrent()) {
                _warning.Visibility = System.Windows.Visibility.Collapsed;
            }

            view.SetValue(Grid.RowProperty, 0);
            view.SetValue(Grid.ColumnProperty, 0);
            _grid.Children.Add(view);

            var content = view as ContentControl;
            if (content != null) {
                content.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
                content.Width = Width;
                content.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Stretch;
            }

            session.Dismissed += SessionDismissed;
        }

        private UIElement SetGridColumnRow(UIElement input, int row, int column)
        {
            input.SetValue(RowProperty, row);
            input.SetValue(ColumnProperty, column);

            return input;
        }

 /// <summary>
 /// Sets a boolean indicating whether or not the specified element is a Tab stop
 /// </summary>
 /// <param name="element">The <see cref="UIElement"/> to set</param>
 /// <param name="isTabStop">A boolean indicating whether or not the element is a Tab stop element</param>
 public static void SetIsTabStop(UIElement element, bool isTabStop)
 {
     IUIElement focusScopeElement;
     HashSet<UIElement> focusables;
     int index;
     if (!element.DependencyProperties.ContainsKey(KeyboardNavigation.IsTabStopProperty))
     {
         KeyboardNavigation.AppendKeyboardNavigationProperties(element);
     }
     focusScopeElement = FocusManager.GetFocusScopeElement(element);
     if (focusScopeElement == null)
     {
         return;
     }
     element.SetValue(KeyboardNavigation.IsTabStopProperty, isTabStop);
     focusables = focusScopeElement.GetValue<HashSet<UIElement>>(FocusManager.FocusableElementsProperty);
     if (focusables.Contains(element))
     {
         return;
     }
     if(focusables.Count > 0)
     {
         index = focusables.Max(elem => elem.GetValue<int>(KeyboardNavigation.TabIndexProperty));
     }
     else
     {
         index = 0;
     }
     element.SetValue(KeyboardNavigation.TabIndexProperty, index);
 }

		public DialogShellViewWpf(System.Windows.UIElement hostedControl)
			: this()
		{
			_hostedControl = hostedControl;
			_hostedControl.SetValue(Grid.RowProperty, 0);
			_hostedControl.SetValue(Grid.ColumnProperty, 0);
			_grid.Children.Add(_hostedControl);
		}

		public static void SetIsVisible(UIElement control, bool? isVisible)
		{
			control.SetValue(IsVisibleProperty, isVisible);

			if (isVisible == null)
				return;

			control.SetValue(UIElement.VisibilityProperty, isVisible.Value ? Visibility.Visible : Visibility.Collapsed);
		}

        public void AddUiElement(UIElement uiElement, int row, int col, int rowSpan = 0, int colSpan = 0)
        {
            if (row > 0) uiElement.SetValue(RowProperty, row);
            if (col > 0) uiElement.SetValue(ColumnProperty, col);
            if (rowSpan > 0) uiElement.SetValue(RowSpanProperty, rowSpan);
            if (colSpan > 0) uiElement.SetValue(ColumnSpanProperty, colSpan);

            Children.Add(uiElement);
        }

        public void AddElement(UIElement el)
        {
            var rowDefinition = new RowDefinition();
            rowDefinition.Height = GridLength.Auto;
            viewGrid.RowDefinitions.Add(rowDefinition);

            el.SetValue(Grid.RowProperty, newRow++);
            el.SetValue(Grid.ColumnProperty, 0);
            this.viewGrid.Children.Add(el);

            //this.viewStack.Children.Add(el);
        }

		public void SetDetailControl(object detailControl)
		{
			if (_detailControl != null)
				_mainGrid.Children.Remove(_detailControl);

			_detailControl = (UIElement)detailControl;

			if (null != _detailControl)
			{
				_detailControl.SetValue(Grid.RowProperty, 4);
				_detailControl.SetValue(Grid.ColumnProperty, 2);
				_mainGrid.Children.Add(_detailControl);
			}
		}

        /// <summary>
        /// Sets the value of the Dock attached property to a specified element.
        /// </summary>
        /// <param name="element">The element to which the attached property is written.</param>
        /// <param name="dock">The new Dock value.</param>
        public static void SetDock(UIElement element, Dock dock)
        {
            if (element == null)
                throw new ArgumentNullException("element");

            element.SetValue(DockProperty, dock);
        }

        /// <summary>
        /// Starts an animation to a particular value on the specified dependency property.
        /// You can pass in an event handler to call when the animation has completed.
        /// </summary>
        public static void StartAnimation(UIElement animatableElement, DependencyProperty dependencyProperty, double toValue, double animationDurationSeconds, EventHandler completedEvent)
        {
            double fromValue = (double)animatableElement.GetValue(dependencyProperty);

            DoubleAnimation animation = new DoubleAnimation();
            animation.From = fromValue;
            animation.To = toValue;
            animation.Duration = TimeSpan.FromSeconds(animationDurationSeconds);

            animation.Completed += delegate(object sender, EventArgs e)
            {
                //
                // When the animation has completed bake final value of the animation
                // into the property.
                //
                animatableElement.SetValue(dependencyProperty, animatableElement.GetValue(dependencyProperty));
                CancelAnimation(animatableElement, dependencyProperty);

                if (completedEvent != null)
                {
                    completedEvent(sender, e);
                }
            };

            //TODO// animation.Freeze();

            //TODO// animatableElement.BeginAnimation(dependencyProperty, animation);
        }

 public static void SetPosition(UIElement element, Position position)
 {
     if (element == null)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(PositionProperty, position);
 }

 /// <summary>
 /// Sets the value of the IsMemoryEfficient attached property to a specified UIElement.
 /// </summary>
 /// <param name="element">The UIElement to which the attached property is written.</param>
 /// <param name="value">The needed IsMemoryEfficient value.</param>
 public static void SetIsMemoryEfficient(UIElement element, bool value)
 {
     if (element == null)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(IsMemoryEfficientProperty, value);
 }