System.Windows.DependencyObject.SetValue(System.Windows.DependencyProperty, object)

public static void SetAreScriptErrorsDisabled(DependencyObject obj, bool value) {
			if (obj == null)
				throw new ArgumentNullException("obj");
			obj.SetValue(AreScriptErrorsDisabledProperty, value);
		}

public static void SetCheckBoxColumnEditingStyle(DependencyObject d, Style value)
        {
            d.SetValue(CheckBoxColumnEditingStyleProperty, value);
        }

public static void SetVisibleIn(DependencyObject element, FrameworkVisibility visibleIn)
        {
            element.SetValue(VisibleInProperty, visibleIn);
        }

public static void SetStrokeThickness(DependencyObject element, float value)
        {
            element.SetValue(StrokeThicknessProperty, value);
        }

public static void SetDrawLine(DependencyObject element, bool value)
        {
            element.SetValue(DrawLineProperty, value);
        }

public static void SetToBounds(DependencyObject depObj, bool clipToBounds)
        {
            depObj.SetValue(ToBoundsProperty, clipToBounds);
        }

public static void SetHasPreplacedwordEmpty(DependencyObject obj, bool value)
        {
            obj.SetValue(HasPreplacedwordEmptyProperty, value);
        }

public static void SetDataSeries(UIElement element, IEnumerable<IDataSeries> value)
        {
            element.SetValue(DataSeriesProperty, value);
        }

public static void SetCompactMode(DependencyObject obj, bool value)
        {
            obj.SetValue(LabelProperty, value);
        }

public static void SetExampleStartPage(DependencyObject element, Guid value)
        {
            element.SetValue(ExampleStartPageProperty, value);
        }

public static void SetSyncZeroLineGroup(DependencyObject element, string value)
        {
            element.SetValue(SyncZeroLineGroupProperty, value);
        }

public static void SetUseAlternateXAxis(DependencyObject element, bool value)
        {
            element.SetValue(UseAlternateXAxisProperty, value);
        }

public static void SetLoadedEventCommand(DependencyObject element, ICommand value)
        {
            element.SetValue(LoadedEventCommandProperty, value);
        }

public static void SetColumns(DependencyObject obj, ObservableCollection<DataGridColumn> value)
        {
            obj.SetValue(ColumnsProperty, value);
        }

public static void SetCornerRadius(DependencyObject element, CornerRadius value)
        {
            element.SetValue(CornerRadiusProperty, value);
        }

protected virtual void ApplyValue(DependencyProperty sourceProperty, FrameworkElement targetElement, DependencyProperty targetProperty) {
			if (sourceProperty == null)
				throw new ArgumentNullException("sourceProperty");
			else if (targetElement == null)
				throw new ArgumentNullException("targetElement");
			else if (targetProperty == null)
				throw new ArgumentNullException("targetProperty");

			// 8/22/2011 - If the property is not set on the column, then do not preplaced down to the element (10F-15E35C2E-480E)
			// 1/27/2012 - Fixed issue with column default that differ from the column not getting preplaceded down properly (197-16B573BD-0301)
			if (DependencyPropertyHelper.GetValueSource(this, sourceProperty).BaseValueSource == BaseValueSource.Default &&
				DefaultValuesEqual(sourceProperty.GetMetadata(this), targetProperty.GetMetadata(targetElement)))
				targetElement.ClearValue(targetProperty);
			else
				targetElement.SetValue(targetProperty, this.GetValue(sourceProperty));
		}

public static void SetText(DependencyObject o, string value)
        {
            o.SetValue(TextProperty, value);
        }

public static void SetComboBoxColumnStyle(DependencyObject d, Style value)
        {
            d.SetValue(ComboBoxColumnStyleProperty, value);
        }

public static void SereplacedermarkContentTemplate(DependencyObject element, DataTemplate value)
        {
            element.SetValue(WatermarkContentTemplateProperty, value);
        }

public static void SetErrorMessage(DependencyObject obj, string value)
        {
            obj.SetValue(ErrorMessageProperty, value);
        }

