예제 #1
0
        /// <summary>
        /// Validates the bindings.
        /// </summary>
        /// <returns></returns>
        public ValidationResult ValidateBindings()
        {
            var result = new ValidationResult();

            foreach(var info in GetBindings())
            {
                var validatedProperty = _element.Type.ValidateAgainst(_element, info.Property, info.Binding);
                result.Add(validatedProperty);
            }

            var triggerValidator = new TriggerValidator(_element.Type, _element, _element.Style.Triggers);
            result.Add(triggerValidator.ValidateBindings());

            return result;
        }
예제 #2
0
        /// <summary>
        /// Validates the bindings.
        /// </summary>
        /// <returns></returns>
        public ValidationResult ValidateBindings()
        {
            var result = new ValidationResult();

            foreach (var info in GetBindings())
            {
                var validatedProperty = element.Type.ValidateAgainst(element, info.Property, info.Binding);
                result.Add(validatedProperty);
            }

            var triggerValidator = new TriggerValidator(element.Type, element, element.Style.Triggers);

            result.Add(triggerValidator.ValidateBindings());

            return(result);
        }
        /// <summary>
        /// Validates the bound item.
        /// </summary>
        /// <returns></returns>
        public new ValidationResult <T> Validate()
        {
            var result      = base.Validate();
            var typedResult = new ValidationResult <T>();

            typedResult.Add(result);

            return(typedResult);
        }
예제 #4
0
        /// <summary>
        /// Validates the bindings.
        /// </summary>
        /// <returns></returns>
        public ValidationResult ValidateBindings()
        {
            var result = new ValidationResult();

            foreach(var info in GetBindings())
            {
                var validatedProperty = Type.ValidateAgainst(item, info.Property, info.Binding);
                result.Add(validatedProperty);
            }

            return result;
        }
