Пример #1
0
 protected abstract void GenerateAttachEventStatement(CodeAttachEventStatement e);
Пример #2
0
    public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {

        // GENERATES (C#):
        //  [assembly: System.CLSCompliantAttribute(false)]
        //  
        //  namespace MyNamespace {
        //      using System;
        //      using System.Drawing;
        //      using System.Windows.Forms;
        //      using System.ComponentModel;
        //      
        //      
        //      public class Test : Form {
        //          
        //          private Button b = new Button();
        //          
        //          public Test() {
        //              this.Size = new Size(600, 600);
        //              b.Text = "Test";
        //              b.TabIndex = 0;
        //              b.Location = new Point(400, 525);
        //              this.MyEvent += new EventHandler(this.b_Click);
        //              this.MyEvent -= new EventHandler(this.b_Click);
        //          }
        //          
        //          [System.CLSCompliantAttribute(false)]
        //          public event System.EventHandler MyEvent;
        //          
        //          private void b_Click(object sender, System.EventArgs e) {
        //          }
        //      }
        //  }
        //  namespace SecondNamespace {
        //      using System;
        //      using System.Drawing;
        //      using System.Windows.Forms;
        //      using System.ComponentModel;
        //      
        //      
        //      public class Test : Form {
        //          
        //          private Button b = new Button();
        //          
        //          public Test() {
        //              this.Size = new Size(600, 600);
        //              b.Text = "Test";
        //              b.TabIndex = 0;
        //              b.Location = new Point(400, 525);
        //              this.MyEvent += new EventHandler(this.b_Click);
        //          }
        //          
        //          private event System.EventHandler MyEvent;
        //          
        //          private void b_Click(object sender, System.EventArgs e) {
        //          }
        //      }
        //  }
        //  namespace ThirdNamespace {
        //      using System;
        //      using System.Drawing;
        //      using System.Windows.Forms;
        //      using System.ComponentModel;
        //      
        //      
        //      public class Test : Form {
        //          
        //          private Button b = new Button();
        //          
        //          public Test() {
        //              this.Size = new Size(600, 600);
        //              b.Text = "Test";
        //              b.TabIndex = 0;
        //              b.Location = new Point(400, 525);
        //              this.MyEvent += new EventHandler(this.b_Click);
        //          }
        //          
        //          [System.CLSCompliantAttribute(false)]
        //          protected event System.EventHandler MyEvent;
        //          
        //          private void b_Click(object sender, System.EventArgs e) {
        //          }
        //      }
        //  }
        //  namespace FourthNamespace {
        //      using System;
        //      using System.Drawing;
        //      using System.Windows.Forms;
        //      using System.ComponentModel;
        //      
        //      
        //      public class Test : Form {
        //          
        //          private Button b = new Button();
        //          
        //          public Test() {
        //              this.Size = new Size(600, 600);
        //              b.Text = "Test";
        //              b.TabIndex = 0;
        //              b.Location = new Point(400, 525);
        //              this.MyEvent += new EventHandler(this.b_Click);
        //          }
        //          
        //          /*FamANDAssem*/ internal event System.EventHandler MyEvent;
        //          
        //          private void b_Click(object sender, System.EventArgs e) {
        //          }
        //      }
        //  }

        if (Supports (provider, GeneratorSupport.DeclareEvents)) {
            // *********************************
            // public
            CodeNamespace ns = new CodeNamespace ();
            ns.Name = "MyNamespace";
            ns.Imports.Add (new CodeNamespaceImport ("System"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
            ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
            cu.Namespaces.Add (ns);

            cu.ReferencedAssemblies.Add ("System.Drawing.dll");
            cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll");

            // Assembly Attributes
            if (Supports (provider, GeneratorSupport.AssemblyAttributes)) {
                CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
                attrs.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new
                    CodeAttributeArgument (new CodePrimitiveExpression (false))));
            }

            CodeTypeDeclaration class1 = new CodeTypeDeclaration ("Test");
            class1.IsClass = true;
            class1.BaseTypes.Add (new CodeTypeReference ("Form"));
            ns.Types.Add (class1);

            CodeMemberField mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
            mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
            class1.Members.Add (mfield);

            CodeConstructor ctor = new CodeConstructor ();
            ctor.Attributes = MemberAttributes.Public;
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeThisReferenceExpression (),
                "Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
                new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Text"), new CodePrimitiveExpression ("Test")));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "TabIndex"), new CodePrimitiveExpression (0)));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
                new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));
            ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new
                CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
                , new CodeThisReferenceExpression (), "b_Click")));
            ctor.Statements.Add (new CodeRemoveEventStatement (new CodeEventReferenceExpression (new
                CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
                , new CodeThisReferenceExpression (), "b_Click")));
            class1.Members.Add (ctor);

            CodeMemberEvent evt = new CodeMemberEvent ();
            evt.Name = "MyEvent";
            evt.Type = new CodeTypeReference ("System.EventHandler");
            evt.Attributes = MemberAttributes.Public;
            evt.CustomAttributes.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false))));
            class1.Members.Add (evt);

            CodeMemberMethod cmm = new CodeMemberMethod ();
            cmm.Name = "b_Click";
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
            class1.Members.Add (cmm);

            // *********************************
            // private
            ns = new CodeNamespace ();
            ns.Name = "SecondNamespace";
            ns.Imports.Add (new CodeNamespaceImport ("System"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
            ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
            cu.Namespaces.Add (ns);

            class1 = new CodeTypeDeclaration ("Test");
            class1.IsClass = true;
            class1.BaseTypes.Add (new CodeTypeReference ("Form"));
            ns.Types.Add (class1);

            mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
            mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
            class1.Members.Add (mfield);

            ctor = new CodeConstructor ();
            ctor.Attributes = MemberAttributes.Public;
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeThisReferenceExpression (),
                "Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
                new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Text"), new CodePrimitiveExpression ("Test")));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "TabIndex"), new CodePrimitiveExpression (0)));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
                new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));

            CodeAttachEventStatement addevt = new CodeAttachEventStatement (new CodeThisReferenceExpression (),
                    "MyEvent", new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
                , new CodeThisReferenceExpression (), "b_Click"));

            ctor.Statements.Add (addevt);

            // remove event statement 
            CodeRemoveEventStatement rem = new CodeRemoveEventStatement (new CodeThisReferenceExpression (), "MyEvent",
                        new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler"),
                            new CodeThisReferenceExpression (), "b_Click"));
            ctor.Statements.Add (rem);


            class1.Members.Add (ctor);

            evt = new CodeMemberEvent ();
            evt.Name = "MyEvent";
            evt.Type = new CodeTypeReference ("System.EventHandler");
            evt.Attributes = MemberAttributes.Private;
            class1.Members.Add (evt);

            cmm = new CodeMemberMethod ();
            cmm.Name = "b_Click";
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
            class1.Members.Add (cmm);

            // *********************************
            // protected
            ns = new CodeNamespace ();
            ns.Name = "ThirdNamespace";
            ns.Imports.Add (new CodeNamespaceImport ("System"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
            ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
            cu.Namespaces.Add (ns);

            class1 = new CodeTypeDeclaration ("Test");
            class1.IsClass = true;
            class1.BaseTypes.Add (new CodeTypeReference ("Form"));
            ns.Types.Add (class1);

            mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
            mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
            class1.Members.Add (mfield);

            ctor = new CodeConstructor ();
            ctor.Attributes = MemberAttributes.Public;
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeThisReferenceExpression (),
                "Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
                new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Text"), new CodePrimitiveExpression ("Test")));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "TabIndex"), new CodePrimitiveExpression (0)));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
                new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));

            addevt = new CodeAttachEventStatement ();
            addevt.Event = new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "MyEvent");
            addevt.Listener = new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler"),
                    new CodeThisReferenceExpression (), "b_Click");
            ctor.Statements.Add (addevt);

            // remove event
            rem = new CodeRemoveEventStatement ();
            rem.Event = new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "MyEvent");
            rem.Listener = new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler"),
                    new CodeThisReferenceExpression (), "b_Click");
            ctor.Statements.Add (rem);

            class1.Members.Add (ctor);

            evt = new CodeMemberEvent ();
            evt.Name = "MyEvent";
            evt.Type = new CodeTypeReference ("System.EventHandler");
            evt.Attributes = MemberAttributes.Family;
            evt.CustomAttributes.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false))));
            class1.Members.Add (evt);

            cmm = new CodeMemberMethod ();
            cmm.Name = "b_Click";
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
            class1.Members.Add (cmm);

            // *********************************
            // internal
            ns = new CodeNamespace ();
            ns.Name = "FourthNamespace";
            ns.Imports.Add (new CodeNamespaceImport ("System"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
            ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
            ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
            cu.Namespaces.Add (ns);

            class1 = new CodeTypeDeclaration ("Test");
            class1.IsClass = true;
            class1.BaseTypes.Add (new CodeTypeReference ("Form"));
            ns.Types.Add (class1);

            mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
            mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
            class1.Members.Add (mfield);

            ctor = new CodeConstructor ();
            ctor.Attributes = MemberAttributes.Public;
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeThisReferenceExpression (),
                "Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
                new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Text"), new CodePrimitiveExpression ("Test")));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "TabIndex"), new CodePrimitiveExpression (0)));
            ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
                "Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
                new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));
            ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new
                CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
                , new CodeThisReferenceExpression (), "b_Click")));
            class1.Members.Add (ctor);

            evt = new CodeMemberEvent ();
            evt.Name = "MyEvent";
            evt.Type = new CodeTypeReference ("System.EventHandler");
            evt.Attributes = MemberAttributes.FamilyAndAssembly;
            class1.Members.Add (evt);

            cmm = new CodeMemberMethod ();
            cmm.Name = "b_Click";
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
            cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
            class1.Members.Add (cmm);
        }
    }
	protected override void GenerateAttachEventStatement
				(CodeAttachEventStatement e)
			{
				GenerateExpression(e.Event);
				Output.Write(" += ");
				GenerateExpression(e.Listener);
				Output.WriteLine(";");
			}
	protected override void GenerateAttachEventStatement
				(CodeAttachEventStatement e)
			{
				Output.Write("AddHandler ");
				GenerateExpression(e.Event);
				Output.Write(", ");
				GenerateExpression(e.Listener);
				Output.WriteLine();
			}
Пример #5
0
 private void GenerateAttachEventStatement(CodeAttachEventStatement e)
 {
     GenerateEventReferenceExpression(e.Event, false);
     GenerateExpression(e.Listener);
     Output.WriteLine(");");
 }
 protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
 {
     Output.WriteLine("[CodeAttachEventStatement: {0}]", e.ToString());
 }
Пример #7
0
 private void ValidateAttachEventStatement(CodeAttachEventStatement e)
 {
     ValidateEventReferenceExpression(e.Event);
     ValidateExpression(e.Listener);
 }
        /// <summary>
        ///  This method actually performs the serialization.  When the member is serialized
        ///  the necessary statements will be added to the statements collection.
        /// </summary>
        public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
        {
            if (manager == null)
            {
                throw new ArgumentNullException(nameof(manager));
            }
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
            if (!(descriptor is EventDescriptor eventToSerialize))
            {
                throw new ArgumentNullException(nameof(descriptor));
            }
            if (statements == null)
            {
                throw new ArgumentNullException(nameof(statements));
            }

            try
            {
                IEventBindingService eventBindings = (IEventBindingService)manager.GetService(typeof(IEventBindingService));

                // If the IEventBindingService is not available, we don't throw - we just don't do anything.
                if (eventBindings != null)
                {
                    PropertyDescriptor prop       = eventBindings.GetEventProperty(eventToSerialize);
                    string             methodName = (string)prop.GetValue(value);

                    if (methodName != null)
                    {
                        CodeDomSerializer.Trace("Event {0} bound to {1}", eventToSerialize.Name, methodName);
                        CodeExpression eventTarget = SerializeToExpression(manager, value);
                        CodeDomSerializer.TraceWarningIf(eventTarget == null, "Object has no name and no propery ref in context so we cannot serialize events: {0}", value);
                        if (eventTarget != null)
                        {
                            CodeTypeReference            delegateTypeRef = new CodeTypeReference(eventToSerialize.EventType);
                            CodeDelegateCreateExpression delegateCreate  = new CodeDelegateCreateExpression(delegateTypeRef, _thisRef, methodName);
                            CodeEventReferenceExpression eventRef        = new CodeEventReferenceExpression(eventTarget, eventToSerialize.Name);
                            CodeAttachEventStatement     attach          = new CodeAttachEventStatement(eventRef, delegateCreate);

                            attach.UserData[typeof(Delegate)] = eventToSerialize.EventType;
                            statements.Add(attach);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                // Since we usually go through reflection, don't
                // show what our engine does, show what caused
                // the problem.
                //
                if (e is TargetInvocationException)
                {
                    e = e.InnerException;
                }

                manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, eventToSerialize.Name, e.Message), manager));
            }
        }
Пример #9
0
 protected abstract void GenerateAttachEventStatement(CodeAttachEventStatement e);
Пример #10
0
 private void ValidateAttachEventStatement(CodeAttachEventStatement e)
 {
     ValidateEventReferenceExpression(e.Event);
     ValidateExpression(e.Listener);
 }
Пример #11
0
 protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
 {
 }
        public static string GenerateWrapper(WrapperClass wrapperClass, Language language)
        {
            // Namespace
            CodeNamespace _namespace = new CodeNamespace(wrapperClass.Namespace);

            // Comments
            string comment =
                @"------------------------------------------------------------------------------" + Environment.NewLine +
                @" <auto-generated>" + Environment.NewLine +
                @"     This code was generated by '.NET Wrapper Class Generator'" + Environment.NewLine +
                @"     Product Version:" + Assembly.GetExecutingAssembly().GetName().Version + Environment.NewLine + Environment.NewLine +
                @"     Changes to this file may cause incorrect behavior and will be lost if" + Environment.NewLine +
                @"     the code is regenerated." + Environment.NewLine +
                @" </auto-generated>" + Environment.NewLine +
                @" ------------------------------------------------------------------------------";

            _namespace.Comments.Add(new CodeCommentStatement(comment));

            // Class
            CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(wrapperClass.ClassName);

            classDeclaration.IsPartial = wrapperClass.Partial;
            if (wrapperClass.Sealed)
            {
                classDeclaration.TypeAttributes |= TypeAttributes.Sealed;
            }
            _namespace.Types.Add(classDeclaration);

            // Initialization
            CodeParameterDeclarationExpressionCollection initializationParameters = null;
            CodeStatementCollection initiazationStatements = null;

            if (wrapperClass.Partial)
            {
                // Initialization method
                CodeMemberMethod initializer = new CodeMemberMethod();
                classDeclaration.Members.Add(initializer);
                initializer.Name       = "InitializeWrapper";
                initializer.Attributes = MemberAttributes.Private;
                {
                    comment =
                        @"***************************************************************" + Environment.NewLine +
                        @" This method should be called by the user-provided constructor!" + Environment.NewLine +
                        @"***************************************************************";
                    initializer.Comments.Add(new CodeCommentStatement(comment));
                }
                initializationParameters = initializer.Parameters;
                initiazationStatements   = initializer.Statements;
            }
            else
            {
                // Constructor
                CodeConstructor constructor = new CodeConstructor();
                classDeclaration.Members.Add(constructor);
                constructor.Attributes   = MemberAttributes.Public;
                initializationParameters = constructor.Parameters;
                initiazationStatements   = constructor.Statements;
            }

            // Iterate over the wrapped types
            foreach (WrappedType wrappedType in wrapperClass.WrappedTypes)
            {
                // Fields
                CodeMemberField field = new CodeMemberField(wrappedType.Type, wrappedType.FieldName);
                if (wrappedType.Acquisition != Acquisition.UserManaged)
                {
                    classDeclaration.Members.Add(field);
                }
                string memberPrefix = string.Empty;
                if (wrappedType.PrefixMembers)
                {
                    memberPrefix = wrappedType.FieldName;
                    memberPrefix = memberPrefix.Substring(0, 1).ToUpper() + memberPrefix.Substring(1);
                }


                CodeFieldReferenceExpression fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), wrappedType.FieldName);
                if (wrappedType.Acquisition == Acquisition.Construct)
                {
                    // Instantiation
                    CodeObjectCreateExpression instantiation      = new CodeObjectCreateExpression(wrappedType.Type);
                    CodeAssignStatement        instanceAssignment = new CodeAssignStatement(fieldReference, instantiation);
                    initiazationStatements.Add(instanceAssignment);
                }
                else if (wrappedType.Acquisition == Acquisition.Parameter)
                {
                    // Pass as parameter
                    initializationParameters.Add(new CodeParameterDeclarationExpression(wrappedType.Type, wrappedType.FieldName));
                    initiazationStatements.Add(new CodeAssignStatement(fieldReference, new CodeVariableReferenceExpression(wrappedType.FieldName)));
                }
                else if (wrappedType.Acquisition == Acquisition.Property)
                {
                    // Set as property
                    CodeMemberProperty property = new CodeMemberProperty();
                    property.Attributes = MemberAttributes.Public;
                    property.HasGet     = property.HasSet = true;
                    property.Type       = new CodeTypeReference(wrappedType.Type);
                    property.Name       = wrappedType.Type.Name;
                    property.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
                    property.SetStatements.Add(new CodeAssignStatement(fieldReference, new CodeVariableReferenceExpression("value")));
                    classDeclaration.Members.Add(property);
                }

                // Methods
                foreach (WrappedMethod wrappedMethod in wrappedType.WrappedMethods)
                {
                    // Method
                    CodeMemberMethod method = new CodeMemberMethod();
                    classDeclaration.Members.Add(method);
                    method.Name       = memberPrefix + wrappedMethod.Method.Name;
                    method.ReturnType = new CodeTypeReference(wrappedMethod.Method.ReturnType);

                    Generator.SetMember(method, wrappedMethod);

                    if (!string.IsNullOrEmpty(wrappedMethod.Interface))
                    {
                        method.PrivateImplementationType = new CodeTypeReference(wrappedMethod.Interface);
                    }

                    // Parameters
                    List <CodeExpression> arguments = Generator.SetParameters(method, wrappedMethod.Method.GetParameters());

                    // Statement
                    CodeMethodInvokeExpression invocation = null;
                    if (!wrappedMethod.Method.IsStatic)
                    {
                        invocation = new CodeMethodInvokeExpression(fieldReference, wrappedMethod.Method.Name, arguments.ToArray());
                    }
                    else
                    {
                        invocation         = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(wrappedType.Type), wrappedMethod.Method.Name, arguments.ToArray());
                        method.Attributes |= MemberAttributes.Static;
                    }

                    if (wrappedMethod.Method.ReturnType == typeof(void))
                    {
                        method.Statements.Add(invocation);
                    }
                    else
                    {
                        method.Statements.Add(new CodeMethodReturnStatement(invocation));
                    }
                }

                // Properties
                foreach (WrappedProperty wrappedProperty in wrappedType.WrappedProperties)
                {
                    // Property
                    CodeMemberProperty property = new CodeMemberProperty();
                    classDeclaration.Members.Add(property);
                    property.Name = memberPrefix + wrappedProperty.Property.Name;
                    property.Type = new CodeTypeReference(wrappedProperty.Property.PropertyType);

                    Generator.SetMember(property, wrappedProperty);

                    if (!string.IsNullOrEmpty(wrappedProperty.Interface))
                    {
                        property.PrivateImplementationType = new CodeTypeReference(wrappedProperty.Interface);
                    }

                    CodePropertyReferenceExpression invocation = null;
                    if (true)                     // TODO: check if property is static
                    {
                        invocation = new CodePropertyReferenceExpression(fieldReference, wrappedProperty.Property.Name);
                    }
                    else
                    {
                    }

                    // Get statement
                    if (wrappedProperty.Get)
                    {
                        property.GetStatements.Add(new CodeMethodReturnStatement(invocation));
                    }

                    // Set statement
                    if (wrappedProperty.Set)
                    {
                        property.SetStatements.Add(new CodeAssignStatement(invocation, new CodeVariableReferenceExpression("value")));
                    }
                }

                // Events
                foreach (WrappedEvent wrappedEvent in wrappedType.WrappedEvents)
                {
                    // Event
                    MethodInfo eventDelegate = wrappedEvent.Event.EventHandlerType.GetMethod("Invoke");

                    CodeMemberEvent _event = new CodeMemberEvent();
                    classDeclaration.Members.Add(_event);
                    _event.Name = memberPrefix + wrappedEvent.Event.Name;
                    _event.Type = new CodeTypeReference(wrappedEvent.Event.EventHandlerType);

                    Generator.SetMember(_event, wrappedEvent);

                    if (!string.IsNullOrEmpty(wrappedEvent.Interface))
                    {
                        _event.PrivateImplementationType = new CodeTypeReference(wrappedEvent.Interface);
                    }

                    // Event handler/raiser
                    CodeMemberMethod eventHandler = new CodeMemberMethod();
                    classDeclaration.Members.Add(eventHandler);
                    eventHandler.Name       = string.Format("On{0}", _event.Name);
                    eventHandler.ReturnType = new CodeTypeReference(eventDelegate.ReturnType);
                    eventHandler.Attributes = MemberAttributes.Private;

                    List <CodeExpression> arguments = Generator.SetParameters(eventHandler, eventDelegate.GetParameters());

                    CodeEventReferenceExpression eventReference = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), _event.Name);
                    CodeConditionStatement       conditional    = new CodeConditionStatement();
                    eventHandler.Statements.Add(conditional);
                    conditional.Condition = new CodeBinaryOperatorExpression(eventReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));

                    CodeDelegateInvokeExpression eventInvocation = new CodeDelegateInvokeExpression(eventReference, arguments.ToArray());
                    if (eventDelegate.ReturnType == typeof(void))
                    {
                        conditional.TrueStatements.Add(eventInvocation);
                    }
                    else
                    {
                        conditional.TrueStatements.Add(new CodeMethodReturnStatement(eventInvocation));
                    }

                    // Event registration
                    CodeEventReferenceExpression  wrappedEventReference = new CodeEventReferenceExpression(fieldReference, wrappedEvent.Event.Name);
                    CodeMethodReferenceExpression eventRaiserReference  = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), eventHandler.Name);
                    CodeAttachEventStatement      eventRegistration     = new CodeAttachEventStatement(wrappedEventReference, eventRaiserReference);
                    initiazationStatements.Add(eventRegistration);
                }
            }

            // Generate the code
            StringWriter    stringWriter = new StringWriter();
            CodeDomProvider codeProvider = null;

            if (language == Language.CSharp)
            {
                codeProvider = new CSharpCodeProvider();
            }
            else if (language == Language.VBNet)
            {
                codeProvider = new VBCodeProvider();
            }
            else
            {
                throw new ArgumentException("Specified language is not supported: " + language);
            }
            CodeGeneratorOptions options = new CodeGeneratorOptions();

            options.BracingStyle = "C";
            codeProvider.GenerateCodeFromNamespace(_namespace, stringWriter, options);
            return(stringWriter.ToString());
        }
Пример #13
0
        public CodeTypeDelegateExample()
        {
            //<Snippet2>

            // Declares a type to contain the delegate and constructor method.
            CodeTypeDeclaration type1 = new CodeTypeDeclaration("DelegateTest");

            // Declares an event that accepts a custom delegate type of "TestDelegate".
            CodeMemberEvent event1 = new CodeMemberEvent();

            event1.Name = "TestEvent";
            event1.Type = new CodeTypeReference("DelegateTest.TestDelegate");
            type1.Members.Add(event1);

            //<Snippet3>
            // Declares a delegate type called TestDelegate with an EventArgs parameter.
            CodeTypeDelegate delegate1 = new CodeTypeDelegate("TestDelegate");

            delegate1.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "sender"));
            delegate1.Parameters.Add(new CodeParameterDeclarationExpression("System.EventArgs", "e"));

            // A C# code generator produces the following source code for the preceeding example code:

            //     public delegate void TestDelegate(object sender, System.EventArgs e);
            //</Snippet3>
            type1.Members.Add(delegate1);

            // Declares a method that matches the "TestDelegate" method signature.
            CodeMemberMethod method1 = new CodeMemberMethod();

            method1.Name = "TestMethod";
            method1.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "sender"));
            method1.Parameters.Add(new CodeParameterDeclarationExpression("System.EventArgs", "e"));
            type1.Members.Add(method1);

            // Defines a constructor that attaches a TestDelegate delegate pointing to the TestMethod method
            // to the TestEvent event.
            CodeConstructor constructor1 = new CodeConstructor();

            constructor1.Attributes = MemberAttributes.Public;
            CodeDelegateCreateExpression createDelegate1 = new CodeDelegateCreateExpression(
                new CodeTypeReference("DelegateTest.TestDelegate"), new CodeThisReferenceExpression(), "TestMethod");
            CodeAttachEventStatement attachStatement1 = new CodeAttachEventStatement(new CodeThisReferenceExpression(), "TestEvent", createDelegate1);

            constructor1.Statements.Add(attachStatement1);
            type1.Members.Add(constructor1);

            // A C# code generator produces the following source code for the preceeding example code:

            //    public class DelegateTest
            //    {
            //
            //        public DelegateTest()
            //        {
            //            this.TestEvent += new DelegateTest.TestDelegate(this.TestMethod);
            //        }
            //
            //        private event DelegateTest.TestDelegate TestEvent;
            //
            //        private void TestMethod(object sender, System.EventArgs e)
            //        {
            //        }
            //
            //        public delegate void TestDelegate(object sender, System.EventArgs e);
            //    }

            //</Snippet2>
        }
Пример #14
0
        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);
                    }
                }
            }
        }