Example #1
0
        internal virtual void ParseKnownAttributes(AttributesHelper attributes, ParseResult result, string baseUri, bool addImageQuery)
        {
            // version is optional
            int version;

            if (TryParse(result, attributes, ATTR_VISUAL_VERSION, out version))
            {
                this.Version = version;
            }

            if (Context != NotificationType.Toast)
            {
                // Branding is optional
                Branding branding;
                if (TryParseEnum(result, attributes, ATTR_VISUAL_BRANDING, out branding, false)) // not case-sensitive
                {
                    this.Branding = branding;
                }

                // DisplayName is optional
                XAttribute attrDisplayName = attributes.PopAttribute(ATTR_VISUAL_DISPLAY_NAME, false); // not case-sensitive
                if (attrDisplayName != null)
                {
                    this.DisplayName = attrDisplayName.Value;
                }
            }
        }
        /// <summary>
        ///     Creates a new Detour.
        /// </summary>
        /// <param name="target">
        ///     The original function to detour. (This delegate should already be registered via
        ///     Magic.RegisterDelegate)
        /// </param>
        /// <param name="newTarget">The new function to be called. (This delegate should NOT be registered!)</param>
        /// <param name="name">The name of the detour.</param>
        /// <returns>
        ///     A <see cref="Detour" /> object containing the required methods to apply, remove, and call the original
        ///     function.
        /// </returns>
        public Detour Create(Delegate target, Delegate newTarget, string name)
        {
            if (target == null)
            {
                throw new ArgumentNullException(nameof(target));
            }
            if (newTarget == null)
            {
                throw new ArgumentNullException(nameof(newTarget));
            }
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException(nameof(name));
            }
            if (!AttributesHelper.HasUfpAttribute(target))
            {
                throw new Exception(
                          "The target delegate does not have the proper UnmanagedFunctionPointer attribute!");
            }
            if (!AttributesHelper.HasUfpAttribute(newTarget))
            {
                throw new Exception(
                          "The new target delegate does not have the proper UnmanagedFunctionPointer attribute!");
            }

            if (InternalItems.ContainsKey(name))
            {
                throw new ArgumentException($"The {name} detour already exists!", nameof(name));
            }
            InternalItems[name] = new Detour(target, newTarget, name, MemoryPlus);
            return(InternalItems[name]);
        }
        internal void ParseActivatableElementAttributes(XElement node, AttributesHelper attributes, ParseResult result)
        {
            IActivatableElement el = this as IActivatableElement;

            // activationType is optional
            ActivationType type;

            if (TryParseEnum(result, attributes, ATTR_ACTIVATIONTYPE, out type))
            {
                el.ActivationType = type;
            }


            // arguments is required
            XAttribute attrArguments = attributes.PopAttribute(ATTR_ARGUMENTS);

            if (attrArguments == null)
            {
                // If we're in an activation type that requires attributes
                if (el.ActivationType != ActivationType.None)
                {
                    result.AddErrorButRenderAllowed("arguments attribute is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                    throw new IncompleteElementException();
                }
            }

            else
            {
                el.Arguments = attrArguments.Value;
            }
        }
Example #4
0
        /// <summary>Annotates the specified tree node.</summary>
        /// <param name="treeNode">The tree node.</param>
        /// <param name="attribute">The attribute.</param>
        public static void Annotate(this ITreeNode treeNode, CodeAnnotationAttribute attribute)
        {
            var owner = treeNode as IAttributesOwnerDeclaration;

            if (owner == null)
            {
                return;
            }

            string attributeName;

            switch (attribute)
            {
            case CodeAnnotationAttribute.NotNull:
                attributeName = CodeAnnotationsCache.NotNullAttributeShortName;
                break;

            case CodeAnnotationAttribute.CanBeNull:
                attributeName = CodeAnnotationsCache.CanBeNullAttributeShortName;
                break;

            default:
                return;
            }

            AttributesHelper.SetAttribute(owner, attributeName);
        }
Example #5
0
        internal override void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result, string baseUri, bool addImageQuery)
        {
            base.ParseKnownAttributes(node, attributes, result, baseUri, addImageQuery);

            // placement defaults to inline
            Placement placement;

            if (TryParseEnum(result, attributes, ATTR_IMAGE_PLACEMENT, out placement))
            {
                this.Placement = placement;
            }

            // hint-removeMargin is optional
            bool hintRemoveMargin;

            if (TryParse(result, attributes, ATTR_IMAGE_HINT_REMOVE_MARGIN, out hintRemoveMargin))
            {
                this.HintRemoveMargin = hintRemoveMargin;
            }

            // hint-align is optional
            HintImageAlign hintAlign;

            if (TryParseEnum(result, attributes, ATTR_IMAGE_HINT_ALIGN, out hintAlign))
            {
                this.HintAlign = hintAlign;
            }
        }
