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); }