public static void SetIsRotationEnabled(DependencyObject obj, bool value)
        {
            obj.SetValue(IsRotationEnabledProperty, value);
        }

public static void SetEnableZoomExtentsOnChecked(DependencyObject element, bool value)
        {
            element.SetValue(EnableZoomExtentsOnCheckedProperty, value);
        }

public static void SetIsShowingWatermark(DependencyObject element, bool value)
        {
            element.SetValue(IsShowingWatermarkProperty, value);
        }

public static void SetDrawMarker(DependencyObject element, bool value)
        {
            element.SetValue(DrawMarkerProperty, value);
        }

private void AddMoreItems()
        {
            var isBusy = (bool)GetValue(IsBusyProperty);
            if (!isBusy)
            {
                SetValue(IsBusyProperty, true);
                SetValue(IsBusyProperty, false);
                SetValue(IsBusyProperty, true);
                var delay = (TimeSpan)GetValue(PreLoadingDelayProperty);
                
                Task.Factory.StartNew(() =>
                {
                    Thread.Sleep(delay);

                    var items = _allItems.Take(10).ToList();
                    items.ForEach(item =>
                    {
                        Dispatcher.BeginInvoke(new Action(() => Currenreplacedems.Add(item)));
                        _allItems.Remove(item);
                    });
                }).ContinueWith(_ =>
                {
                    Dispatcher.BeginInvoke(new Action(() => SetValue(IsBusyProperty, false)));
                });
            }
        }

public static void SetIncludeSeries(DependencyObject obj, bool value)
        {
            obj.SetValue(IncludeSeriesProperty, value);
        }

public static void SetForeground(DependencyObject element, Brush value)
        {
            element.SetValue(ForegroundProperty, value);
        }

private void Expand()
        {
            Grid parentGrid = base.Parent as Grid;
            int splitterIndex = int.MinValue;

            if (_gridCollapseDirection == GridCollapseDirection.Rows)
            {
                // Get the index of the row containing the splitter
                splitterIndex = (int)this.GetValue(Grid.RowProperty);

                // Determine the curent CollapseMode
                if (this.CollapseMode == GridSplitterCollapseMode.Next)
                {
                    // Expand the next row
                    if (IsAnimated)
                        AnimateExpand(parentGrid.RowDefinitions[splitterIndex + 1]);
                    else
                        parentGrid.RowDefinitions[splitterIndex + 1].SetValue(RowDefinition.HeightProperty, _savedGridLength);
                }
                else
                {
                    // Expand the previous row
                    if (IsAnimated)
                        AnimateExpand(parentGrid.RowDefinitions[splitterIndex - 1]);
                    else
                        parentGrid.RowDefinitions[splitterIndex - 1].SetValue(RowDefinition.HeightProperty, _savedGridLength);
                }
            }
            else
            {
                // Get the index of the column containing the splitter
                splitterIndex = (int)this.GetValue(Grid.ColumnProperty);

                // Determine the curent CollapseMode
                if (this.CollapseMode == GridSplitterCollapseMode.Next)
                {
                    // Expand the next column
                    if (IsAnimated)
                        AnimateExpand(parentGrid.ColumnDefinitions[splitterIndex + 1]);
                    else
                        parentGrid.ColumnDefinitions[splitterIndex + 1].SetValue(ColumnDefinition.WidthProperty, _savedGridLength);
                }
                else
                {
                    // Expand the previous column
                    if (IsAnimated)
                        AnimateExpand(parentGrid.ColumnDefinitions[splitterIndex - 1]);
                    else
                        parentGrid.ColumnDefinitions[splitterIndex - 1].SetValue(ColumnDefinition.WidthProperty, _savedGridLength);
                }
            }
        }

public static void SetZoomExtentsOnVisibilityChanged(DependencyObject element, bool value)
        {
            element.SetValue(ZoomExtentsOnVisibilityChangedProperty, value);
        }

