/// <summary>
/// Creates an instance of <see cref="MessageDetail"/> by parsing out the textual dsl.
/// </summary>
/// <param name="target">The target of the message.</param>
/// <param name="messageText">The textual message dsl.</param>
/// <param name="namedElements">All the <see cref="Control"/> instances with names in the scope.</param>
/// <returns>The created message detail.</returns>
public static MessageDetail CreateMessageDetail(Control target, string messageText,
IEnumerable <Control> namedElements)
{
var openingParenthesisIndex = messageText.IndexOf('(');
if (openingParenthesisIndex < 0)
{
openingParenthesisIndex = messageText.Length;
}
var closingParenthesisIndex = messageText.LastIndexOf(')');
if (closingParenthesisIndex < 0)
{
closingParenthesisIndex = messageText.Length;
}
var core = messageText.Substring(0, openingParenthesisIndex).Trim();
var message = InterpretMessageText(core);
if (closingParenthesisIndex - openingParenthesisIndex > 1)
{
var paramString = messageText.Substring(openingParenthesisIndex + 1,
closingParenthesisIndex - openingParenthesisIndex - 1);
var parameters = SplitParameters(paramString);
foreach (var parameter in parameters)
{
message.Parameters.Add(CreateParameter(target, parameter.Trim(), namedElements));
}
}
return(message);
}
/// <summary>
/// Creates a binding on a <see cref="Parameter" />.
/// </summary>
/// <param name="target">The target to which the message is applied.</param>
/// <param name="parameter">The parameter object.</param>
/// <param name="control">The actual control to bind to.</param>
/// <param name="propertyName">The name of the property to bind to.</param>
/// <param name="bindingMode">The binding mode to use.</param>
public static void BindParameter(Control target, Parameter parameter, Control control,
string propertyName, BindingMode bindingMode)
{
if (string.IsNullOrEmpty(propertyName))
{
var convention = ConventionManager.GetElementConvention(control.GetType());
if (convention != null)
{
propertyName = convention.ParameterProperty;
}
}
if (!string.IsNullOrEmpty(propertyName))
{
var binding = new Binding()
{
SourceObject = control,
SourcePath = propertyName,
TargetObject = parameter,
TargetPath = "Value",
Mode = bindingMode
};
parameter.BindingManager.Bindings.Add(binding);
}
}
/// <summary>
/// Executes the handler the first time the elements's LayoutUpdated event fires.
/// </summary>
/// <param name="control">The control.</param>
/// <param name="handler">The handler.</param>
public static void ExecuteOnLayoutUpdated(Control control, LayoutEventHandler handler)
{
LayoutEventHandler onLayout = null;
onLayout = (s, e) =>
{
handler(s, e);
control.Layout -= onLayout;
};
control.Layout += onLayout;
}
/// <summary>
/// Creates a binding on a <see cref="Parameter" />.
/// </summary>
/// <param name="target">The target to which the message is applied.</param>
/// <param name="parameter">The parameter object.</param>
/// <param name="controlName">The name of the control to bind to.</param>
/// <param name="propertyName">The name of the property to bind to.</param>
/// <param name="bindingMode">The binding mode to use.</param>
/// <param name="namedElements">All the <see cref="Control"/> instances with names in the scope.</param>
public static void BindParameters(Control target, Parameter parameter, string controlName,
string propertyName, BindingMode bindingMode, IEnumerable <Control> namedElements)
{
var control = namedElements.FindName(controlName);
if (control == null)
{
return;
}
BindParameter(target, parameter, control, propertyName, bindingMode);
}
/// <summary>
/// Executes the handler immediately if the element is loaded, otherwise wires it to the Loaded event.
/// </summary>
/// <param name="control">The control.</param>
/// <param name="handler">The handler.</param>
/// <returns>true if the handler was executed immediately; false otherwise</returns>
public static bool ExecuteOnLoad(Control control, EventHandler handler)
{
if (control.IsHandleCreated)
{
handler(control, new EventArgs());
return(true);
}
EventHandler loaded = null;
loaded = (s, e) =>
{
handler(s, e);
control.HandleCreated -= loaded;
};
control.HandleCreated += loaded;
return(false);
}
///<summary>
/// Uses the action pipeline to invoke the method.
///</summary>
///<param name="target"> The object instance to invoke the method on. </param>
///<param name="methodName"> The name of the method to invoke. </param>
///<param name="view"> The view. </param>
///<param name="source"> The source of the invocation. </param>
///<param name="eventArgs"> The event args. </param>
///<param name="parameters"> The method parameters. </param>
public static void Invoke(object target, string methodName, DependencyObject view = null,
Control source = null, object eventArgs = null, object[] parameters = null)
{
var context = new ActionExecutionContext
{
Target = target,
Method = target.GetType().GetMethod(methodName),
Message = new ActionMessage(source, null, methodName),
View = view,
Source = source,
EventArgs = eventArgs
};
if (parameters != null)
{
parameters.Apply(x => context.Message.Parameters.Add(x as Parameter ?? new Parameter {
Value = x
}));
}
ActionMessage.InvokeAction(context);
}
/// <summary>
/// Parses the specified message text.
/// </summary>
/// <param name="target">The event trigger control.</param>
/// <param name="text">The message text.</param>
/// <param name="namedElements">All the <see cref="Control"/> instances with names in the scope.</param>
/// <returns>
/// The message details parsed from the text.
/// </returns>
public static IEnumerable <MessageDetail> Parse(Control target, string text, IEnumerable <Control> namedElements)
{
var messageDetails = new List <MessageDetail>();
var messageTexts = Split(text, ';');
foreach (var messageText in messageTexts)
{
var triggerPlusMessage = LongFormatRegularExpression.IsMatch(messageText)
? Split(messageText, '=')
: new[] { null, messageText };
var messageDetail = CreateMessageDetail(target, triggerPlusMessage.Last()
.Replace("[", string.Empty)
.Replace("]", string.Empty)
.Trim(), namedElements);
messageDetail.EventName = GetTriggerEventName(target,
triggerPlusMessage.Length == 1 ? null : triggerPlusMessage[0]);
messageDetails.Add(messageDetail);
}
return(messageDetails);
}
/// <summary>
/// Determines whether a view should have conventions applied to it.
/// </summary>
/// <param name="view">The view to check.</param>
/// <returns>Whether or not conventions should be applied to the view.</returns>
public static bool ShouldApplyConventions(Control view)
{
var overriden = View.GetApplyConventions(view.GetDependencyObject());
return(overriden.GetValueOrDefault(ApplyConventionsByDefault));
}
/// <summary>
/// Determines whether the specified control has events with listeners.
/// </summary>
/// <param name="control">The control.</param>
/// <returns>
/// <c>true</c> if the specified control has events with listeners; otherwise, <c>false</c>.
/// </returns>
public static bool HasEventsWithListeners(Control control)
{
//TODO make this work
return(false);
}
