public PropertySettingGroup Deserialize()
        {
            PropertySettingGroup group = new PropertySettingGroup();

            group.BasedOn = this.basedOn;

            if (this.propertySettings != null)
            {
                for (int settingIndex = 0; settingIndex < this.PropertySettings.Count; settingIndex++)
                {
                    XmlPropertySetting xmlPropertySetting = this.PropertySettings[settingIndex];
                    IPropertySetting   setting            = xmlPropertySetting.Deserialize();
                    group.PropertySettings.Add(setting);
                }
            }

            if (this.selectors != null)
            {
                for (int selectorIndex = 0; selectorIndex < this.Selectors.Count; selectorIndex++)
                {
                    XmlElementSelector xmlSelector = this.Selectors[selectorIndex];
                    IElementSelector   selector    = xmlSelector.Deserialize();
                    group.Selectors.Add(selector);
                }
            }

            return(group);
        }
Esempio n. 2
0
 public static string SerializeValue(
     PropertyDescriptor prop,
     object value,
     string propertyDisplayName)
 {
     return(XmlPropertySetting.ConvertValueToString(prop.Converter, value, propertyDisplayName));
 }
Esempio n. 3
0
 public static object DeserializeValue(
     System.Type propertyType,
     string value,
     string propertyDisplayName)
 {
     return(XmlPropertySetting.ConvertValueFromString(TypeDescriptor.GetConverter(propertyType), value, propertyDisplayName, propertyType, false));
 }
Esempio n. 4
0
        public override void GetSetting()
        {
            base.GetSetting();

            this.generalAnimationSettings1.GetValues();
            this.AnimatedSetting.StartValueIsCurrentValue = (this.checkBoxUseCurrentValue.Checked);

            if (!this.checkBoxUseCurrentValue.Checked)
            {
                this.AnimatedSetting.Value = XmlPropertySetting.DeserializeValue(this.Property, this.tbStartRectangle.Text);
            }
            else
            {
                this.AnimatedSetting.Value = null;
            }

            this.AnimatedSetting.StartValueIsCurrentValue = this.checkBoxUseCurrentValue.Checked;
            //   this.AnimatedSetting.ApplyEasingType = this.comboApplyeasing

            if (this.AnimatedSetting.AnimationType == RadAnimationType.ByStartEndValues)
            {
                this.AnimatedSetting.EndValue = XmlPropertySetting.DeserializeValue(Property, this.tbEndRectangle.Text);
            }
            else
            {
                this.AnimatedSetting.Step = XmlAnimatedPropertySetting.SerializeStep(this.GetValidatedPadding(tbStepRectangle.Text));

                if (!checkBoxAutomaticReverse.Checked)
                {
                    this.AnimatedSetting.ReverseStep =
                        XmlAnimatedPropertySetting.SerializeStep(this.GetValidatedPadding(tbReversedStepRectangle.Text));
                }
            }
        }
Esempio n. 5
0
        public static object Deserialize(string fullName, string propertyName, string value)
        {
            if (PropertyReader.directConverters.ContainsKey(propertyName))
            {
                return(PropertyReader.directConverters[propertyName](value));
            }
            if (PropertyReader.typeDescriptorConverters.ContainsKey(propertyName))
            {
                return(PropertyReader.typeDescriptorConverters[propertyName].Converter?.ConvertFromString((ITypeDescriptorContext)null, PropertyReader.serializationCulture, value));
            }
            object obj = (object)null;

            try
            {
                RadProperty property = XmlPropertySetting.DeserializePropertySafe(!string.IsNullOrEmpty(fullName) ? fullName : propertyName);
                if (property != null)
                {
                    obj = XmlPropertySetting.DeserializeValue(property, value);
                }
            }
            catch
            {
            }
            return(obj);
        }
Esempio n. 6
0
        public XmlPropertySettingGroup Serialize()
        {
            XmlPropertySettingGroup xmlGroup = new XmlPropertySettingGroup();

            xmlGroup.BasedOn = this.basedOn;

            for (int settingIndex = 0; settingIndex < this.PropertySettings.OriginalPropertySettings.Count; settingIndex++)
            {
                IPropertySetting setting = this.PropertySettings.OriginalPropertySettings[settingIndex];
                //serialize value;
                XmlPropertySetting xmlSetting = setting.Serialize();
                xmlGroup.PropertySettings.Add(xmlSetting);
            }

            if (this.Selectors.Count > 0)
            {
                for (int selectorIndex = 0; selectorIndex < this.Selectors.Count; selectorIndex++)
                {
                    IElementSelector selector = this.Selectors[selectorIndex];
                    xmlGroup.Selectors.Add(selector.Serialize());
                }
            }

            return(xmlGroup);
        }