public static void SetClearButton(DependencyObject element, bool value)
        {
            element.SetValue(ClearButtonProperty, value);
        }

public static void SetAntiAliasing(DependencyObject element, bool value)
        {
            element.SetValue(AntiAliasingProperty, value);
        }

public static void SetUnloadedEventCommand(DependencyObject element, ICommand value)
        {
            element.SetValue(UnloadedEventCommandProperty, value);
        }

private static void SetWebBrowserBehaviorContext(DependencyObject obj, BehaviorContext value) {
			if (obj == null)
				throw new ArgumentNullException("obj");
			obj.SetValue(WebBrowserBehaviorContextProperty, value);
		}

public static void SereplacedermarkContent(DependencyObject element, object value)
        {
            element.SetValue(WatermarkContentProperty, value);
        }

[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPreplacedingBaseTypesAsParameters")]
		public static void SetTemplate(DataGridControl obj, ControlTemplate value) {
			if (null == obj) throw new ArgumentNullException("obj");
			obj.SetValue(NewRowTemplateBehavior.TemplateProperty, value);
		}

public static void SetSourceCode(DependencyObject o, string code)
        {
            o.SetValue(SourceCodeProperty, code);
        }

public static void SetCheckPreplacedwordIsEmpty(DependencyObject obj, bool value)
        {
            obj.SetValue(CheckPreplacedwordIsEmptyProperty, value);
        }

public static void SetUseAlternateYAxis(DependencyObject element, bool value)
        {
            element.SetValue(UseAlternateYAxisProperty, value);
        }

public static void SetTextColumnStyle(DependencyObject d, Style value)
        {
            d.SetValue(TextColumnStyleProperty, value);
        }

public static void SetContentTemplate(DependencyObject element, string value)
        {
            element.SetValue(ContentTemplateProperty, value);
        }

public static void SetCheckBoxColumnStyle(DependencyObject d, Style value)
        {
            d.SetValue(CheckBoxColumnStyleProperty, value);
        }

public static void SetShowTooltipLabel(DependencyObject element, bool value)
        {
            element.SetValue(ShowTooltipLabelProperty, value);
        }

public static void SetLabel(DependencyObject obj, string value)
        {
            obj.SetValue(LabelProperty, value);
        }

private FrameworkElement CreateVisualChild()
        {
            MeshGeometry3D simpleQuad = new MeshGeometry3D()
            {
                Positions = new Point3DCollection(_mesh),
                TextureCoordinates = new PointCollection(_texCoords),
                TriangleIndices = new Int32Collection(_indices)
            };

            // Front material is interactive, back material is not.
            Material frontMaterial = new DiffuseMaterial(Brushes.White);
            frontMaterial.SetValue(Viewport2DVisual3D.IsVisualHostMaterialProperty, true);

            VisualBrush vb = new VisualBrush(_logicalChild);
            SetCachingForObject(vb);  // big perf wins by caching!!
            Material backMaterial = new DiffuseMaterial(vb);

            _rotationTransform.Rotation = _quaternionRotation;
            var xfGroup = new Transform3DGroup() { Children = { _scaleTransform, _rotationTransform } };

            GeometryModel3D backModel = new GeometryModel3D() { Geometry = simpleQuad, Transform = xfGroup, BackMaterial = backMaterial };
            Model3DGroup m3dGroup = new Model3DGroup()
            {
                Children = { new DirectionalLight(Colors.White, new Vector3D(0, 0, -1)), 
                                 new DirectionalLight(Colors.White, new Vector3D(0.1, -0.1, 1)),
                                 backModel }
            };

            // Non-interactive Visual3D consisting of the backside, and two lights.
            ModelVisual3D mv3d = new ModelVisual3D() { Content = m3dGroup };

            // Interactive frontside Visual3D
            Viewport2DVisual3D frontModel = new Viewport2DVisual3D() { Geometry = simpleQuad, Visual = _logicalChild, Material = frontMaterial, Transform = xfGroup };

            // Cache the brush in the VP2V3 by setting caching on it.  Big perf wins.
            SetCachingForObject(frontModel);

            // Scene consists of both the above Visual3D's.
            _viewport3d = new Viewport3D() { ClipToBounds = false, Children = { mv3d, frontModel } };

            UpdateRotation();

            return _viewport3d;
        }

public static void SetStartPage(DependencyObject element, Guid value)
        {
            element.SetValue(StartPageProperty, value);
        }

private static void SetVirtualItemIndex(DependencyObject obj, int value)
        {
            obj.SetValue(VirtualItemIndexProperty, value);
        }

public static void SetCanContentScroll(DependencyObject element, bool value)
        {
            element.SetValue(CanContentScrollProperty, value);
        }

public static void SetLoseFocusOnEscape(DependencyObject element, bool value)
        {
            element.SetValue(LoseFocusOnEscapeProperty, value);
        }

private void Collapse()
        {
            Grid parentGrid = base.Parent as Grid;
            int splitterIndex = int.MinValue;

            if (_gridCollapseDirection == GridCollapseDirection.Rows)
            {
                // Get the index of the row containing the splitter
                splitterIndex = (int)base.GetValue(Grid.RowProperty);

                // Determing the curent CollapseMode
                if (this.CollapseMode == GridSplitterCollapseMode.Next)
                {
                    // Save the next rows Height information
                    _savedGridLength = parentGrid.RowDefinitions[splitterIndex + 1].Height;
                    _savedActualValue = parentGrid.RowDefinitions[splitterIndex + 1].ActualHeight;

                    // Collapse the next row
                    if (IsAnimated)
                        AnimateCollapse(parentGrid.RowDefinitions[splitterIndex + 1]);
                    else
                        parentGrid.RowDefinitions[splitterIndex + 1].SetValue(RowDefinition.HeightProperty, new GridLength(0));
                }
                else
                {
                    // Save the previous row's Height information
                    _savedGridLength = parentGrid.RowDefinitions[splitterIndex - 1].Height;
                    _savedActualValue = parentGrid.RowDefinitions[splitterIndex - 1].ActualHeight;

                    // Collapse the previous row
                    if (IsAnimated)
                        AnimateCollapse(parentGrid.RowDefinitions[splitterIndex - 1]);
                    else
                        parentGrid.RowDefinitions[splitterIndex - 1].SetValue(RowDefinition.HeightProperty, new GridLength(0));
                }
            }
            else
            {
                // Get the index of the column containing the splitter
                splitterIndex = (int)base.GetValue(Grid.ColumnProperty);

                // Determing the curent CollapseMode
                if (this.CollapseMode == GridSplitterCollapseMode.Next)
                {
                    // Save the next column's Width information
                    _savedGridLength = parentGrid.ColumnDefinitions[splitterIndex + 1].Width;
                    _savedActualValue = parentGrid.ColumnDefinitions[splitterIndex + 1].ActualWidth;

                    // Collapse the next column
                    if (IsAnimated)
                        AnimateCollapse(parentGrid.ColumnDefinitions[splitterIndex + 1]);
                    else
                        parentGrid.ColumnDefinitions[splitterIndex + 1].SetValue(ColumnDefinition.WidthProperty, new GridLength(0));
                }
                else
                {
                    // Save the previous column's Width information
                    _savedGridLength = parentGrid.ColumnDefinitions[splitterIndex - 1].Width;
                    _savedActualValue = parentGrid.ColumnDefinitions[splitterIndex - 1].ActualWidth;

                    // Collapse the previous column
                    if (IsAnimated)
                        AnimateCollapse(parentGrid.ColumnDefinitions[splitterIndex - 1]);
                    else
                        parentGrid.ColumnDefinitions[splitterIndex - 1].SetValue(ColumnDefinition.WidthProperty, new GridLength(0));
                }
            }

        }

public static void SetGridStroke(DependencyObject element, SolidColorBrush value)
        {
            element.SetValue(GridStrokeProperty,value);
        }