public void Constructor1 ()
{
CodeEventReferenceExpression eventref = new CodeEventReferenceExpression ();
CodeExpression listener = new CodeExpression ();
CodeAttachEventStatement caes = new CodeAttachEventStatement (eventref, listener);
Assert.AreSame (eventref, caes.Event, "#1");
Assert.AreEqual (string.Empty, caes.Event.EventName, "#2");
Assert.IsNull (caes.Event.TargetObject, "#3");
Assert.AreSame (listener, caes.Listener, "#4");
caes.Event = null;
Assert.IsNotNull (caes.Event, "#5");
Assert.AreEqual (string.Empty, caes.Event.EventName, "#6");
Assert.IsNull (caes.Event.TargetObject, "#7");
Assert.AreSame (listener, caes.Listener, "#8");
caes.Listener = null;
Assert.IsNull (caes.Listener, "#9");
caes.Event = eventref;
Assert.AreSame (eventref, caes.Event, "#10");
caes.Listener = listener;
Assert.AreSame (listener, caes.Listener, "#11");
caes = new CodeAttachEventStatement ((CodeEventReferenceExpression) null, (CodeExpression) null);
Assert.IsNotNull (caes.Event, "#12");
Assert.IsNull (caes.Listener, "#13");
Assert.AreEqual (string.Empty, caes.Event.EventName, "#14");
Assert.IsNull (caes.Event.TargetObject, "#15");
}
protected override void GenerateAttachEventStatement(System.CodeDom.CodeAttachEventStatement e)
{
GenerateExpression(e.Event);
Output.Write(" += ");
GenerateExpression(e.Listener);
Output.WriteLine(";");
}
public void Constructor0 ()
{
CodeAttachEventStatement caes = new CodeAttachEventStatement ();
Assert.IsNotNull (caes.Event, "#1");
Assert.IsNull (caes.Listener, "#2");
Assert.AreEqual (string.Empty, caes.Event.EventName, "#3");
Assert.IsNull (caes.Event.TargetObject, "#4");
}
public void Constructor0_Deny_Unrestricted ()
{
CodeAttachEventStatement caes = new CodeAttachEventStatement ();
Assert.AreEqual (String.Empty, caes.Event.EventName, "Event.EventName");
Assert.IsNull (caes.Event.TargetObject, "Event.TargetObject");
caes.Event = new CodeEventReferenceExpression ();
Assert.IsNull (caes.Listener, "Listener");
caes.Listener = new CodeExpression ();
}
public TypescriptAttachEventStatement(
IExpressionFactory expressionFactory,
CodeAttachEventStatement statement,
CodeGeneratorOptions options)
{
_expressionFactory = expressionFactory;
_statement = statement;
_options = options;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeEventReferenceExpression eventref = new CodeEventReferenceExpression ();
CodeExpression listener = new CodeExpression ();
CodeAttachEventStatement caes = new CodeAttachEventStatement (eventref, listener);
Assert.AreSame (eventref, caes.Event, "Event");
caes.Event = new CodeEventReferenceExpression ();
Assert.AreSame (listener, caes.Listener, "Listener");
caes.Listener = new CodeExpression ();
}
public void Constructor2_Deny_Unrestricted ()
{
CodeExpression target = new CodeExpression ();
string eventName = "Mono";
CodeExpression listener = new CodeExpression ();
CodeAttachEventStatement caes = new CodeAttachEventStatement (target, eventName, listener);
Assert.AreEqual (eventName, caes.Event.EventName, "Event.EventName");
Assert.AreSame (target, caes.Event.TargetObject, "Event.TargetObject");
caes.Event = new CodeEventReferenceExpression ();
Assert.AreSame (listener, caes.Listener, "Listener");
caes.Listener = new CodeExpression ();
}
public static CodeAttachEventStatement Clone(this CodeAttachEventStatement statement)
{
if (statement == null) return null;
CodeAttachEventStatement s = new CodeAttachEventStatement();
s.EndDirectives.AddRange(statement.EndDirectives);
s.Event = statement.Event.Clone();
s.LinePragma = statement.LinePragma;
s.Listener = statement.Listener.Clone();
s.StartDirectives.AddRange(statement.StartDirectives);
s.UserData.AddRange(statement.UserData);
return s;
}
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
{
EventDescriptor e = descriptor as EventDescriptor;
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (e == null)
{
throw new ArgumentNullException("descriptor");
}
if (statements == null)
{
throw new ArgumentNullException("statements");
}
try
{
IEventBindingService service = (IEventBindingService) manager.GetService(typeof(IEventBindingService));
if (service != null)
{
string methodName = (string) service.GetEventProperty(e).GetValue(value);
if (methodName != null)
{
CodeExpression targetObject = base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeTypeReference delegateType = new CodeTypeReference(e.EventType);
CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression(delegateType, _thisRef, methodName);
CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression(targetObject, e.Name);
CodeAttachEventStatement statement = new CodeAttachEventStatement(eventRef, listener);
statement.UserData[typeof(Delegate)] = e.EventType;
statements.Add(statement);
}
}
}
}
catch (Exception innerException)
{
if (innerException is TargetInvocationException)
{
innerException = innerException.InnerException;
}
manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { e.Name, innerException.Message }));
}
}
// top of stack is reference to an event
public override void CreateEventDelegate(string functionName, Type eventDelegateType)
{
debug();
CodeExpression expr = buildDelegate(eventDelegateType, functionName);
CodeAttachEventStatement attach = new CodeAttachEventStatement(
(CodeEventReferenceExpression)peek(),
expr);
constructor.Statements.Add(attach);
}
public override bool AddEventHandler(EventDescription eventDescription, string objectName, string methodName)
{
const string Init = "__init__";
//This is not the most optimal solution for WPF since we will call FindLogicalNode for each event handler,
//but it simplifies the code generation for now.
CodeDomDocDataAdapter adapter = GetDocDataAdapterForPyFile();
//Find the __init__ method
CodeMemberMethod method = null;
foreach(CodeTypeMember ctMember in adapter.TypeDeclaration.Members)
{
if (ctMember is CodeConstructor)
{
if (ctMember.Name == Init)
{
method = ctMember as CodeMemberMethod;
break;
}
}
}
if (method == null)
{
method = new CodeConstructor();
method.Name = Init;
}
//Create a code statement which looks like: LogicalTreeHelper.FindLogicalNode(self.Root, "button1").Click += self.button1_Click
CodeTypeReferenceExpression logicalTreeHelper = new CodeTypeReferenceExpression("LogicalTreeHelper");
CodeMethodReferenceExpression findLogicalNodeMethod = new CodeMethodReferenceExpression(logicalTreeHelper, "FindLogicalNode");
CodeFieldReferenceExpression selfWindow = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Root");
CodeMethodInvokeExpression findLogicalNodeInvoke = new CodeMethodInvokeExpression( findLogicalNodeMethod, selfWindow, new CodeSnippetExpression("\'" + objectName + "\'"));
CodeDelegateCreateExpression createDelegateExpression = new CodeDelegateCreateExpression(new CodeTypeReference("System.EventHandler"), new CodeThisReferenceExpression(), methodName);
CodeAttachEventStatement attachEvent = new CodeAttachEventStatement(findLogicalNodeInvoke, eventDescription.Name, createDelegateExpression);
method.Statements.Add(attachEvent);
adapter.Generate();
return true;
}
protected override void GenerateAttachEventStatement(CodeAttachEventStatement e) {
GenerateExpression(e.Event.TargetObject);
Output.Write(".add_");
Output.Write(e.Event.EventName);
Output.Write("(");
GenerateExpression(e.Listener);
Output.WriteLine(");");
}
private CodeStatement AddCLREvent(Type eventTarget, CodeContext cc, CodeExpression ce, MarkupEventInfo mei)
{
bool subClassed = _ccRoot.SubClass.Length > 0;
CodeStatement csEvent = null;
// param2: <FooEventHandler>
CodeExpression cDelExp = GetEventDelegate(cc, mei.mi, mei.eventName, mei.eventHandler);
if (mei.mi.DeclaringType.IsAssignableFrom(eventTarget))
{
// _element.FooEvent += new FooEventHandlerDelegate(OnFoo);
csEvent = new CodeAttachEventStatement(ce, mei.eventName, cDelExp);
}
else if (eventTarget == null || // for known attached events on unknown local tags
KnownTypes.Types[(int)KnownElements.UIElement].IsAssignableFrom(eventTarget) ||
KnownTypes.Types[(int)KnownElements.ContentElement].IsAssignableFrom(eventTarget))
{
// _element.AddHandler(FooEvent, new FooEventHandlerDelegate(OnFoo));
CodeFieldReferenceExpression cfreEvent = GetEvent(mei.mi, mei.eventName, mei.eventHandler);
CodeMethodInvokeExpression cmieAddHandler = new CodeMethodInvokeExpression(ce, ADDHANDLER, cfreEvent, cDelExp);
csEvent = new CodeExpressionStatement(cmieAddHandler);
}
else
{
string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName;
ThrowCompilerException(SRID.UnknownEventAttribute, mei.eventName, mei.eventHandler, eventTargetName);
}
// When x:SubClass is used, event handlers can be specified in a code-behind file, under this sub class.
// But these handler methods need to be accessible from the intermediary generated sub class. So an empty
// internal virtual method with the same signature as the handler method is generated in this intermediary
// sub class (in the generated file):
//
// internal virtual void OnFooEvent(object sender, FooEventArgs ea)
// {
// }
//
// Since a delegate cannot take the address of a virtual function, a non-virtual helper function
// with the same signature as the above function & which calls the above function is also generated:
//
// private void OnFooEventHelper(object sender, FooEventArgs ea)
// {
// OnFooEvent(sender, ea);
// }
//
// All this is done only if x:Subclass is specified, since this means that this sub class would need to be
// defined in a code-behind file. This also means that inline events (in <x:Code>) will not be supported.
if (subClassed)
{
GenerateProtectedEventHandlerMethod(mei);
}
AddLinePragma(csEvent, mei.lineNumber);
return csEvent;
}
protected override void GenerateAttachEventStatement (CodeAttachEventStatement e)
{
}
protected abstract void GenerateAttachEventStatement (CodeAttachEventStatement s);
/// <include file='doc\CSharpCodeProvider.uex' path='docs/doc[@for="CSharpCodeGenerator.GenerateAttachEventStatement"]/*' />
/// <devdoc>
/// <para>
/// Generates code for the specified CodeDom based attach event statement
/// representation.
/// </para>
/// </devdoc>
protected override void GenerateAttachEventStatement(CodeAttachEventStatement e) {
GenerateEventReferenceExpression(e.Event);
Output.Write(" += ");
GenerateExpression(e.Listener);
Output.WriteLine(";");
}
void AddEventAssign (CodeMemberMethod method, ControlBuilder builder, string name, Type type, string value)
{
//"__ctrl.{0} += new {1} (this.{2});"
CodeEventReferenceExpression evtID = new CodeEventReferenceExpression (ctrlVar, name);
CodeDelegateCreateExpression create;
create = new CodeDelegateCreateExpression (new CodeTypeReference (type), thisRef, value);
CodeAttachEventStatement attach = new CodeAttachEventStatement (evtID, create);
method.Statements.Add (attach);
}
public override void EnterExpressionStmt([NotNull] XSharpParser.ExpressionStmtContext context)
{
if (initComponent != null)
{
CodeExpression expr = new CodeExpression();
CodeStatement stmt = new CodeStatement();
//
if (context._expression is XSharpParser.AssignmentExpressionContext)
{
XSharpParser.AssignmentExpressionContext exp = (XSharpParser.AssignmentExpressionContext)context._expression;
//
//what is the left hand side ?
// Self -> check if Right is in the member of CurrentClass --> FieldReference
// else --> always Property
//
CodeExpression left = BuildExpression(exp.Left, false);
CodeExpression right = BuildExpression(exp.Right, true);
if (exp.ASSIGN_OP() != null)
{
//expr = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.Assign, right);
stmt = new CodeAssignStatement(left, right);
}
else if (exp.ASSIGN_ADD() != null)
{
// += Event Handler
// We will decode Left as CodeFieldReferenceExpression or CodePropertyReferenceExpression, but we need a CodeEventReferenceExpression
CodeEventReferenceExpression cere;
if (left is CodeFieldReferenceExpression)
cere = new CodeEventReferenceExpression(((CodeFieldReferenceExpression)left).TargetObject, ((CodeFieldReferenceExpression)left).FieldName);
else
cere = new CodeEventReferenceExpression(((CodePropertyReferenceExpression)left).TargetObject, ((CodePropertyReferenceExpression)left).PropertyName);
stmt = new CodeAttachEventStatement(cere, right);
//
}
else if (exp.ASSIGN_SUB() != null)
{
// -= Event Handler
CodeEventReferenceExpression cere;
if (left is CodeFieldReferenceExpression)
cere = new CodeEventReferenceExpression(((CodeFieldReferenceExpression)left).TargetObject, ((CodeFieldReferenceExpression)left).FieldName);
else
cere = new CodeEventReferenceExpression(((CodePropertyReferenceExpression)left).TargetObject, ((CodePropertyReferenceExpression)left).PropertyName);
stmt = new CodeRemoveEventStatement(cere, right);
}
}
else if (context._expression is XSharpParser.MethodCallContext)
{
XSharpParser.MethodCallContext exp = (XSharpParser.MethodCallContext)context._expression;
expr = BuildExpression(exp,false);
stmt = new CodeExpressionStatement(expr);
}
else
{
expr = new CodeSnippetExpression(context.GetText());
stmt = new CodeExpressionStatement(expr);
}
//
initComponent.Statements.Add(stmt);
}
}
private void GenerateAttachEventStatement(CodeAttachEventStatement e)
{
this.GenerateEventReferenceExpression(e.Event);
this.Output.Write(" += ");
this.GenerateExpression(e.Listener);
this.Output.WriteLine(";");
}
internal static void BindSignalHandlers (CodeExpression targetObjectVar, ObjectWrapper wrapper, Stetic.WidgetMap map, CodeStatementCollection statements, GenerationOptions options)
{
foreach (Signal signal in wrapper.Signals) {
SignalDescriptor descriptor = signal.SignalDescriptor;
CodeExpression createDelegate;
if (options.UsePartialClasses) {
createDelegate =
new CodeDelegateCreateExpression (
new CodeTypeReference (descriptor.HandlerTypeName, CodeTypeReferenceOptions.GlobalReference),
new CodeThisReferenceExpression (),
signal.Handler);
} else {
createDelegate =
new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression (new CodeTypeReference (typeof(Delegate), CodeTypeReferenceOptions.GlobalReference)),
"CreateDelegate",
new CodeTypeOfExpression (descriptor.HandlerTypeName),
targetObjectVar,
new CodePrimitiveExpression (signal.Handler));
createDelegate = new CodeCastExpression (descriptor.HandlerTypeName.ToGlobalTypeRef (), createDelegate);
}
CodeAttachEventStatement cevent = new CodeAttachEventStatement (
new CodeEventReferenceExpression (
map.GetWidgetExp (wrapper),
descriptor.Name),
createDelegate);
statements.Add (cevent);
}
Wrapper.Widget widget = wrapper as Wrapper.Widget;
if (widget != null && widget.IsTopLevel) {
// Bind local action signals
foreach (Wrapper.ActionGroup grp in widget.LocalActionGroups) {
foreach (Wrapper.Action ac in grp.Actions)
BindSignalHandlers (targetObjectVar, ac, map, statements, options);
}
}
Gtk.Container cont = wrapper.Wrapped as Gtk.Container;
if (cont != null) {
foreach (Gtk.Widget child in cont.AllChildren) {
Stetic.Wrapper.Widget ww = Stetic.Wrapper.Widget.Lookup (child);
if (ww != null)
BindSignalHandlers (targetObjectVar, ww, map, statements, options);
}
}
}
/// <summary>
/// Generates code for the specified attach event statement.
/// </summary>
/// <remarks><c>EVENT->Add(LISTENER);</c></remarks>
protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
{
GenerateEventReferenceExpression(e.Event);
Output.Write(Tokens.Arrow);
Output.Write(SpecialWords.Add);
Output.Write(Tokens.ParenthesisLeft);
GenerateExpression(e.Listener);
Output.Write(Tokens.ParenthesisRight);
Output.WriteLine(Tokens.Semicolon);
}
public void Visit (CodeAttachEventStatement o)
{
g.GenerateAttachEventStatement (o);
}
public void CodeAttachEventStatementTest ()
{
CodeEventReferenceExpression cere = new CodeEventReferenceExpression (
new CodeSnippetExpression ("A"), "class");
CodeSnippetExpression handler = new CodeSnippetExpression ("EventHandler");
CodeAttachEventStatement attachEventStatement = new CodeAttachEventStatement ();
statement = attachEventStatement;
try {
Generate ();
Assert.Fail ("#1");
} catch (ArgumentNullException) {
}
attachEventStatement.Event = cere;
try {
Generate ();
Assert.Fail ("#2");
} catch (ArgumentNullException) {
}
attachEventStatement.Event = null;
attachEventStatement.Listener = handler;
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
" += EventHandler;{0}", NewLine), Generate (), "#3");
attachEventStatement.Event = cere;
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"A.@class += EventHandler;{0}", NewLine), Generate (), "#4");
attachEventStatement.Event = new CodeEventReferenceExpression (
new CodeSnippetExpression ((string) null), "");
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
". += EventHandler;{0}", NewLine), Generate (), "#5");
attachEventStatement.Listener = new CodeSnippetExpression ("");
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
". += ;{0}", NewLine), Generate (), "#6");
}
protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)
{
TextWriter output = Output;
Output.Write ("AddHandler ");
if (statement.Event.TargetObject != null) {
GenerateEventReferenceExpression (statement.Event);
} else {
Output.Write (CreateEscapedIdentifier (statement.Event.EventName));
}
Output.Write ( ", ");
GenerateExpression (statement.Listener);
output.WriteLine ();
}
public bool ValidateCodeAttachEventStatement (CodeAttachEventStatement exp) {
bool result = false;
PushLocation (exp);
if (ValidateCodeEventReferenceExpression (exp.Event) &&
IsSimpleTarget (exp.Listener))
result = true;
PopLocation();
return result;
}
protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
{
base.Output.Write("AddHandler ");
this.GenerateFormalEventReferenceExpression(e.Event);
base.Output.Write(", ");
base.GenerateExpression(e.Listener);
base.Output.WriteLine("");
}
protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)
{
TextWriter output = Output;
GenerateEventReferenceExpression (statement.Event);
output.Write (" += ");
GenerateExpression (statement.Listener);
output.WriteLine (';');
}
protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
{
Output.WriteLine("[CodeAttachEventStatement: {0}]", e.ToString());
}
/// <summary>
/// Using an anonymous code block to call the event handler method:
///
/// @button1.Click { |sender, e| self.Button1Click(sender, e) }
/// </summary>
void AppendAttachEventStatement(CodeAttachEventStatement statement)
{
codeBuilder.AppendIndented(String.Empty);
AppendExpression(statement.Event.TargetObject);
codeBuilder.Append(".");
codeBuilder.Append(statement.Event.EventName);
codeBuilder.Append(" { |sender, e| ");
AppendExpression(statement.Listener);
codeBuilder.Append("(sender, e) }");
codeBuilder.AppendLine();
}
private void GenerateCodeFromCodeAttachEventStatement(CodeAttachEventStatement e, TextWriter w,
CodeGeneratorOptions o)
{
if (e.Event.TargetObject is CodeThisReferenceExpression)
{
if (_currentType.Methods.All(m => m.Name != e.Event.EventName))
{
w.Write("$MainForm.");
}
}
else
{
GenerateCodeFromExpression(e.Event.TargetObject, w, o);
w.Write(".");
}
w.Write("add_{0}(", e.Event.EventName);
GenerateCodeFromExpression(e.Listener, w, o);
w.WriteLine(")");
}
private void ValidateAttachEventStatement(CodeAttachEventStatement e) {
ValidateEventReferenceExpression(e.Event);
ValidateExpression(e.Listener);
}