Esempio n. 7
0
 public static object DeserializeValue(
     PropertyDescriptor prop,
     string value,
     string propertyDisplayName,
     bool throwOnError)
 {
     return(XmlPropertySetting.ConvertValueFromString(prop.Converter, value, propertyDisplayName, prop.PropertyType, throwOnError));
 }
Esempio n. 8
0
 public RadProperty GetDeserializedProperty()
 {
     if (this.tempPoroperty == null)
     {
         this.tempPoroperty = XmlPropertySetting.DeserializeProperty(this.Property);
     }
     return(this.tempPoroperty);
 }
Esempio n. 9
0
        protected override XmlPropertySetting Serialize()
        {
            XmlPropertySetting xmlPropertySetting = new XmlPropertySetting();

            xmlPropertySetting.Property = this.Property.FullName;
            xmlPropertySetting.Value    = this.valueProviderHelper.UnderlayingValue;//XmlPropertySetting.SerializeValue(this.Property, this.Value);

            return(xmlPropertySetting);
        }
Esempio n. 10
0
 void AddSetting(TreeNode node, XmlPropertySetting setting)
 {
     if (node != null && setting != null)
     {
         TreeNode newNode = new TreeNode(setting.ToString(), 5, 5);
         newNode.Tag = setting;
         node.Nodes.Add(newNode);
     }
 }
Esempio n. 11
0
        public static string SerializeValue(RadProperty property, object value)
        {
            if (value == null)
            {
                return((string)null);
            }
            PropertyDescriptor prop = TypeDescriptor.GetProperties(property.OwnerType).Find(property.Name, true);

            return(prop == null?XmlPropertySetting.ConvertValueToString(TypeDescriptor.GetConverter(property.PropertyType), value, property.FullName) : XmlPropertySetting.SerializeValue(prop, value, property.FullName));
        }
Esempio n. 12
0
        public static object DeserializeValue(RadProperty property, string value, bool throwOnError)
        {
            if (value == null)
            {
                return((object)null);
            }
            PropertyDescriptor prop = TypeDescriptor.GetProperties(property.OwnerType).Find(property.Name, true);

            return(prop == null?XmlPropertySetting.ConvertValueFromString(TypeDescriptor.GetConverter(property.PropertyType), value, property.FullName, property.PropertyType, throwOnError) : XmlPropertySetting.DeserializeValue(prop, value, property.FullName, throwOnError));
        }
Esempio n. 13
0
        private UITypeEditor GetActualEditor(ITypeDescriptorContext context)
        {
            if (context == null)
            {
                return(this.actualEditor);
            }
            XmlPropertySetting instance = (XmlPropertySetting)context.Instance;

            if (instance.Property == null)
            {
                this.actualEditor = (UITypeEditor)null;
                return((UITypeEditor)null);
            }
            string[] strArray = instance.Property.Split('.');
            if (strArray.Length > 1)
            {
                string      propertyName = strArray[strArray.Length - 1];
                string      className    = string.Join(".", strArray, 0, strArray.Length - 1);
                RadProperty safe         = RadProperty.FindSafe(className, propertyName);
                this.currProperty = safe;
                if (safe != null)
                {
                    TypeConverter converter = TypeDescriptor.GetConverter(safe.PropertyType);
                    this.actualPropertyType = safe.PropertyType;
                    if (converter == null || !converter.CanConvertFrom(typeof(string)) || !converter.CanConvertTo(typeof(string)))
                    {
                        if (!converter.CanConvertFrom(typeof(string)))
                        {
                            int num1 = (int)MessageBox.Show("Converter can't convert from string");
                        }
                        else if (!converter.CanConvertTo(typeof(string)))
                        {
                            int num2 = (int)MessageBox.Show("Converter can't convert to string");
                        }
                        else
                        {
                            int num3 = (int)MessageBox.Show("Converter for type not found");
                        }
                        this.actualEditor = (UITypeEditor)null;
                        return((UITypeEditor)null);
                    }
                    this.actualConverter = converter;
                    PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(safe.OwnerType).Find(safe.Name, false);
                    this.actualEditor = propertyDescriptor == null ? (UITypeEditor)TypeDescriptor.GetEditor(safe.PropertyType, typeof(UITypeEditor)) : (UITypeEditor)propertyDescriptor.GetEditor(typeof(UITypeEditor));
                    return(this.actualEditor);
                }
                int num = (int)MessageBox.Show("Can't find property " + instance.Property + ". Property " + propertyName + "not registered for RadObject" + className);
                this.actualEditor = (UITypeEditor)null;
                return((UITypeEditor)null);
            }
            int num4 = (int)MessageBox.Show("Invalid property name. Property consist of type FullName\".\"PropertyName.");

            this.actualEditor = (UITypeEditor)null;
            return((UITypeEditor)null);
        }
