Esempio n. 1
0
                /// <summary>
                ///   Allows action parameters to be specified using Xaml compact syntaxes and (optionally) parameters evaluation.
                /// </summary>
                /// <param name = "syntaxes">The extra syntaxes which should be allowed.</param>
                public static void AllowExtraSyntax(MessageSyntaxes syntaxes)
                {
                    MessageBinder.EvaluateParameter = BaseEvaluateParameter;
                    Parser.CreateParameter          = BaseCreateParameter;

                    Func <DependencyObject, string, Parameter> createParameter =
                        syntaxes.HasFlag(MessageSyntaxes.SpecialValueProperty)
                            ? CreateParameter
                            : BaseCreateParameter;

                    if (syntaxes.HasFlag(MessageSyntaxes.XamlBinding))
                    {
                        Parser.CreateParameter =
                            (target, parameterText) =>
                        {
                            //Check if the parameter is defined as a markup...
                            if (parameterText.StartsWith("{") && parameterText.EndsWith("}"))
                            {
                                try
                                {
                                    parameterText = string.Format(PARAMETER_XAML_FRAGMENT,
                                                                  XamlNamespaces,
                                                                  parameterText);
                                    var parsed = LoadXaml(parameterText);

                                    return((Parameter)parsed);
                                }
                                catch (Exception exc)
                                {
                                    LogManager.GetLog(typeof(Parser)).Error(exc);
                                }
                            }

                            //Use the default implementation if the parameter is not identified as a binding...
                            return(createParameter(target, parameterText));
                        };
                    }

                    if (syntaxes.HasFlag(MessageSyntaxes.SpecialValueProperty))
                    {
                        MessageBinder.EvaluateParameter = (text, parameterType, context) =>
                        {
                            var lookup = text.ToLower(CultureInfo.InvariantCulture);
                            Func <ActionExecutionContext, object> resolver;

                            if (MessageBinder.SpecialValues.TryGetValue(lookup,
                                                                        out resolver))
                            {
                                return(resolver(context));
                            }

                            return
                                (MessageBinder.SpecialValues.Any(
                                     x => lookup.Contains(x.Key))
                                                                      ? EvaluateParameter(text, context, parameterType)
                                                                      : text);
                        };
                    }
                }
Esempio n. 2
0
                /// <summary>
                ///   Allows action parameters to be specified using Xaml compact syntaxes and (optionally) parameters evaluation.
                /// </summary>
                /// <param name = "syntaxes">The extra syntaxes which should be allowed.</param>
                public static void AllowExtraSyntax(MessageSyntaxes syntaxes)
                {
                    MessageBinder.EvaluateParameter = BaseEvaluateParameter;
                    Parser.CreateParameter = BaseCreateParameter;

                    Func<DependencyObject, string, Parameter> createParameter =
                        syntaxes.HasFlag(MessageSyntaxes.SpecialValueProperty)
                            ? CreateParameter
                            : BaseCreateParameter;

                    if (syntaxes.HasFlag(MessageSyntaxes.XamlBinding))
                    {
                        Parser.CreateParameter =
                            (target, parameterText) =>
                            {
                                //Check if the parameter is defined as a markup...
                                if (parameterText.StartsWith("{") && parameterText.EndsWith("}"))
                                {
                                    try
                                    {
                                        parameterText = string.Format(PARAMETER_XAML_FRAGMENT,
                                                                      XamlNamespaces,
                                                                      parameterText);
                                        var parsed = LoadXaml(parameterText);

                                        return (Parameter)parsed;
                                    }
                                    catch (Exception exc)
                                    {
                                        LogManager.GetLog(typeof(Parser)).Error(exc);
                                    }
                                }

                                //Use the default implementation if the parameter is not identified as a binding...
                                return createParameter(target, parameterText);
                            };
                    }

                    if (syntaxes.HasFlag(MessageSyntaxes.SpecialValueProperty))
                    {
                        MessageBinder.EvaluateParameter = (text, parameterType, context) =>
                                                          {
                                                              var lookup = text.ToLower(CultureInfo.InvariantCulture);
                                                              Func<ActionExecutionContext, object> resolver;

                                                              if (MessageBinder.SpecialValues.TryGetValue(lookup,
                                                                                                          out resolver)) return resolver(context);

                                                              return
                                                                  MessageBinder.SpecialValues.Any(
                                                                      x => lookup.Contains(x.Key))
                                                                      ? EvaluateParameter(text, context, parameterType)
                                                                      : text;
                                                          };
                    }
                }