Example #6
0
        internal virtual void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result, string baseUri, bool addImageQuery)
        {
            // src is required
            XAttribute attrSrc = attributes.PopAttribute(ATTR_IMAGE_SRC);

            if (attrSrc == null)
            {
                result.AddError("src attribute on image element is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            this.Src = XmlTemplateParser.ConstructUri(attrSrc.Value, baseUri, addImageQuery);



            // alt is optional, I don't use it right now either
            attributes.PopAttribute(ATTR_IMAGE_ALT);


            // hint-crop is optional
            HintCrop hintCrop;

            if (TryParseEnum(result, attributes, ATTR_IMAGE_HINT_CROP, out hintCrop))
            {
                this.HintCrop = hintCrop;
            }
        }
Example #7
0
        internal void Parse(ParseResult result, XElement node, string baseUri, bool addImageQuery)
        {
            if (!XmlTemplateParser.EnsureNodeOnlyHasElementsAsChildren(result, node))
            {
                throw new IncompleteElementException();
            }

            AttributesHelper attributes = new AttributesHelper(node.Attributes());



            ParseKnownAttributes(node, attributes, result, baseUri, addImageQuery);

            HandleRemainingAttributes(attributes, result);

            // 0-n children
            foreach (XElement child in node.Elements())
            {
                try
                {
                    HandleChild(result, child, baseUri, addImageQuery);
                }

                catch (IncompleteElementException)
                {
                }
            }
        }
Example #8
0
        internal bool TryParseEnum <TEnum>(ParseResult result, AttributesHelper attributes, string attributeName, out TEnum answer, bool caseSensitive = true) where TEnum : struct, IConvertible
        {
            XAttribute attr = attributes.PopAttribute(attributeName, caseSensitive);

            // If it has the attribute
            if (attr != null)
            {
                // And the attribute has a value
                if (attr.Value != null)
                {
                    if (TryParseEnum(attr.Value, out answer))
                    {
                        return(true);
                    }

                    // Couldn't find matching enum
                    result.AddWarning($@"Unknown value ""{attr.Value}"" on {attributeName} attribute", GetErrorPositionInfo(attr));

                    if (TryGetUnknownEnum(out answer))
                    {
                        return(true);
                    }
                }

                // Attribute doesn't have a value
                else
                {
                    result.AddWarning($@"Attribute {attributeName} has no value specified", GetErrorPositionInfo(attr));
                }
            }

            // Attribute isn't found, no warning
            answer = default(TEnum);
            return(false);
        }
        internal virtual void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result)
        {
            // id is required
            XAttribute attrId = attributes.PopAttribute(ATTR_ID);

            if (attrId == null)
            {
                result.AddError("id attribute on action element is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            this.Id = attrId.Value;


            // arguments is required
            XAttribute attrArguments = attributes.PopAttribute(ATTR_ARGUMENTS);

            if (attrArguments == null)
            {
                result.AddErrorButRenderAllowed("arguments attribute on action element is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            this.Arguments = attrArguments.Value;


            // activationType is optional
            ActivationType type;

            if (TryParseEnum(result, attributes, ATTR_ACTIVATIONTYPE, out type))
            {
                this.ActivationType = type;
            }
        }
Example #10
0
        internal virtual void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result)
        {
            // src is optional
            var srcAttr = attributes.PopAttribute(ATTR_SRC);

            if (srcAttr != null)
            {
                Uri srcUri;
                if (Uri.TryCreate(srcAttr.Value, UriKind.RelativeOrAbsolute, out srcUri))
                {
                    Src = srcUri;
                }
                else
                {
                    result.AddWarning("Audio src value must be a valid Uri.", XmlTemplateParser.GetErrorPositionInfo(node));
                }
            }

            // loop is optional, must be bool
            bool boolean;

            if (TryParse(result, attributes, ATTR_LOOP, out boolean))
            {
                Loop = boolean;
            }

            if (TryParse(result, attributes, ATTR_SILENT, out boolean))
            {
                Silent = boolean;
            }
        }
Example #11
0
        public static PropertyColumnMetamodel Create(LambdaExpression property, int width, ColumnWidthMode widthMode, FilterMetamodel filterMetamodel)
        {
            var name    = ObjectHelper.GetPropertyName(property);
            var caption = AttributesHelper.GetPropertyDisplayName(property) ?? property.Name;   // TODO: maybe better to provide explicite caption parameter?

            return(new PropertyColumnMetamodel(name, caption, width, widthMode, property.ReturnType, filterMetamodel));
        }
Example #12
0
        internal void Parse(ParseResult result, XElement node)
        {
            if (!XmlTemplateParser.EnsureNodeOnlyHasElementsAsChildren(result, node))
            {
                throw new IncompleteElementException();
            }

            AttributesHelper attributes = new AttributesHelper(node.Attributes());



            ParseKnownAttributes(node, attributes, result);

            HandleRemainingAttributes(attributes, result);

            // 0-n children
            foreach (XElement child in node.Elements())
            {
                if (!result.IsOkForRender())
                {
                    break;
                }

                try
                {
                    HandleChild(result, child);
                }

                catch (IncompleteElementException)
                {
                }
            }
        }
Example #13
0
        internal void Parse(ParseResult result, XElement node)
        {
            AttributesHelper attributes = new AttributesHelper(node.Attributes());

            ParseKnownAttributes(node, attributes, result);

            HandleRemainingAttributes(attributes, result);

            // 0-n children
            foreach (XElement child in node.Elements())
            {
                if (!result.IsOkForRender())
                {
                    break;
                }

                try
                {
                    HandleChild(result, child);
                }

                catch (IncompleteElementException)
                {
                }
            }
        }
Example #14
0
 static Scanner()
 {
     ConstantTokensLookup = AttributesHelper.GetLookUpTable <Token, ConstantTokenAttribute>()
                            .ToDictionary(x => x.Value.ReservedWord, x => x.Key);
     PatternTokensLookup = AttributesHelper.GetLookUpTable <Token, PatternTokenAttribute>();
     IgnoredTokensLookup = AttributesHelper.GetLookUpTable <Token, IgnoredTokenAttribute>();
 }
Example #15
0
        public void Test__GetPropertyAttributeValues__Working()
        {
            var name        = AttributesHelper.GetPropertyAttributeValue <TestViewModel, DisplayAttribute, string>(x => x.Title, a => a.Name);
            var description = AttributesHelper.GetPropertyAttributeValue <TestViewModel, DisplayAttribute, string>(x => x.TypeName, a => a.Description);

            Assert.That(name, Is.EqualTo("Tytuł"));
            Assert.That(description, Is.EqualTo("Coś"));
        }
Example #16
0
        internal void Parse(ParseResult result, XElement node)
        {
            AttributesHelper attributes = new AttributesHelper(node.Attributes());

            ParseKnownAttributes(node, attributes, result);

            HandleRemainingAttributes(attributes, result);
        }
Example #17
0
        internal void Parse(ParseResult result, XElement node, string baseUri, bool addImageQuery)
        {
            AttributesHelper attributes = new AttributesHelper(node.Attributes());

            ParseKnownAttributes(node, attributes, result, baseUri, addImageQuery);

            HandleRemainingAttributes(attributes, result);
        }
        private void ParseHintWeight(AttributesHelper attributes, ParseResult result)
        {
            int hintWeight;

            if (TryParse(result, attributes, ATTR_SUBGROUP_HINT_WEIGHT, out hintWeight))
            {
                this.HintWeight = hintWeight;
            }
        }
        internal void ParseKnownAttributes(AttributesHelper attributes, ParseResult result, bool isBindingRootLevel)
        {
            // Max lines is supported on non-toasts, and adaptive toasts, and group/subgroups
            if (Context != NotificationType.Toast || SupportedFeatures.AdaptiveToasts || !isBindingRootLevel)
            {
                // hint-max-lines is optional
                int hintMaxLines;
                if (TryParse(result, attributes, ATTR_TEXT_HINT_MAX_LINES, out hintMaxLines))
                {
                    this.HintMaxLines = hintMaxLines;
                }
            }

            // These features are supported on non-toasts, and group/subgroups
            if (Context != NotificationType.Toast || !isBindingRootLevel)
            {
                // hint-align is optional
                HintAlign hintAlign;
                if (TryParseEnum(result, attributes, ATTR_TEXT_HINT_ALIGN, out hintAlign))
                {
                    this.HintAlign = hintAlign;
                }

                // hint-min-lines is optional
                int hintMinLines;
                if (TryParse(result, attributes, ATTR_TEXT_HINT_MIN_LINES, out hintMinLines))
                {
                    this.HintMinLines = hintMinLines;
                }

                // hint-style is optional
                HintStyle hintStyle;
                if (TryParseEnum(result, attributes, ATTR_TEXT_HINT_STYLE, out hintStyle))
                {
                    this.HintStyle = hintStyle;
                }

                // hint-wrap is optional
                bool hintWrap;
                if (TryParse(result, attributes, ATTR_TEXT_HINT_WRAP, out hintWrap))
                {
                    this.HintWrap = hintWrap;
                }
            }

            if (Context == NotificationType.Tile)
            {
                Id = attributes.PopAttributeValue(ATTR_TEXT_ID);
            }

            TextPlacement placement;

            if (TryParseEnum(result, attributes, ATTR_TEXT_PLACEMENT, out placement))
            {
                this.Placement = placement;
            }
        }
        private void HandleHintCrop(ParseResult result, AttributesHelper attributes)
        {
            HintCrop hintCrop;

            if (TryParseEnum(result, attributes, ATTR_IMAGE_HINT_CROP, out hintCrop))
            {
                this.HintCrop = hintCrop;
            }
        }
Example #21
0
        protected override void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result, string baseUri, bool addImageQuery)
        {
            base.ParseKnownAttributes(node, attributes, result, baseUri, addImageQuery);

            // Template is required
            XAttribute attrTemplate = attributes.PopAttribute(ATTR_BINDING_TEMPLATE);

            if (attrTemplate == null)
            {
                result.AddWarning("template attribute wasn't provided on binding element.", GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            // If template is unknown, stop there
            Template template;

            if (!TryParseEnum(attrTemplate.Value, out template))
            {
                result.AddWarning($"template attribute \"{attrTemplate.Value}\" is not supported.", GetErrorPositionInfo(attrTemplate));
                throw new IncompleteElementException();
            }

            this.Template = template;

            // Branding is optional
            Branding branding;

            if (TryParseEnum(result, attributes, ATTR_BINDING_BRANDING, out branding, false)) // not case-sensitive
            {
                this.Branding = branding;
            }

            // Display name is optional
            XAttribute attrDisplayName = attributes.PopAttribute(ATTR_BINDING_DISPLAY_NAME, false); // not case-sensitive

            if (attrDisplayName != null)
            {
                this.DisplayName = attrDisplayName.Value;
            }

            // hint-overlay is optional
            double hintOverlay;

            if (TryParse(result, attributes, ATTR_BINDING_HINT_OVERLAY, out hintOverlay))
            {
                this.HintOverlay = hintOverlay;
            }

            // hint-textStacking is optional
            HintTextStacking hintTextStacking;

            if (TryParseEnum(result, attributes, ATTR_BINDING_HINT_TEXT_STACKING, out hintTextStacking))
            {
                this.HintTextStacking = hintTextStacking;
            }
        }
Example #22
0
        internal void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result)
        {
            // hint-systemCommands is optional
            HintSystemCommands hintSystemCommands;

            if (TryParseEnum(result, attributes, ATTR_HINT_SYSTEMCOMMANDS, out hintSystemCommands))
            {
                this.HintSystemCommands = hintSystemCommands;
            }
        }
        private void HandleHintOverlay(ParseResult result, AttributesHelper attributes)
        {
            // hint-overlay is optional
            double hintOverlay;

            if (TryParse(result, attributes, ATTR_HINT_OVERLAY, out hintOverlay))
            {
                this.HintOverlay = hintOverlay;
            }
        }
Example #24
0
        internal void Parse(ParseResult result, XElement node)
        {
            // Inner text
            this.Text = node.Value;

            AttributesHelper attributes = new AttributesHelper(node.Attributes());

            ParseKnownAttributes(attributes, result);

            HandleRemainingAttributes(attributes, result);
        }
 protected void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result, string baseUri, bool addImageQuery)
 {
     if (Context != NotificationType.Toast)
     {
         // hint-textStacking is optional
         HintTextStacking hintTextStacking;
         if (TryParseEnum(result, attributes, ATTR_TEXT_STACKING, out hintTextStacking))
         {
             this.HintTextStacking = hintTextStacking;
         }
     }
 }
Example #26
0
 internal void ParseKnownAttributes(AttributesHelper attributes, ParseResult result, string baseUri, bool addImageQuery)
 {
     if (Context != NotificationType.Tile && Context != NotificationType.Toast)
     {
         // actionId is optional
         var attrActionId = attributes.PopAttribute(ATTR_ACTIONID);
         if (attrActionId != null)
         {
             this.ActionId = attrActionId.Value;
         }
     }
 }
Example #27
0
        internal void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result)
        {
            // id is required
            XAttribute attrId = attributes.PopAttribute(ATTR_ID);

            if (attrId == null)
            {
                result.AddError("id attribute on input element is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            this.Id = attrId.Value;
        }
Example #28
0
        internal void Parse(ParseResult result, XElement node)
        {
            if (!XmlTemplateParser.EnsureNodeOnlyHasElementsAsChildren(result, node))
            {
                throw new IncompleteElementException();
            }

            AttributesHelper attributes = new AttributesHelper(node.Attributes());

            ParseKnownAttributes(node, attributes, result);

            HandleRemainingAttributes(attributes, result);
        }
Example #29
0
        protected virtual void ParseKnownAttributes(XElement node, AttributesHelper attributes, ParseResult result)
        {
            // id is required
            XAttribute attrId = attributes.PopAttribute(ATTR_ID);

            if (attrId == null)
            {
                result.AddError("id attribute on input element is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            // type is required
            InputType type;

            if (!TryParseEnum(result, attributes, ATTR_TYPE, out type))
            {
                result.AddErrorButRenderAllowed("type attribute on input element is required.", XmlTemplateParser.GetErrorPositionInfo(node));
                throw new IncompleteElementException();
            }

            this.Id   = attrId.Value;
            this.Type = type;


            // title is optional
            var attrTitle = attributes.PopAttribute(ATTR_TITLE);

            if (attrTitle != null)
            {
                this.Title = attrTitle.Value;
            }

            // placeHolderContent is optional
            var attrPlaceHolderContent = attributes.PopAttribute(ATTR_PLACEHOLDERCONTENT);

            if (attrPlaceHolderContent != null)
            {
                this.PlaceHolderContent = attrPlaceHolderContent.Value;
            }

            // defaultInput is optional
            var attrDefaultInput = attributes.PopAttribute(ATTR_DEFAULTINPUT);

            if (attrDefaultInput != null)
            {
                this.DefaultInput = attrDefaultInput.Value;
            }
        }
Example #30
0
        protected override Expression VisitMember(MemberExpression node)
        {
            if (!AttributesHelper.IsAttributesClass(node.Member.DeclaringType))
            {
                throw new NotSupportedException();
            }

            var attributeName = node.ToString();

            if (!_attributes.ContainsKey(attributeName))
            {
                throw new AttributeMissingException(attributeName);
            }

            return(Expression.Constant(_attributes[attributeName]));
        }