Esempio n. 14
0
 private TypeConverter GetUnderlayingConverter(ITypeDescriptorContext context)
 {
     if (this.underlayingConverter == null || context != this.currContext)
     {
         this.currContext = context;
         if (context == null)
         {
             return(this.underlayingConverter);
         }
         XmlPropertySetting instance = (XmlPropertySetting)context.Instance;
         if (string.IsNullOrEmpty(instance.Property))
         {
             this.underlayingConverter = (TypeConverter)null;
             return((TypeConverter)null);
         }
         string[] strArray = instance.Property.Split('.');
         if (strArray.Length <= 1)
         {
             throw new Exception("Invalid property name. Property consist of type FullName \".\" and property name.");
         }
         string      propertyName = strArray[strArray.Length - 1];
         string      className    = string.Join(".", strArray, 0, strArray.Length - 1);
         RadProperty safe         = RadProperty.FindSafe(className, propertyName);
         if (safe != null)
         {
             TypeConverter converter = TypeDescriptor.GetConverter(safe.PropertyType);
             if (converter == null || !converter.CanConvertFrom(typeof(string)) || !converter.CanConvertTo(typeof(string)))
             {
                 if (!converter.CanConvertFrom(typeof(string)))
                 {
                     int num1 = (int)MessageBox.Show("Converter can't convert from string");
                 }
                 else if (!converter.CanConvertTo(typeof(string)))
                 {
                     int num2 = (int)MessageBox.Show("Converter can't convert to string");
                 }
                 else
                 {
                     int num3 = (int)MessageBox.Show("Converter for type not found");
                 }
             }
             this.hasEditor            = (UITypeEditor)TypeDescriptor.GetEditor(safe.PropertyType, typeof(UITypeEditor)) != null;
             this.underlayingConverter = converter;
         }
         else
         {
             int num = (int)MessageBox.Show("Can't find property " + instance.Property + ". Property " + propertyName + " not registered for " + className);
             this.underlayingConverter = (TypeConverter)null;
             return((TypeConverter)null);
         }
     }
     return(this.underlayingConverter);
 }
Esempio n. 15
0
        public virtual IPropertySetting Deserialize()
        {
            if (string.IsNullOrEmpty(this.Property))
            {
                throw new InvalidOperationException("Property to deserialize is null or empty");
            }
            PropertySetting propertySetting = new PropertySetting()
            {
                Property = XmlPropertySetting.DeserializeProperty(this.Property)
            };

            propertySetting.Value = this.GetConvertedValue(propertySetting.Property, this.Value);
            return((IPropertySetting)propertySetting);
        }
        public override IPropertySetting Deserialize()
        {
            AnimatedPropertySetting animatedPropertySetting = new AnimatedPropertySetting();

            animatedPropertySetting.Property = XmlPropertySetting.DeserializeProperty(this.Property);
            if (!this.StartValueIsCurrentValue)
            {
                animatedPropertySetting.StartValue = this.GetConvertedValue(animatedPropertySetting.Property, this.Value);
            }
            animatedPropertySetting.Interval        = this.Interval;
            animatedPropertySetting.NumFrames       = this.NumFrames;
            animatedPropertySetting.ApplyEasingType = this.ApplyEasingType;
            animatedPropertySetting.EndValue        = this.GetConvertedValue(animatedPropertySetting.Property, this.EndValue);
            return((IPropertySetting)animatedPropertySetting);
        }
Esempio n. 17
0
        private void addPropertySettingToolStripMenuItem_Click(object sender, EventArgs e)
        {
            XmlPropertySetting setting = null;

            switch (((ToolStripMenuItem)sender).Name)
            {
            case "AnimatedPropertySetting": setting = new XmlAnimatedPropertySetting(); break;

            case "PropertySetting": setting = new XmlPropertySetting(); break;
            }

            if (tvPropertySettingGroups.SelectedNode != null)
            {
                AddSetting(tvPropertySettingGroups.SelectedNode, setting);
                XmlPropertySettingGroup group = (XmlPropertySettingGroup)tvPropertySettingGroups.SelectedNode.Parent.Tag;
                group.PropertySettings.Add(setting);
                tvPropertySettingGroups.SelectedNode.Expand();
            }
        }
