C# FrameworkElement.SetValue方法代码示例

		protected override void SetCommonBindings(FrameworkElement marker)
		{
			base.SetCommonBindings(marker);

			marker.SetValue(ViewportPanel.YProperty, 0.0);
			marker.SetBinding(ViewportPanel.ViewportHeightProperty, DependentValueBinding);
			marker.SetBinding(ViewportPanel.ViewportWidthProperty, ColumnWidthBinding);
			marker.SetValue(ViewportPanel.ViewportVerticalAlignmentProperty, VerticalAlignment.Bottom);
			marker.SetBinding(ViewportPanel.XProperty, IndexBinding);
		}

        public Enemy(Field field, FrameworkElement ui)
            : base(ui)
        {
            this.field = field;

            this.right = -ui.ActualWidth;
            this.bottom = (double)App.Random.Next(100);
            ui.SetValue(Canvas.RightProperty, this.right);
            ui.SetValue(Canvas.BottomProperty, this.bottom);
        }

		protected override void AddCommonBindings(FrameworkElement marker)
		{
			base.AddCommonBindings(marker);

			marker.SetValue(ViewportPanel.XProperty, 0.0);
			marker.SetBinding(ViewportPanel.ViewportWidthProperty, viewportWidthBinding);
			marker.SetValue(ViewportPanel.ViewportHeightProperty, 0.85);
			marker.SetValue(ViewportPanel.ViewportHorizontalAlignmentProperty, HorizontalAlignment.Left);
			marker.SetBinding(ViewportPanel.YProperty, viewportYBinding);
		}

        public void FreezableBasicTest()
        {
            int resourcesChangedCount = 0;
            object resourceValue;

            Freezable freezable = new Freezable();
            freezable.ResourcesChanged += (sender, e) => resourcesChangedCount++;

            FrameworkElement element = new FrameworkElement();
            element.DataContext = "data-context";
            element.Resources = new ResourceDictionary();
            element.Resources.Add("key1", "value1");

            Assert.AreNotEqual("data-context", freezable.GetValue(FrameworkElement.DataContextProperty));
            Assert.IsFalse(freezable.TryGetResource("key1", out resourceValue));

            element.SetValue(ValueProperty, freezable);
            Assert.AreEqual("data-context", freezable.GetValue(FrameworkElement.DataContextProperty));
            Assert.AreEqual(1, resourcesChangedCount);
            Assert.IsTrue(freezable.TryGetResource("key1", out resourceValue));
            Assert.AreEqual("value1", resourceValue);

            element.Resources.Add("key2", "value2");
            Assert.AreEqual(2, resourcesChangedCount);
            Assert.IsTrue(freezable.TryGetResource("key2", out resourceValue));
            Assert.AreEqual("value2", resourceValue);
        }

		public static void SetupNextToolTip(FrameworkElement element, Window window) {
			element.ToolTip = GetNextToolTip(window);

			if (element.ToolTip != null) {
				element.SetValue(ToolTipService.ShowDurationProperty, 30000);
			}
		}

    internal void UpdateProperty( FrameworkElement element, DependencyProperty elementProp, DependencyProperty definitionProperty )
    {
      object currentValue = this.GetValue( definitionProperty );
      object localValue = this.ReadLocalValue( definitionProperty );
      object elementValue = element.GetValue( elementProp );
      bool areEquals = false;

      // Avoid setting values if it does not affect anything 
      // because setting a local value may prevent a style setter from being active.
      if( localValue != DependencyProperty.UnsetValue )
      {
        if( ( elementValue != null ) && ( currentValue != null ) )
        {
          areEquals = ( elementValue.GetType().IsValueType && currentValue.GetType().IsValueType )
                      ? elementValue.Equals( currentValue )  // Value Types
                      : currentValue == element.GetValue( elementProp ); // Reference Types
        }

        if( !areEquals )
        {
          element.SetValue( elementProp, currentValue );
        }
        else
        {
          element.ClearValue( elementProp );
        }
      }
    }

        private static void SetPosition(FrameworkElement ellipse, double offset,
            double posOffSet, double step, double ew, double eh, double w, double h,
            double r)
        {
            double t = 2*Math.PI*posOffSet/10;
            ellipse.Width = ew;
            ellipse.Height = eh;

            ellipse.SetValue(Canvas.LeftProperty, w + r*Math.Cos(t));
            ellipse.SetValue(Canvas.TopProperty, h + r*Math.Sin(t));

            //ellipse.SetValue(Canvas.LeftProperty,w
            //    + Math.Sin(offset + posOffSet * step) * w);

            //ellipse.SetValue(Canvas.TopProperty, h
            //    + Math.Cos(offset + posOffSet * step) * h);
        }

 public void InjectControl(FrameworkElement pControl)
 {
     _panel.Dispatcher.Invoke(() =>
     {
         pControl.SetValue(DockPanel.DockProperty, Dock.Left);
         _panel.Children.Insert(1, pControl);
     });
 }

 public static void SetDefaultSource(FrameworkElement image, string value)
 {
     if (image == null)
     {
         throw new ArgumentNullException("Image");
     }
     image.SetValue(ImageDecoder.DefaultSourceProperty, value);
 }

 private static void SetHasBeenStyled(FrameworkElement element, bool value)
 {
     if (element == null)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(HasBeenStyledProperty, value);
 }

 public static PushBindingCollection GetPushBindings(FrameworkElement obj)
 {
     if (obj.GetValue(PushBindingsProperty) == null)
     {
         obj.SetValue(PushBindingsProperty, new PushBindingCollection(obj));
     }
     return (PushBindingCollection)obj.GetValue(PushBindingsProperty);
 }

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

 public static void SetFill(FrameworkElement element, bool value)
 {
     if (element == null)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(ZoomScrollViewer.FillProperty, value);
 }

        public static void SetObserve(FrameworkElement frameworkElement, bool observe)
        {
            if (frameworkElement == null)
            {
                throw new ArgumentNullException("frameworkElement");
            }

            frameworkElement.SetValue(ObserveProperty, observe);
        }

        public static void SetObservedHeight(FrameworkElement frameworkElement, double observedHeight)
        {
            if (frameworkElement == null)
            {
                throw new ArgumentNullException("frameworkElement");
            }

            frameworkElement.SetValue(ObservedHeightProperty, observedHeight);
        }