예제 #5
0
        /// <summary>
        /// Validates the bindings.
        /// </summary>
        /// <returns></returns>
        public ValidationResult ValidateBindings()
        {
            var result = new ValidationResult();

            foreach (var info in GetBindings())
            {
                var validatedProperty = Type.ValidateAgainst(item, info.Property, info.Binding);
                result.Add(validatedProperty);
            }

            return(result);
        }
        /// <summary>
        /// Validates the bindings.
        /// </summary>
        /// <returns>The result of the validation process.</returns>
        public virtual ValidationResult ValidateBindings()
        {
            var elementResult = new ValidationResult();

            CheckAmbiguities(elementResult);

            if (element.Type == null)
            {
                elementResult.Add(
                    Error.BadDataContext(
                        element,
                        element.Type,
                        FrameworkElement.DataContextProperty
                        )
                    );
            }
            else
            {
                foreach (var info in GetBindings())
                {
                    if (info.Property.Name == "DataContext")
                    {
                        if (element.DataContextCheckType != null)
                        {
                            var validatedProperty = element.DataContextCheckType.ValidateAgainst(element,
                                                                                                 info.Property,
                                                                                                 info.Binding);
                            elementResult.Add(validatedProperty);
                        }
                    }
                    else
                    {
                        var validatedProperty = element.Type.ValidateAgainst(element, info.Property, info.Binding);
                        elementResult.Add(validatedProperty);
                    }
                }
            }

            return(elementResult);
        }
        /// <summary>
        /// Validates the bindings.
        /// </summary>
        /// <returns>The result of the validation process.</returns>
        public virtual ValidationResult ValidateBindings()
        {
            var elementResult = new ValidationResult();

            CheckAmbiguities(elementResult);

            if(_element.Type == null)
            {
                elementResult.Add(
                    Error.BadDataContext(
                        _element,
                        _element.Type,
                        FrameworkElement.DataContextProperty
                        )
                    );
            }
            else
            {
                foreach(var info in GetBindings())
                {
                    if(info.Property.Name == "DataContext")
                    {
                        if(_element.DataContextCheckType != null)
                        {
                            var validatedProperty = _element.DataContextCheckType.ValidateAgainst(_element,
                                                                                                  info.Property,
                                                                                                  info.Binding);
                            elementResult.Add(validatedProperty);
                        }
                    }
                    else
                    {
                        var validatedProperty = _element.Type.ValidateAgainst(_element, info.Property, info.Binding);
                        elementResult.Add(validatedProperty);
                    }
                }
            }

            return elementResult;
        }
        void CheckAmbiguities(ValidationResult result)
        {
            if (element.Element is ContentControl)
            {
                var contentControl = (ContentControl)element.Element;

                if (contentControl.ContentTemplateSelector != null &&
                    contentControl.ContentTemplate != null)
                {
                    result.Add(
                        Error.TemplateSelectorAmbiguity(element, element.Type, "ContentTemplate")
                        );
                }

                if (element.Element is HeaderedContentControl)
                {
                    var headeredContentControl = (HeaderedContentControl)element.Element;

                    if (headeredContentControl.HeaderTemplateSelector != null &&
                        headeredContentControl.HeaderTemplate != null)
                    {
                        result.Add(
                            Error.TemplateSelectorAmbiguity(element, element.Type, "HeaderTemplate")
                            );
                    }
                }
            }
            else if (element.Element is ItemsControl)
            {
                var itemsControl = (ItemsControl)element.Element;

                if (itemsControl.ItemTemplateSelector != null &&
                    itemsControl.ItemTemplate != null)
                {
                    result.Add(
                        Error.TemplateSelectorAmbiguity(element, element.Type, "ItemTemplate")
                        );
                }

                if (itemsControl.ItemContainerStyle != null &&
                    itemsControl.ItemContainerStyleSelector != null)
                {
                    result.Add(
                        Error.StyleSelectorAmbiguity(element, element.Type, "ItemContainerStyle")
                        );
                }

                if (itemsControl.GroupStyle.Count > 0 &&
                    itemsControl.GroupStyleSelector != null)
                {
                    result.Add(
                        Error.StyleSelectorAmbiguity(element, element.Type, "GroupStyle")
                        );
                }

                if (element.Element is HeaderedItemsControl)
                {
                    var headeredItemsControl = (HeaderedItemsControl)element.Element;

                    if (headeredItemsControl.HeaderTemplateSelector != null &&
                        headeredItemsControl.HeaderTemplate != null)
                    {
                        result.Add(
                            Error.TemplateSelectorAmbiguity(element, element.Type, "HeaderTemplate")
                            );
                    }
                }
            }
        }
        private void CheckAmbiguities(ValidationResult result)
        {
            if(_element.Element is ContentControl)
            {
                var contentControl = (ContentControl)_element.Element;

                if(contentControl.ContentTemplateSelector != null &&
                   contentControl.ContentTemplate != null)
                {
                    result.Add(
                        Error.TemplateSelectorAmbiguity(_element, _element.Type, "ContentTemplate")
                        );
                }

                if(_element.Element is HeaderedContentControl)
                {
                    var headeredContentControl = (HeaderedContentControl)_element.Element;

                    if(headeredContentControl.HeaderTemplateSelector != null &&
                       headeredContentControl.HeaderTemplate != null)
                    {
                        result.Add(
                            Error.TemplateSelectorAmbiguity(_element, _element.Type, "HeaderTemplate")
                            );
                    }
                }
            }
            else if(_element.Element is ItemsControl)
            {
                var itemsControl = (ItemsControl)_element.Element;

                if(itemsControl.ItemTemplateSelector != null &&
                   itemsControl.ItemTemplate != null)
                {
                    result.Add(
                        Error.TemplateSelectorAmbiguity(_element, _element.Type, "ItemTemplate")
                        );
                }

                if(itemsControl.ItemContainerStyle != null &&
                   itemsControl.ItemContainerStyleSelector != null)
                {
                    result.Add(
                        Error.StyleSelectorAmbiguity(_element, _element.Type, "ItemContainerStyle")
                        );
                }

                if(itemsControl.GroupStyle.Count > 0 &&
                   itemsControl.GroupStyleSelector != null)
                {
                    result.Add(
                        Error.StyleSelectorAmbiguity(_element, _element.Type, "GroupStyle")
                        );
                }

                if(_element.Element is HeaderedItemsControl)
                {
                    var headeredItemsControl = (HeaderedItemsControl)_element.Element;

                    if(headeredItemsControl.HeaderTemplateSelector != null &&
                       headeredItemsControl.HeaderTemplate != null)
                    {
                        result.Add(
                            Error.TemplateSelectorAmbiguity(_element, _element.Type, "HeaderTemplate")
                            );
                    }
                }
            }
        }