Esempio n. 18
0
 private static RadProperty DeserializePropertyCore(
     string property,
     bool fallback,
     bool throwOnError)
 {
     if (string.IsNullOrEmpty(property))
     {
         return((RadProperty)null);
     }
     string[] strArray = property.Split('.');
     if (strArray.Length > 1)
     {
         string      propertyName = strArray[strArray.Length - 1];
         string      className    = string.Join(".", strArray, 0, strArray.Length - 1);
         System.Type typeByName   = RadTypeResolver.Instance.GetTypeByName(className);
         if ((object)typeByName == null)
         {
             if (throwOnError)
             {
                 throw new InvalidOperationException("Could not look-up type '" + className + "'");
             }
             return((RadProperty)null);
         }
         RadProperty property1 = XmlPropertySetting.FindProperty(typeByName, propertyName, fallback);
         if (property1 != null)
         {
             return(property1);
         }
         if (!throwOnError)
         {
             return((RadProperty)null);
         }
         return(XmlPropertySetting.ProcessDuplicateAssemblies(propertyName, className));
     }
     if (throwOnError)
     {
         throw new Exception("Invalid property parts");
     }
     return((RadProperty)null);
 }
Esempio n. 19
0
        private void RectangleAnimationForm_Load(object sender, EventArgs e)
        {
            if (AnimatedSetting.Value != null)
            {
                this.tbStartRectangle.Text           = XmlPropertySetting.SerializeValue(this.Property, AnimatedSetting.Value);
                this.checkBoxUseCurrentValue.Checked = false;
            }
            else
            {
                this.checkBoxUseCurrentValue.Checked = true;
            }

            if (AnimatedSetting.EndValue != null)
            {
                this.tbEndRectangle.Text = XmlPropertySetting.SerializeValue(this.Property, AnimatedSetting.EndValue);
            }

            if (AnimatedSetting.Step != null)
            {
                //TODO: What if the step is different type?
                this.tbStepRectangle.Text = AnimatedSetting.Step.Value;
            }
            else
            {
                this.checkBoxUseCurrentValue.Checked = true;
            }

            if (AnimatedSetting.ReverseStep != null)
            {
                //TODO: What if the step is different type?
                this.tbReversedStepRectangle.Text = AnimatedSetting.ReverseStep.Value;
            }

            if (AnimatedSetting.ReverseStep == null)
            {
                this.checkBoxAutomaticReverse.Checked = true;
            }
        }
Esempio n. 20
0
        private void SizeAnimationForm_Load(object sender, EventArgs e)
        {
            Decimal minValue      = Decimal.MinValue;
            Decimal maxValue      = Decimal.MaxValue;
            int     decimalPlaces = 0;

            if (Property.PropertyType == typeof(float))
            {
                decimalPlaces = 2;
            }
            else if (Property.PropertyType == typeof(double))
            {
                decimalPlaces = 3;
            }

            this.numericUpDownStart1.Minimum            = minValue;
            this.numericUpDownStart1.Maximum            = maxValue;
            this.numericUpDownStart1.DecimalPlaces      = decimalPlaces;
            this.numericUpDownEnd1.Minimum              = minValue;
            this.numericUpDownEnd1.Maximum              = maxValue;
            this.numericUpDownEnd1.DecimalPlaces        = decimalPlaces;
            this.numericUpDownStep.Minimum              = minValue;
            this.numericUpDownStep.Maximum              = maxValue;
            this.numericUpDownStep.DecimalPlaces        = decimalPlaces;
            this.numericUpDownReverseStep.Minimum       = minValue;
            this.numericUpDownReverseStep.Maximum       = maxValue;
            this.numericUpDownReverseStep.DecimalPlaces = decimalPlaces;

            if (AnimatedSetting.Value != null)
            {
                if (Property.PropertyType == typeof(Size))
                {
                    Size size = (Size)AnimatedSetting.Value;
                    this.numericUpDownStart1.Value = Convert.ToDecimal(size.Width);
                    this.numericUpDownEnd1.Value   = Convert.ToDecimal(size.Height);
                }

                if (this.numericUpDownStart1.Value == 0)
                {
                    this.checkBoxUseCurrentValue.Checked = true;
                }
            }
            if (AnimatedSetting.EndValue != null)
            {
                Size size = (Size)AnimatedSetting.EndValue;

                this.numericUpDownStart2.Value = Convert.ToDecimal(size.Width);
                this.numericUpDownEnd2.Value   = Convert.ToDecimal(size.Height);
            }

            if (AnimatedSetting.Step != null)
            {
                this.numericUpDownStep.Value = Convert.ToDecimal(XmlPropertySetting.DeserializeValue(Property, AnimatedSetting.Step.Value));
            }
            if (AnimatedSetting.ReverseStep != null)
            {
                this.numericUpDownReverseStep.Value = Convert.ToDecimal(XmlPropertySetting.DeserializeValue(Property, AnimatedSetting.ReverseStep.Value));
            }
            else
            {
                this.checkBoxAutomaticReverse.Checked = true;
                this.numericUpDownReverseStep.Enabled = false;
            }
        }
Esempio n. 21
0
        private TypeConverter GetUnderlayingConverter(ITypeDescriptorContext context)
        {
            if (underlayingConverter == null || context != currContext)
            {
                currContext = context;
                if (context == null)
                {
                    return(underlayingConverter);
                }
                XmlPropertySetting setting = (XmlPropertySetting)context.Instance;
                //Find property
                //setting.Property
                //Find type converter
                //Convert value
                //Find corresponding UITypeEditor
                //Edit converted value

                if (string.IsNullOrEmpty(setting.Property))
                {
                    this.underlayingConverter = null;
                    return(null);
                }

                string[] propertyParts = setting.Property.Split('.');
                string   propertyName;
                string   className;
                if (propertyParts.Length > 1)
                {
                    propertyName = propertyParts[propertyParts.Length - 1];
                    className    = string.Join(".", propertyParts, 0, propertyParts.Length - 1);
                }
                else
                {
                    throw new Exception("Invalid property name. Property consist of type FullName \".\" and property name.");
                }

                RadProperty prop = RadProperty.FindSafe(className, propertyName);

                //this.actualProperty = prop;

                TypeConverter converter;

                if (prop != null)
                {
                    converter = TypeDescriptor.GetConverter(prop.PropertyType);
                }
                else
                {
                    MessageBox.Show("Can't find property " + setting.Property + ". Property " + propertyName + " not registered for " + className);
                    this.underlayingConverter = null;
                    return(null);
                }


                if (converter == null ||
                    !converter.CanConvertFrom(typeof(string)) ||
                    !converter.CanConvertTo(typeof(string)))
                {
                    if (!converter.CanConvertFrom(typeof(string)))
                    {
                        MessageBox.Show("Converter can't convert from string");
                    }
                    else
                    if (!converter.CanConvertTo(typeof(string)))
                    {
                        MessageBox.Show("Converter can't convert to string");
                    }
                    else
                    {
                        MessageBox.Show("Converter for type not found");
                    }
                }


                UITypeEditor editor = (UITypeEditor)TypeDescriptor.GetEditor(prop.PropertyType, typeof(UITypeEditor));
                hasEditor = editor != null;

                underlayingConverter = converter;
            }

            return(underlayingConverter);
        }
Esempio n. 22
0
        private UITypeEditor GetActualEditor(ITypeDescriptorContext context)
        {
            if (context == null)
            {
                return(actualEditor);
            }

            XmlPropertySetting setting = (XmlPropertySetting)context.Instance;

            //Find property
            //setting.Property
            //Find type converter
            //Convert value
            //Find corresponding UITypeEditor
            //Edit converted value

            if (setting.Property == null)
            {
                this.actualEditor = null;
                return(null);
            }

            string[] propertyParts = setting.Property.Split('.');
            string   propertyName;
            string   className;

            if (propertyParts.Length > 1)
            {
                propertyName = propertyParts[propertyParts.Length - 1];
                className    = string.Join(".", propertyParts, 0, propertyParts.Length - 1);
            }
            else
            {
                MessageBox.Show("Invalid property name. Property consist of type FullName\".\"PropertyName.");
                this.actualEditor = null;
                return(null);
            }

            RadProperty prop = RadProperty.FindSafe(className, propertyName);

            this.currProperty = prop;

            TypeConverter converter;

            if (prop != null)
            {
                converter = TypeDescriptor.GetConverter(prop.PropertyType);
            }
            else
            {
                MessageBox.Show("Can't find property " + setting.Property + ". Property " + propertyName + "not registered for RadObject" + className);
                this.actualEditor = null;
                return(null);
            }

            this.actualPropertyType = prop.PropertyType;

            if (converter == null ||
                !converter.CanConvertFrom(typeof(string)) ||
                !converter.CanConvertTo(typeof(string)))
            {
                if (!converter.CanConvertFrom(typeof(string)))
                {
                    MessageBox.Show("Converter can't convert from string");
                }
                else
                if (!converter.CanConvertTo(typeof(string)))
                {
                    MessageBox.Show("Converter can't convert to string");
                }
                else
                {
                    MessageBox.Show("Converter for type not found");
                }

                this.actualEditor = null;
                return(null);
            }

            this.actualConverter = converter;

            PropertyDescriptor actualProperty = TypeDescriptor.GetProperties(prop.OwnerType).Find(prop.Name, false);

            if (actualProperty != null)
            {
                this.actualEditor = (UITypeEditor)actualProperty.GetEditor(typeof(UITypeEditor));
            }
            else
            {
                this.actualEditor = (UITypeEditor)TypeDescriptor.GetEditor(prop.PropertyType, typeof(UITypeEditor));
            }


            return(actualEditor);
        }
Esempio n. 23
0
        /// <summary>
        /// This method supports TPF infrastructure and is intended for internal use only.
        /// </summary>
        /// <param name="applyUnconditional"></param>
        /// <param name="groups"></param>
        /// <returns></returns>
        public StyleSheet GetStyleSheet(XmlSelectorBase applyUnconditional, XmlPropertySettingGroup[] groups)
        {
            StyleSheet   res           = new StyleSheet();
            SelectorBase applySelector = null;

            if (this.PropertySettingGroups == null)
            {
                return(res);
            }

            for (int i = 0; i < this.PropertySettingGroups.Count; i++)
            {
                XmlPropertySettingGroup xmlGroup = this.PropertySettingGroups[i];
                if (xmlGroup.Selectors != null)
                {
                    for (int selectorIndex = 0; selectorIndex < xmlGroup.Selectors.Count; selectorIndex++)
                    {
                        XmlElementSelector xmlSelector = xmlGroup.Selectors[selectorIndex];
                        if (xmlSelector == applyUnconditional)
                        {
                            applySelector = (SelectorBase)xmlSelector.Deserialize();
                            break;
                        }
                    }
                }
            }

            for (int i = 0; i < this.PropertySettingGroups.Count; i++)
            {
                XmlPropertySettingGroup xmlGroup = this.PropertySettingGroups[i];
                PropertySettingGroup    group    = new PropertySettingGroup();

                if (xmlGroup.PropertySettings == null ||
                    xmlGroup.Selectors == null)
                {
                    continue;
                }

                bool disable = false;
                if (applyUnconditional != null)
                {
                    for (int groupIndex = 0; groupIndex < groups.Length; groupIndex++)
                    {
                        XmlPropertySettingGroup g = groups[groupIndex];
                        if (g == xmlGroup)
                        {
                            disable = true;
                            break;
                        }
                    }
                }

                for (int settingIndex = 0; settingIndex < xmlGroup.PropertySettings.Count; settingIndex++)
                {
                    XmlPropertySetting xmlPropertySetting = xmlGroup.PropertySettings[settingIndex];
                    IPropertySetting   setting            = xmlPropertySetting.Deserialize();
                    group.PropertySettings.Add(setting);
                }

                //IElementSelector activeSelector = null;

                for (int selectorIndex = 0; selectorIndex < xmlGroup.Selectors.Count; selectorIndex++)
                {
                    XmlElementSelector xmlSelector = xmlGroup.Selectors[selectorIndex];
                    IElementSelector   selector    = null;
                    selector = xmlSelector.Deserialize();

                    if (xmlSelector == applyUnconditional)
                    {
                        applySelector.IsActiveSelectorInStyleBuilder = true;
                        selector = applySelector;
                        //continue;
                    }
                    else if (disable)
                    {
                        ((SelectorBase)selector).DisableStyle = true;
                        //((SelectorBase)selector).ExcludeSelector = applySelector;
                    }

                    group.Selectors.Add(selector);
                }

                //if (activeSelector != null)
                //	group.Selectors.Insert(0, activeSelector);

                res.PropertySettingGroups.Add(group);
            }

            return(res);
        }
Esempio n. 24
0
 public static RadProperty DeserializePropertySafe(string property)
 {
     return(XmlPropertySetting.DeserializePropertyCore(property, true, false));
 }
Esempio n. 25
0
 public static object DeserializeValue(RadProperty property, string value)
 {
     return(XmlPropertySetting.DeserializeValue(property, value, false));
 }