Condition.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Condition.cs / 1 / Condition.cs

                            using MS.Utility; 
using System.IO;
using System.Windows.Markup;
using System.ComponentModel;
 
using System;
using System.Windows.Data; 
 
namespace System.Windows
{ 
    /// 
    ///     Condition for a multiple property or data trigger
    /// 
    public sealed class Condition 
    {
        ///  
        ///     Constructor with no property reference nor value 
        /// 
        public Condition() 
        {
            _property = null;
            _binding = null;
        } 

        ///  
        ///     Constructor for creating a Condition 
        /// 
        public Condition( DependencyProperty conditionProperty, object conditionValue ) : 
            this(conditionProperty, conditionValue, null)
        {
            // Call Forwarded
        } 

        ///  
        ///     Constructor for creating a Condition with the given property 
        /// and value instead of creating an empty one and setting values later.
        ///  
        /// 
        ///     This constructor does parameter validation, which before doesn't
        /// happen until Seal() is called.  We can do it here because we get
        /// both at the same time. 
        /// 
        public Condition( DependencyProperty conditionProperty, object conditionValue, string sourceName ) 
        { 
            if( conditionProperty == null )
            { 
                throw new ArgumentNullException("conditionProperty");
            }

            if( !conditionProperty.IsValidValue( conditionValue ) ) 
            {
                throw new ArgumentException(SR.Get(SRID.InvalidPropertyValue, conditionValue, conditionProperty.Name)); 
            } 

            _property = conditionProperty; 
            Value    = conditionValue;
            _sourceName = sourceName;
        }
 
        /// 
        ///     Constructor for creating a Condition with the given binding declaration. 
        /// and value. 
        /// 
        public Condition( BindingBase binding, object conditionValue ) 
        {
            if( binding == null )
            {
                throw new ArgumentNullException("binding"); 
            }
 
            Binding = binding; 
            Value  = conditionValue;
        } 

        /// 
        ///     DepedencyProperty of the conditional
        ///  
        [DefaultValue(null)]
        public DependencyProperty Property 
        { 
            get { return _property; }
            set 
            {
                if (_sealed)
                {
                    throw new InvalidOperationException(SR.Get(SRID.CannotChangeAfterSealed, "Condition")); 
                }
 
                if( _binding != null ) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.ConditionCannotUseBothPropertyAndBinding)); 
                }

                _property = value;
            } 
        }
 
        ///  
        ///     Binding of the conditional
        ///  
        [DefaultValue(null)]
        public BindingBase Binding
        {
            get { return _binding; } 
            set
            { 
                if (_sealed) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.CannotChangeAfterSealed, "Condition")); 
                }

                if( _property != null )
                { 
                    throw new InvalidOperationException(SR.Get(SRID.ConditionCannotUseBothPropertyAndBinding));
                } 
 
                _binding = value;
            } 
        }

        /// 
        ///     Value of the condition (equality check) 
        /// 
        public object Value 
        { 
            get { return _value; }
            set 
            {
                if (_sealed)
                {
                    throw new InvalidOperationException(SR.Get(SRID.CannotChangeAfterSealed, "Condition")); 
                }
 
                if (value is MarkupExtension) 
                {
                    throw new ArgumentException(SR.Get(SRID.ConditionValueOfMarkupExtensionNotSupported, 
                                                       value.GetType().Name));
                }

                if( value is Expression ) 
                {
                    throw new ArgumentException(SR.Get(SRID.ConditionValueOfExpressionNotSupported)); 
                } 

                _value = value; 
            }
        }

        ///  
        /// The x:Name of the object whose property shall
        /// trigger the associated setters to be applied. 
        /// If null, then this is the object being Styled 
        /// and not anything under its Template Tree.
        ///  
        [DefaultValue(null)]
        public string SourceName
        {
            get 
            {
                return _sourceName; 
            } 
            set
            { 
                if( _sealed )
                {
                    throw new InvalidOperationException(SR.Get(SRID.CannotChangeAfterSealed, "Condition"));
                } 

                _sourceName = value; 
            } 
        }
 
        /// 
        ///     Seal the condition so that it can no longer be modified
        /// 
        internal void Seal(ValueLookupType type) 
        {
            if (_sealed) 
            { 
                return;
            } 

            _sealed = true;

            // Ensure valid condition 
            if (_property != null && _binding != null)
                throw new InvalidOperationException(SR.Get(SRID.ConditionCannotUseBothPropertyAndBinding)); 
 
            switch (type)
            { 
                case ValueLookupType.Trigger:
                case ValueLookupType.PropertyTriggerResource:
                    if (_property == null)
                    { 
                        throw new InvalidOperationException(SR.Get(SRID.NullPropertyIllegal, "Property"));
                    } 
 
                    if (!_property.IsValidValue(_value))
                    { 
                        throw new InvalidOperationException(SR.Get(SRID.InvalidPropertyValue, _value, _property.Name));
                    }
                    break;
 
                case ValueLookupType.DataTrigger:
                case ValueLookupType.DataTriggerResource: 
                    if (_binding == null) 
                    {
                        throw new InvalidOperationException(SR.Get(SRID.NullPropertyIllegal, "Binding")); 
                    }
                    break;

                default: 
                    throw new InvalidOperationException(SR.Get(SRID.UnexpectedValueTypeForCondition, type));
            } 
 
            // Freeze the condition value
            StyleHelper.SealIfSealable(_value); 
        }


        private bool _sealed = false; 

        private DependencyProperty _property; 
        private BindingBase _binding; 
        private object _value = DependencyProperty.UnsetValue;
        private string _sourceName = null; 
    }
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK