public object RecreateInterfaceProxy(SerializationInfo info, StreamingContext context)
		{
			object proxy = null;

			GeneratorContext genContext = new GeneratorContext();

			foreach(object mixin in _mixins)
			{
				genContext.AddMixinInstance(mixin);
			}

			InterfaceProxyGenerator gen = new InterfaceProxyGenerator( _scope, genContext );

			object target = info.GetValue("__target", typeof(object));

			if (_mixins.Length == 0)
			{
				Type proxy_type = gen.GenerateCode( _interfaces, target.GetType());

				proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor, target } );
			}
			else
			{
				Type proxy_type = gen.GenerateCode( _interfaces, target.GetType() );

				proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor, target, genContext.MixinsAsArray() } );
			}

			return proxy;
		}

		protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop)
		{
			if (prop.Name == "Alpha" && Alpha == -1)
				return;
			else
				base.GeneratePropertySet (ctx, var, prop);
		}

		public void TwoMixins()
		{
			GeneratorContext context = new GeneratorContext();
			SimpleMixin mixin1 = new SimpleMixin();
			OtherMixin mixin2 = new OtherMixin();

			context.AddMixinInstance( mixin1 );
			context.AddMixinInstance( mixin2 );

			AssertInvocationInterceptor interceptor = new AssertInvocationInterceptor();

			object proxy = _generator.CreateCustomClassProxy( 
				typeof(SimpleClass), interceptor, context );
			
			Assert.IsFalse( interceptor.Invoked );

			Assert.IsNotNull(proxy);
			Assert.IsTrue( typeof(SimpleClass).IsAssignableFrom( proxy.GetType() ) );

			ISimpleMixin mixin = proxy as ISimpleMixin;
			Assert.IsNotNull(mixin);
			Assert.AreEqual(1, mixin.DoSomething());

			Assert.IsTrue( interceptor.Invoked );
			Assert.AreSame( proxy, interceptor.proxy );
			Assert.AreSame( mixin1, interceptor.mixin );

			IOtherMixin other = proxy as IOtherMixin;
			Assert.IsNotNull(other);
			Assert.AreEqual(3, other.Sum(1,2));
			Assert.IsTrue( interceptor.Invoked );
			Assert.AreSame( proxy, interceptor.proxy );
			Assert.AreSame( mixin2, interceptor.mixin );

		}

		internal protected override CodeExpression GenerateObjectCreation (GeneratorContext ctx)
		{
			return new CodeObjectCreateExpression (
				ClassDescriptor.WrappedTypeName.ToGlobalTypeRef (), 
				new CodePrimitiveExpression (null), 
				new CodePrimitiveExpression (null)
			);
		}

		internal protected override CodeExpression GenerateObjectCreation (GeneratorContext ctx)
		{
			if (textCombo) {
				return new CodeMethodInvokeExpression (
					new CodeTypeReferenceExpression (new CodeTypeReference ("Gtk.ComboBox", CodeTypeReferenceOptions.GlobalReference)),
					"NewText"
				);
			} else
				return base.GenerateObjectCreation (ctx);
		}

        public void Run(ServiceDefinition definition)
        {
            var context = new GeneratorContext();
            context.Definition = definition;
            context.Root = definition.Root;

            this.WriteEverything(context);

            text.Flush();
        }

 protected internal override CodeExpression GenerateObjectCreation(GeneratorContext ctx)
 {
     if (IsTextCombo) {
         return new CodeMethodInvokeExpression (
             new CodeTypeReferenceExpression ("Gtk.ComboBoxEntry"),
             "NewText"
         );
     } else
         return base.GenerateObjectCreation (ctx);
 }

        public void CreateCustomProxy()
        {
            GeneratorContext context = new GeneratorContext(
                new EnhanceTypeDelegate(EnhanceType),
                new ScreenInterfacesDelegate(ScreenInterfaces));

            object proxy = m_generator.CreateCustomProxy(
                typeof (IMyInterface),
                new StandardInvocationHandler(new MyInterfaceImpl()), context);

            Assert.IsTrue( m_enhanceInvoked );
            Assert.IsTrue( m_screenInvoked );
        }

		protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop)
		{
			if (prop.Name == "Group") {
				CodeExpression groupExp = GroupManager.GenerateGroupExpression (ctx, (Gtk.Widget) Wrapped);
				ctx.Statements.Add (
					new CodeAssignStatement (
						new CodePropertyReferenceExpression (var, "Group"),
						groupExp)
				);
			}
			else
				base.GeneratePropertySet (ctx, var, prop);
		}

        public void GenerateBuildCode(GeneratorContext ctx, CodeVariableReferenceExpression uiManager)
        {
            StringBuilder sb = new StringBuilder ();
            sb.Append ("<ui>");
            GenerateUiString (sb);
            sb.Append ("</ui>");

            CodeMethodInvokeExpression exp = new CodeMethodInvokeExpression (
                uiManager,
                "AddUiFromString",
                new CodePrimitiveExpression (sb.ToString ())
            );
            ctx.Statements.Add (exp);
        }

 public static void Main(string[] args)
 {
     try
     {
         List<object> instances = new List<object>();
         GeneratorContext context = new GeneratorContext();
         Generator generator = new Generator(instances, context);
         generator.Execute();
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex);
     }
 }

		protected override void GenerateChildBuildCode (GeneratorContext ctx, CodeExpression parentVar, Widget wrapper)
		{
			if (wrapper.Wrapped == expander.LabelWidget) {
				CodeExpression var = ctx.GenerateNewInstanceCode (wrapper);
				CodeAssignStatement assign = new CodeAssignStatement (
					new CodePropertyReferenceExpression (
						parentVar,
						"LabelWidget"
					),
					var
				);
				ctx.Statements.Add (assign);
			} else
				base.GenerateChildBuildCode (ctx, parentVar, wrapper);
		}

		static void Main(string[] args)
		{
			AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);

			MainOptions opts = new MainOptions();
			opts.ProcessArgs(args);

			if (args.Length == 0 || args[0].StartsWith("-"))
			{
				ShowUsage();
			}

			Console.WriteLine("Processing {0} {1}", args[0], opts.verbose);

			IGenerator generator = null;

			if (args[0] == "controller")
			{
				generator = new NewController();
			}
			else if (args[0] == "project")
			{
				generator = new NewProject();
			}
			else
			{
				Console.Error.WriteLine("Not supported");
				return;
			}

			Configure(generator, args);

			string workingDir = AppDomain.CurrentDomain.BaseDirectory;
			string templateDir = @"C:\dev\DotNet\castle\svn\trunk\MonoRail\NewGenerator\GeneratorTemplates\";

			GeneratorContext context = new GeneratorContext(workingDir, templateDir);

			ITemplateEngine engine = new NVelocityTemplateEngine(templateDir);

			if (engine is ISupportInitialize)
			{
				((ISupportInitialize)engine).BeginInit();
			}

			generator.Generate(context, new DefaultGeneratorService(context, engine));
		}

		protected override void GenerateChildBuildCode (GeneratorContext ctx, CodeExpression parentVar, Widget wrapper)
		{
			if (!HasLabel) {
				// CheckButton generates a label by default. Remove it if it is not required.
				ctx.Statements.Add (
					new CodeMethodInvokeExpression (
						parentVar,
						"Remove",
						new CodePropertyReferenceExpression (
							parentVar,
							"Child"
						)
					)
				);
			}
			base.GenerateChildBuildCode (ctx, parentVar, wrapper);
		}

		internal protected override void GenerateBuildCode (GeneratorContext ctx, CodeExpression var)
		{
			if (Text.Length > 0) {
				ctx.Statements.Add (
					new CodeAssignStatement (
						new CodePropertyReferenceExpression (
							new CodePropertyReferenceExpression (
								var,
								"Buffer"
							),
							"Text"
						),
						new CodePrimitiveExpression (Text)
					)
				);
			}
			base.GenerateBuildCode (ctx, var);
		}

		internal protected override void GeneratePostBuildCode (GeneratorContext ctx, CodeExpression var)
		{
			if (mnem != null) {
				Widget targetWidget = GetTopLevel ().FindChild (mnem);
				if (targetWidget != null) {
					CodeExpression memVar = ctx.WidgetMap.GetWidgetExp (targetWidget);
					if (memVar != null) {
						ctx.Statements.Add (
							new CodeAssignStatement (
								new CodePropertyReferenceExpression (
									var, 
									"MnemonicWidget"
								),
								memVar
							)
						);
					}
				}
			}
			base.GeneratePostBuildCode (ctx, var);
		}

		public void Execute(object Application, int hwndOwner, ref object[] ContextParams, ref object[] CustomParams,
		                    ref wizardResult retval)
		{
			DTE dte = (DTE) Application;

			AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
			
			string workingDir =  (string) ContextParams[3];
			string templateDir = @"C:\dev\DotNet\castle\svn\trunk\MonoRail\NewGenerator\GeneratorTemplates\";

			context = new GeneratorContext(workingDir, templateDir);

			//Using NVelocityTemplateEngine. Since we must resolve the lib dir...
			templateEngine = new NVelocityTemplateEngine(templateDir);
			((ISupportInitialize) templateEngine).BeginInit();

			NewProject generator = CreateNewProject(ContextParams);

			generator.Generate(context, this);

			dte.Solution.Open(generator.SolutionFilePath);
		}

        public CodeExpression GenerateGroupExpression(GeneratorContext ctx, Action action)
        {
            // Returns and expression that represents the group to which the radio belongs.
            // This expression can be an empty SList, if this is the first radio of the
            // group that has been generated, or an SList taken from previously generated
            // radios from the same group.

            string group = actions [action] as string;
            if (group == null)
                return new CodePrimitiveExpression (null);

            CodeExpression var = null;

            foreach (Action a in FindActionsInGroup (group)) {
                if (a == action)
                    continue;
                var = ctx.WidgetMap.GetWidgetExp (a);
                if (var != null)
                    break;
            }

            if (var == null) {
                return new CodeObjectCreateExpression (
                    "GLib.SList",
                    new CodePropertyReferenceExpression (
                        new CodeTypeReferenceExpression (typeof(IntPtr)),
                        "Zero"
                    )
                );
            } else {
                return new CodePropertyReferenceExpression (
                    var,
                    "Group"
                );
            }
        }

		internal protected override void GeneratePostBuildCode (GeneratorContext ctx, CodeExpression var)
		{
			base.GeneratePostBuildCode (ctx, var);
			
			// The visible property is generated here to ensure that widgets are made visible
			// after they have been fully built
			
			PropertyDescriptor prop = ClassDescriptor ["Visible"] as PropertyDescriptor;
			if (prop != null && prop.PropertyType == typeof(bool) && !(bool) prop.GetValue (Wrapped)) {
				ctx.Statements.Add (
					new CodeMethodInvokeExpression (
						var, 
						"Hide"
					)
				);
			}
			
			// The HasDefault property can only be assigned when the widget is added to the window
			prop = ClassDescriptor ["HasDefault"] as PropertyDescriptor;
			if (prop != null && (bool) prop.GetValue (Wrapped)) {
				ctx.Statements.Add (
					new CodeAssignStatement (
						new CodePropertyReferenceExpression (
							var,
							"HasDefault"
						),
						new CodePrimitiveExpression (true)
					)
				);
			}
		}

		internal protected override void GenerateBuildCode (GeneratorContext ctx, CodeExpression var)
		{
			if (Type == ActionType.Radio) {
				CodeExpression groupExp = GroupManager.GenerateGroupExpression (ctx, this);
				ctx.Statements.Add (
					new CodeAssignStatement (
						new CodePropertyReferenceExpression (var, "Group"),
						groupExp)
				);
			}
			else if (type == ActionType.Toggle) {
				if (Active) {
					ctx.Statements.Add (
						new CodeAssignStatement (
							new CodePropertyReferenceExpression (var, "Active"),
							new CodePrimitiveExpression (true))
					);
				}
				if (DrawAsRadio) {
					ctx.Statements.Add (
						new CodeAssignStatement (
							new CodePropertyReferenceExpression (var, "DrawAsRadio"),
							new CodePrimitiveExpression (true))
					);
				}
			}
			base.GenerateBuildCode (ctx, var);
		}