public override bool OnMouseUp(Widget w, MouseInput mi)
        {
            if (w.Id == "MAINMENU_BUTTON_CREATE")
            {
                Game.chrome.rootWidget.ShowMenu("CREATESERVER_BG");
                return true;
            }

            if (w.Id == "CREATESERVER_BUTTON_CANCEL")
            {
                Game.chrome.rootWidget.ShowMenu("MAINMENU_BG");
                return true;
            }

            if (w.Id == "CREATESERVER_BUTTON_START")
            {
                Game.chrome.rootWidget.ShowMenu(null);
                Log.Write("Creating server");

                Server.Server.ServerMain(AdvertiseServerOnline, Game.Settings.MasterServer,
                                        Game.Settings.GameName, Game.Settings.ListenPort,
                                        Game.Settings.ExternalPort, Game.Settings.InitialMods);

                Log.Write("Joining server");
                Game.JoinServer(IPAddress.Loopback.ToString(), Game.Settings.ListenPort);
                return true;
            }

            return false;
        }

	public static void AddWidget(Container box, Widget widget, int position, bool expandAndFill = false)
	{
		box.Add(widget);
		((Box.BoxChild)box[widget]).Position = position;
		((Box.BoxChild)box[widget]).Expand = expandAndFill;
		((Box.BoxChild)box[widget]).Fill = expandAndFill;
	}

        public override bool GetState(Widget w)
        {
            if (w.Id == "CREATESERVER_CHECKBOX_ONLINE")
                return AdvertiseServerOnline;

            return false;
        }

 private string GetAlign(Widget frame)
 {
     if (((RadioButton)((HBox)((Frame)((Alignment)frame).Child).Child).Children[0]).Active == true)
         return "persistent-apps";
     else
         return "persistent-others";
 }

 //////////////////////////////////////////////////////////////////////////
 // Constructor
 //////////////////////////////////////////////////////////////////////////
 public static WidgetPeer make(Widget self)
 {
     System.Type type = System.Type.GetType("Fan.Fwt." + self.type().name().val + "Peer");
       WidgetPeer peer = (WidgetPeer)System.Activator.CreateInstance(type);
       peer.m_self = self;
       return peer;
 }

	protected override void OnRender (Cairo.Context cr, Widget widget, Rectangle background_area, Rectangle cell_area, CellRendererState flags)
	{
		int x = (int) (cell_area.X + this.Xpad);
		int y = (int) (cell_area.Y + this.Ypad);
		int width = (int) (cell_area.Width - this.Xpad * 2);
		int height = (int) (cell_area.Height - this.Ypad * 2);

		widget.StyleContext.Save ();
		widget.StyleContext.AddClass ("trough");
		widget.StyleContext.RenderBackground (cr, x, y, width, height);
		widget.StyleContext.RenderFrame (cr, x, y, width, height);
		
		Border padding = widget.StyleContext.GetPadding (StateFlags.Normal);
		x += padding.Left;
		y += padding.Top;
		width -= padding.Left + padding.Right;
		height -= padding.Top + padding.Bottom;

		widget.StyleContext.Restore ();
		
		widget.StyleContext.Save ();
		widget.StyleContext.AddClass ("progressbar");
		widget.StyleContext.RenderActivity (cr, x, y, (int) (width * Percentage), height);
		widget.StyleContext.Restore ();
	}

        public void GetAllProperties_By_Generic() {
            var widget = new Widget(1, "Widget No1");
            var accessor = DynamicAccessorFactory.CreateDynamicAccessor<Widget>();
            var properties = accessor.GetPropertyNameValueCollection(widget).ToDictionary(pair => pair.Key, pair => pair.Value);

            VerifyPropertyCollection(properties);
        }

		internal static FrameworkElementFactory CreateBoundColumnTemplate (ApplicationContext ctx, Widget parent, CellViewCollection views, string dataPath = ".")
		{
			if (views.Count == 1)
                return CreateBoundCellRenderer(ctx, parent, views[0], dataPath);
			
			FrameworkElementFactory container = new FrameworkElementFactory (typeof (StackPanel));
			container.SetValue (StackPanel.OrientationProperty, System.Windows.Controls.Orientation.Horizontal);

			foreach (CellView view in views) {
				var factory = CreateBoundCellRenderer(ctx, parent, view, dataPath);

				factory.SetValue(FrameworkElement.MarginProperty, CellMargins);

				if (view.VisibleField != null)
				{
					var binding = new Binding(dataPath + "[" + view.VisibleField.Index + "]");
					binding.Converter = new BooleanToVisibilityConverter();
					factory.SetBinding(UIElement.VisibilityProperty, binding);
				}
				else if (!view.Visible)
					factory.SetValue(UIElement.VisibilityProperty, Visibility.Collapsed);

				container.AppendChild(factory);
			}

			return container;
		}

        public WidgetInstance Build(Widget widget, IEnumerable<int> path, IBuildData buildData)
        {
            // Add the widget's parameters to the context to be picked up by any children
            var propertyInstances = widget.Properties.Select(p => p.Build(buildData)).ToList();
            buildData.ContextSets.Push(propertyInstances);

            var areas = widget.Areas.Select(
                (a, i) => new { Name = a.Name, Components = a.Build(this, path.Append(i), buildData) })
                .ToList()
                .ToDictionary(d => d.Name, d => d.Components);

            buildData.AreaContents.Push(areas);

            var specification = this.widgetSpecificationFinder(widget.Name);

            if (this.renderingInstructions.ShowAmendments)
            {
                specification.ApplyAmendments(this.componentLibrary);
            }

            // Notice that we're passing null as the path - we don't want to annotate the components from the widget
            // specification because they're not components that the editor of the current template can do anything about
            var components = specification.Components.Select((c, i) => c.Build(this, null, buildData)).ToList();

            buildData.AreaContents.Pop();
            buildData.ContextSets.Pop();

            return new WidgetInstance(
                path,
                this.renderingInstructions,
                components);
        }

	protected override void Render (Drawable window, Widget widget, Rectangle background_area, Rectangle cell_area, Rectangle expose_area, CellRendererState flags)
	{
		int width = 0, height = 0, x_offset = 0, y_offset = 0;
		StateType state;
		GetSize (widget, ref cell_area, out x_offset, out y_offset, out width, out height);

		if (widget.HasFocus)
			state = StateType.Active;
		else
			state = StateType.Normal;

		width -= (int) this.Xpad * 2;
		height -= (int) this.Ypad * 2;


		//FIXME: Style.PaintBox needs some customization so that if you pass it
		//a Gdk.Rectangle.Zero it gives a clipping area big enough to draw
		//everything
		Gdk.Rectangle clipping_area = new Gdk.Rectangle ((int) (cell_area.X + x_offset + this.Xpad), (int) (cell_area.Y + y_offset + this.Ypad), width - 1, height - 1);
		
		Style.PaintBox (widget.Style, (Gdk.Window) window, StateType.Normal, ShadowType.In, clipping_area, widget, "trough", (int) (cell_area.X + x_offset + this.Xpad), (int) (cell_area.Y + y_offset + this.Ypad), width - 1, height - 1);

		Gdk.Rectangle clipping_area2 = new Gdk.Rectangle ((int) (cell_area.X + x_offset + this.Xpad), (int) (cell_area.Y + y_offset + this.Ypad), (int) (width * Percentage), height - 1);
		
		Style.PaintBox (widget.Style, (Gdk.Window) window, state, ShadowType.Out, clipping_area2, widget, "bar", (int) (cell_area.X + x_offset + this.Xpad), (int) (cell_area.Y + y_offset + this.Ypad), (int) (width * Percentage), height - 1);
	}

 public VerticalLine(Widget parent)
     : base(parent)
 {
     Background = parent.Background;
     Foreground = ConsoleColor.Black;
     Border = BorderStyle.Thin;
 }

 //Take a widget, and extract its excluded choices, into excluded_choices list
 public void AppendExcluded(Widget w)
 {
     foreach(string s in (w as DialogWidget).excluded_choices)
     {
         excluded_choices.Add(s);
     }
 }

        public override bool OnMouseDown(Widget w, MouseInput mi)
        {
            if (w.Id == "SETTINGS_CHECKBOX_UNITDEBUG")
            {
                Game.Settings.UnitDebug = !Game.Settings.UnitDebug;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_PATHDEBUG")
            {
                Game.Settings.PathDebug = !Game.Settings.PathDebug;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_INDEXDEBUG")
            {
                Game.Settings.IndexDebug = !Game.Settings.IndexDebug;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_PERFGRAPH")
            {
                Game.Settings.PerfGraph = !Game.Settings.PerfGraph;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_PERFTEXT")
            {
                Game.Settings.PerfText = !Game.Settings.PerfText;
                return true;
            }

            return false;
        }

 public static void SaveValue(Widget editor, PropertyItem item, dynamic target)
 {
     var getEditValue = editor as IGetEditValue;
     if (getEditValue != null)
         getEditValue.GetEditValue(item, target);
     else
     {
         var stringValue = editor as IStringValue;
         if (stringValue != null)
             target[item.Name] = stringValue.Value;
         else
         {
             var booleanValue = editor as IBooleanValue;
             if (booleanValue != null)
                 target[item.Name] = booleanValue.Value;
             else
             {
                 var doubleValue = editor as IDoubleValue;
                 if (doubleValue != null)
                 {
                     var value = doubleValue.Value;
                     target[item.Name] = Double.IsNaN(value.As<double>()) ? null : value;
                 }
                 else if (editor.Element.Is(":input"))
                 {
                     target[item.Name] = editor.Element.GetValue();
                 }
             }
         }
     }
 }

 public void Can_delete_entity()
 {
     var w = new Widget { Name = "sproket", Tags = new[] { "big", "small" } };
     var doc = _sx.Save(w);
     _sx.Delete(w);
     Assert.IsFalse(_sx.ListDocuments().Any(x => x.Id == doc.Id && x.Revision == doc.Revision));
 }

        public void SetUp()
        {
            var specification = new WidgetSpecification(
                "widget name",
                Enumerable.Empty<PropertySpecification>(),
                new IComponent[]
                    {
                        new Atom("atom", Enumerable.Empty<Property>()),
                        new Placeholder("area 1"),
                        new Container("container", Enumerable.Empty<Property>(), new[] { new Placeholder("area 2") })
                    });

            var widget = new Widget(
                "widget name",
                new[]
                    {
                        new Area("area 1", new IComponent[] { new Atom("atom", Enumerable.Empty<Property>()), new Atom("atom", Enumerable.Empty<Property>()) }),
                        new Area("area 2", new IComponent[] { new Atom("atom", Enumerable.Empty<Property>()), new Atom("atom", Enumerable.Empty<Property>()), new Atom("atom", Enumerable.Empty<Property>()) })
                    });

            var buildContext = new BuildData(Enumerable.Empty<IContextItem>());

            var builder = new Builder(RenderingInstructions.BuildForPreview(), n => specification, null);

            this.instance = (WidgetInstance)widget.Build(builder, new[] { 0 }, buildContext);
        }

        public void SetUp()
        {
            var placeholder1 = new Placeholder("area 1");
            var placeholder2 = new Placeholder("area 2");
            var widgetSpecification = new WidgetSpecification("widget");
            widgetSpecification.Insert(0, placeholder1);
            widgetSpecification.Insert(1, placeholder2);

            var area = new Area("area 1");
            var widget = new Widget("widget", new[] { area });

            var buildContext = new BuildData(Enumerable.Empty<IContextItem>());

            var builder = new Builder(RenderingInstructions.BuildForPreview(), w => widgetSpecification, null);

            var instance = widget.Build(builder, new[] { 0 }, buildContext);

            var rendererFactory = MockRepository.GenerateStub<IRendererFactory>();
            this.viewHelper = MockRepository.GenerateStub<IViewHelper>();
            var multiRenderer = new MultiRenderer(rendererFactory);

            KolaConfigurationRegistry.RegisterRenderer(multiRenderer);

            this.result = instance.Render(multiRenderer);
        }

            private void AttachToTable(Table table,
						    Widget widget, uint x,
						    uint y, uint width)
            {
                //                      table.Attach(widget, x, x + width, y, y + 1, AttachOptions.Fill, AttachOptions.Fill, 2, 2);
                table.Attach (widget, x, x + width, y, y + 1);
            }

		public void Split(string fieldName, string captionName, params string[] args)
		{
			Widget dataset = new Widget();
			WidgetCollection rows = this["rows"] as WidgetCollection;
			if (rows == null || rows.Count < 1)
			{
				return;
			}
			Widget prevRow = rows[0];
			object prevValue = prevRow[fieldName];
			WidgetCollection temp = new WidgetCollection();
			foreach (Widget i in rows)
			{
				object v = i[fieldName];
				if (!object.Equals(v, prevValue))
				{
					AddPreviousCategory(captionName, dataset, prevRow, temp, args);
					temp = new WidgetCollection();
					prevRow = i;
					prevValue = v;
				}
				temp.Add(i);
			}
			AddPreviousCategory(captionName, dataset, prevRow, temp, args);
			this["dataset"] = dataset;
			this.Remove("rows");
		}

        static void Main(string[] args)
        {
            bool input = true;
            while (input)
            {
            Course course = new Course();
            course.Name = Question.AskForString(" Course Name? ");
            course.CRN = Question.AskForInt(" Course CRN number? ");
            int size = Question.AskForInt(" Number of Students? ");

            Widget[] students = new Widget[size];

            for (int i = 0; i < size; i++)
            {
                students[i] = new Widget();
                students[i].SetID(Question.AskForString(" Student Name? "));
                students[i].SetDescription(Question.AskForString(" Student Snumber? "));
            }

            foreach (Widget Student in students)
            {
                Student.Print();
            }

            input = Question.AskForString(" Would you like to start over? ").ToLower().StartsWith("y");

            }

            System.Console.WriteLine();
            System.Console.WriteLine(" Press any key to continue...");
            System.Console.Write(" ");
            System.Console.ReadKey();
        }