changeset 0:1bb28f84d567

Initial commit of WarFoundry code
author IBBoard <dev@ibboard.co.uk>
date Fri, 19 Dec 2008 15:57:51 +0000
parents
children a3c70b542257
files App.ico App.png AssemblyInfo.cs Dialog.cs FrmChangeGameSystem.cs FrmMainWindow.cs FrmNewArmy.cs FrmNewUnit.cs WarFoundry GTK# GUI.pidb WarFoundryGUI.exe.log4net WarFoundryGUI.mdp Widgets/UnitDisplayWidget.cs gtk-gui/IBBoard.WarFoundry.FrmChangeGameSystem.cs gtk-gui/IBBoard.WarFoundry.FrmMainWindow.cs gtk-gui/IBBoard.WarFoundry.FrmNewArmy.cs gtk-gui/IBBoard.WarFoundry.FrmNewUnit.cs gtk-gui/IBBoard.WarFoundry.Widgets.UnitDisplayWidget.cs gtk-gui/generated.cs gtk-gui/gui.stetic gtk-gui/objects.xml libs/log4net.dll libs/log4net.xml
diffstat 22 files changed, 31401 insertions(+), 0 deletions(-) [+]
line wrap: on
line diff
Binary file App.ico has changed
Binary file App.png has changed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AssemblyInfo.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly: AssemblyTitle("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly: AssemblyVersion("1.0.*")]
+
+// The following attributes specify the key for the sign of your assembly. See the
+// .NET Framework documentation for more information about signing.
+// This is not required, if you don't want signing let these attributes like they're.
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+
+
+[assembly: log4net.Config.XmlConfigurator(ConfigFileExtension="log4net",Watch=true)]
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Dialog.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,21 @@
+// Dialog.cs created with MonoDevelop
+// User: ibboard at 20:40 14/06/2008
+//
+// To change standard headers go to Edit->Preferences->Coding->Standard Headers
+//
+
+using System;
+
+namespace IBBoard.WarFoundry
+{
+	
+	
+	public partial class Dialog : Gtk.Dialog
+	{
+		
+		public Dialog()
+		{
+			this.Build();
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FrmChangeGameSystem.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,100 @@
+// FrmChangeGameSystem.cs
+//
+//  Copyright (C) 2007 IBBoard
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License version 2.1 of the License as published by the Free
+// Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+//
+//
+
+using System;
+using IBBoard.WarFoundry.API;
+using IBBoard.WarFoundry.API.Objects;
+using Gtk;
+using log4net;
+
+namespace IBBoard.WarFoundry
+{
+	public partial class FrmChangeGameSystem : Dialog
+	{
+		private ILog logger = LogManager.GetLogger(typeof(FrmChangeGameSystem));
+		//private AbstractNativeWarFoundryFactory factory;
+		private GameSystem selectedSystem;
+		
+		public FrmChangeGameSystem(Window parent) : base("Change Game System", parent, DialogFlags.Modal)
+		{
+			this.Build();
+			lstGameSystems.Selection.Changed+= new EventHandler(OnSelectionChanged);
+			TreeViewColumn gameSystemColumn = new TreeViewColumn ();
+			gameSystemColumn.Title = "Game System";
+			CellRendererText gameSystemCell = new CellRendererText ();
+			gameSystemColumn.PackStart (gameSystemCell, true);
+			lstGameSystems.AppendColumn(gameSystemColumn);
+			gameSystemColumn.SetCellDataFunc (gameSystemCell, new TreeCellDataFunc (RenderSystemName));
+			ListStore store = new ListStore(typeof(GameSystem));
+			
+			foreach (GameSystem system in WarFoundryLoader.GetDefault().GetGameSystems())
+			{
+				store.AppendValues(system);
+			}
+			
+			lstGameSystems.Model = store;
+		}
+		
+		private void RenderSystemName(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
+		{
+			GameSystem system = (GameSystem) model.GetValue(iter, 0);
+			(cell as CellRendererText).Text = system.Name;
+		}
+
+		protected virtual void OnGameSystemOkayClicked(object sender, EventArgs e)
+		{
+			logger.Debug("Okay clicked");
+			SetReturnValue();
+			Respond(ResponseType.Ok);
+		}
+		
+		private void SetReturnValue()
+		{
+			TreeModel model;
+			TreeIter iter;
+			lstGameSystems.Selection.GetSelected (out model, out iter);
+			selectedSystem = (GameSystem) model.GetValue(iter, 0);
+		}
+
+		protected virtual void OnSelectionChanged(object o, EventArgs e)
+		{
+			logger.Debug("Selection changed");
+			buttonOk.Sensitive = (lstGameSystems.Selection.CountSelectedRows() > 0);
+		}
+
+		protected virtual void OnCancel (object sender, System.EventArgs e)
+		{
+			logger.Debug("Cancel clicked");
+			Respond(ResponseType.Cancel);
+		}
+
+		protected virtual void lstGameSystemsRowActivated (object o, Gtk.RowActivatedArgs args)
+		{
+			logger.Debug("List row double-clicked");
+			SetReturnValue();
+			Respond(ResponseType.Ok);
+		}
+		
+		public GameSystem SelectedSystem
+		{
+			get { return selectedSystem; }
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FrmMainWindow.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,925 @@
+// FrmMainWindow.cs
+//
+//  Copyright (C) 2007 IBBoard
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License version 2.1 of the License as published by the Free
+// Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+//
+//
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Configuration;
+using Gtk;
+using IBBoard;
+using IBBoard.Commands;
+using IBBoard.IO;
+using IBBoard.Lang;
+using IBBoard.Logging;
+using IBBoard.CustomMath;
+using IBBoard.Log4Net;
+using IBBoard.WarFoundry.API;
+using IBBoard.WarFoundry.API.Factories;
+using IBBoard.WarFoundry.API.Factories.Xml;
+using IBBoard.WarFoundry.API.Objects;
+using IBBoard.WarFoundry.API.Commands;
+using IBBoard.WarFoundry.API.Savers;
+using IBBoard.WarFoundry.API.Requirements;
+using IBBoard.WarFoundry.Widgets;
+using IBBoard.WarFoundry.Plugin.Rollcall;
+using IBBoard.Xml;
+using log4net;
+
+namespace IBBoard.WarFoundry
+{	
+	public partial class FrmMainWindow: Gtk.Window
+	{
+		private static readonly string AppTitle = "WarFoundry";
+		private const int CATEGORY_BUTTON_SEPARATOR_INDEX = 6;
+
+		private Preferences preferences;
+		private ILog logger = LogManager.GetLogger(typeof(FrmMainWindow));
+
+		private CommandStack commandStack;
+		private Type factoryType = typeof(WarFoundryXmlFactory);
+		private Dictionary<ToolButton, Category> categoryMap = new Dictionary<ToolButton, Category>();
+		private Dictionary<IBBoard.WarFoundry.API.Objects.Unit, UnitDisplayWidget> unitToWidgetMap = new Dictionary<IBBoard.WarFoundry.API.Objects.Unit,UnitDisplayWidget>();
+
+		private ObjectAddDelegate UnitAddedMethod;
+		private ObjectRemoveDelegate UnitRemovedMethod;
+		private DoubleValChangedDelegate PointsValueChangedMethod;
+		private FailedUnitRequirementDelegate FailedUnitRequirementMethod;
+		private StringValChangedDelegate UnitNameChangedMethod;
+		
+		private GameSystem system;
+		private string loadedArmyPath;
+		
+		private MenuToolButton undoMenuButton, redoMenuButton;
+		
+		public static void Main (string[] args)
+		{			
+			try
+			{
+				Application.Init();
+				FrmMainWindow win = new FrmMainWindow(args);
+				win.Show();
+				Application.Run();
+				LogManager.GetLogger(typeof(FrmMainWindow)).Debug("Application ended");
+			}
+			catch(Exception ex)
+			{
+				LogManager.GetLogger(typeof(FrmMainWindow)).Fatal(ex.Message + Environment.NewLine + ex.StackTrace);
+			}
+		}
+		
+		public FrmMainWindow() : this(new string[0])
+		{
+			//Do nothing extra
+		}
+			
+		public FrmMainWindow (string[] args): base (Gtk.WindowType.Toplevel)
+		{
+			logger.Info("Opening FrmMainWindow");
+			LogNotifierHandler.RegisterNotifierHandler();
+			Build ();
+			//Replace the undo/redo buttons with menu versions, which Monodevelop's GUI editor doesn't currently support
+			redoMenuButton = new MenuToolButton("gtk-redo");
+			redoMenuButton.Label = "Redo";
+			redoMenuButton.SetTooltip(new Tooltips(), "Redo", "");
+			redoMenuButton.Clicked+= redoTBButtonActivated;
+			toolbar.Insert(redoMenuButton, CATEGORY_BUTTON_SEPARATOR_INDEX);
+			undoMenuButton = new MenuToolButton("gtk-undo");
+			undoMenuButton.Label = "Undo";
+			undoMenuButton.SetTooltip(new Tooltips(), "Undo", "");
+			undoMenuButton.Clicked+= undoTBButtonActivated;
+			toolbar.Insert(undoMenuButton, CATEGORY_BUTTON_SEPARATOR_INDEX);
+			toolbar.Remove(toolbar.Children[CATEGORY_BUTTON_SEPARATOR_INDEX-1]);
+			toolbar.Remove(toolbar.Children[CATEGORY_BUTTON_SEPARATOR_INDEX-2]);
+			toolbar.ShowAll();
+			
+			Title = AppTitle;
+			TreeViewColumn mainColumn = new TreeViewColumn ();
+			mainColumn.Title = "Army Categories";
+			CellRendererText mainCell = new CellRendererText ();
+			mainColumn.PackStart (mainCell, true);
+			treeUnits.AppendColumn(mainColumn);
+			mainColumn.SetCellDataFunc(mainCell, new TreeCellDataFunc(RenderCategoryTreeObjectName));
+			treeUnits.Model = new TreeStore(typeof(WarFoundryObject));
+			logger.Debug("Loading preferences");
+			Preferences = new Preferences("WarFoundryGTK");
+			logger.Debug("Loading translations");
+			Translation.InitialiseTranslations(Constants.ExecutablePath, Preferences["language"].ToString());
+			logger.Debug("Initialising");
+			commandStack = new CommandStack();
+			commandStack.CommandStackUpdated+=new MethodInvoker(commandStack_CommandStackUpdated);
+			WarFoundryCore.GameSystemChanged+= new GameSystemChangedDelegate(OnGameSystemChanged);
+			WarFoundryCore.ArmyChanged+= new ArmyChangedDelegate(OnArmyChanged);
+			Destroyed+= new EventHandler(OnWindowDestroyed);
+			//TODO: Translate and subscribe to other events
+			UnitAddedMethod = new ObjectAddDelegate(OnUnitAdded);
+			UnitRemovedMethod = new ObjectRemoveDelegate(OnUnitRemoved);
+			PointsValueChangedMethod = new DoubleValChangedDelegate(OnPointsValueChanged);
+			FailedUnitRequirementMethod = new FailedUnitRequirementDelegate(OnFailedUnitRequirement);
+			UnitNameChangedMethod = new StringValChangedDelegate(OnUnitNameChanged);
+			logger.Debug("Initialising complete - trying to load default army or system");
+			
+			//FIXME: Temporary hack to add paths and factories
+			WarFoundryLoader.GetDefault().AddLoadDirectory(new DirectoryInfo(Constants.ExecutablePath + Constants.DirectoryString + "data"));
+			IWarFoundryFactory factory = WarFoundryFactoryFactory.GetFactoryFactory().GetFactory(typeof(WarFoundryXmlFactory));
+			
+			if (factory!=null && factory is WarFoundryXmlFactory)
+			{
+				WarFoundryLoader.GetDefault().RegisterFactory((WarFoundryXmlFactory)factory);
+			}
+			
+			factory = WarFoundryFactoryFactory.GetFactoryFactory().GetFactory(typeof(RollcallFactory));
+			
+			if (factory!=null && factory is RollcallFactory)
+			{
+				WarFoundryLoader.GetDefault().RegisterNonNativeFactory((INonNativeWarFoundryFactory)factory);
+			}
+								
+			if (args.Length == 1)
+			{
+				logger.Debug("Attempting to load from file");				
+				FileInfo file = new FileInfo(args[0]);
+				
+				try
+				{
+					//TODO: Try to load files
+					/*if (file.Extension.Equals("."+Factory.GetArmyFileExtension()))
+					{
+						WarFoundryCore.CurrentArmy = Factory.CreateArmyFromFile(file);
+						logger.InfoFormat("Loaded army from {0}", file.FullName);
+					}
+					else if (file.Extension.Equals("."+Factory.GetSystemFileExtension()))
+					{
+						WarFoundryCore.CurrentGameSystem = Factory.CreateGameSystemFromFile(file);
+						logger.InfoFormat("Loaded game system from {0}", file.FullName);
+					}*/
+				}
+				catch (InvalidFileException ex)
+				{
+					//TODO: show error dialog
+					logger.Error(ex);
+				}
+			}
+			else
+			{
+				string gameSystemID = Preferences.GetStringProperty("currSystem");
+
+				if (gameSystemID!=null && !"".Equals(gameSystemID))
+				{
+					logger.Debug("Attempting to load current game system from properties");
+					GameSystem sys = WarFoundryLoader.GetDefault().GetGameSystem(gameSystemID);
+					
+					if (sys!=null)
+					{
+						WarFoundryCore.CurrentGameSystem = sys;
+						logger.InfoFormat("Loaded game system {0} from properties", gameSystemID);
+					}
+				}
+			}
+		}
+		
+		private void RenderCategoryTreeObjectName(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
+		{
+			object o = model.GetValue(iter, 0);
+			
+			if (o is ArmyCategory)
+			{
+				ArmyCategory c = (ArmyCategory)o;
+				string name = "";
+				
+				if (Preferences.GetBooleanProperty("ShowCatPercentage"))
+				{
+					name = Translation.GetTranslation("categoryTreeCatName", "{0} - {1}pts", c.Name, c.PointsTotal);
+				}
+				else
+				{
+					name = Translation.GetTranslation("categoryTreeCatNamePercentage", "{0} - {1}pts ({2}%)", c.Name, c.PointsTotal, (c.ParentArmy.PointsTotal > 0 ? Math.Round((c.PointsTotal / c.ParentArmy.PointsTotal) * 100) : 0));
+				}
+				
+				(cell as CellRendererText).Text = name;
+			}
+			else if (o is IBBoard.WarFoundry.API.Objects.Unit)
+			{
+				IBBoard.WarFoundry.API.Objects.Unit u = (IBBoard.WarFoundry.API.Objects.Unit)o;
+				string name = Translation.GetTranslation("categoryTreeCatName", "{0} - {1}pts", u.Name, u.PointsValue);
+				(cell as CellRendererText).Text = name;
+			}
+		}
+		
+		private void OnWindowDestroyed(object source, EventArgs args)
+		{
+			logger.Info("Exiting");
+			Application.Quit();
+		}
+		
+		private void OnUnitNameChanged(WarFoundryObject val, string oldValue, string newValue)
+		{
+			IBBoard.WarFoundry.API.Objects.Unit unit = (IBBoard.WarFoundry.API.Objects.Unit)val;
+			UnitDisplayWidget widget;
+			unitToWidgetMap.TryGetValue(unit, out widget);
+			
+			if (widget!=null)
+			{
+				unitsNotebook.SetTabLabelText(widget, newValue);
+			}
+		}
+		
+		private void OnUnitAdded(WarFoundryObject val)
+		{
+			IBBoard.WarFoundry.API.Objects.Unit unit = (IBBoard.WarFoundry.API.Objects.Unit)val;
+			unit.NameChanged+= UnitNameChangedMethod;
+			AddUnitToTree(unit);
+		}
+		
+		private void AddUnitToTree(IBBoard.WarFoundry.API.Objects.Unit unit)
+		{
+			TreeStore model = (TreeStore)treeUnits.Model;
+			TreeIter iter;
+			model.GetIterFirst(out iter);
+			
+			do
+			{
+				object obj = model.GetValue(iter, 0);
+				
+				if (obj is ArmyCategory)
+				{
+					ArmyCategory cat = (ArmyCategory)obj;
+					
+					if (cat.Equals(unit.Category))
+					{
+						model.AppendValues(iter, unit);
+						TreePath path = model.GetPath(iter);
+						treeUnits.ExpandToPath(path);
+					}
+				}
+			}
+			while (model.IterNext(ref iter));
+		}
+		
+		private void OnUnitRemoved(WarFoundryObject obj)
+		{
+			IBBoard.WarFoundry.API.Objects.Unit unit = (IBBoard.WarFoundry.API.Objects.Unit)obj;
+			unit.NameChanged-= UnitNameChangedMethod;
+			RemoveUnitFromTree(unit);
+			
+			//See if unit has a tab open and close it if it does
+		}
+		
+		private void RemoveUnitFromTree(IBBoard.WarFoundry.API.Objects.Unit unit)
+		{
+			TreeStore model = (TreeStore)treeUnits.Model;
+			TreeIter iter;
+			model.GetIterFirst(out iter);
+			bool removed = false;
+			
+			do
+			{
+				object obj = model.GetValue(iter, 0);
+				
+				if (obj is ArmyCategory)
+				{
+					ArmyCategory cat = (ArmyCategory)obj;
+					
+					if (unit.Category == null || cat.Equals(unit.Category))
+					{
+						TreeIter innerIter;
+						model.IterChildren(out innerIter, iter);
+						
+						do
+						{
+							object innerObj = model.GetValue(innerIter, 0);
+							
+							if (unit.Equals(innerObj))
+							{
+								model.Remove(ref innerIter);
+								removed = true;
+								break;
+							}
+						}
+						while (model.IterNext(ref innerIter));
+						
+						if (removed)
+						{
+							break;
+						}
+					}
+				}
+			}
+			while (model.IterNext(ref iter));
+		}
+		
+		private void OnPointsValueChanged(WarFoundryObject obj, double before, double after)
+		{
+			//Set points in panel
+		}
+		
+		private void OnFailedUnitRequirement(List<FailedUnitRequirement> failedRequirement)
+		{
+			//Show error message in panel
+		}
+		
+		public Preferences Preferences
+		{
+			get { return preferences; }
+			set { preferences = value; }		
+		}
+		
+		/*public AbstractNativeWarFoundryFactory Factory
+		{
+			get { return WarFoundryFactoryFactory.GetFactoryFactory().GetFactory(Constants.ExecutablePath, factoryType); }
+		}*/
+		
+		protected void OnDeleteEvent (object sender, DeleteEventArgs a)
+		{
+			Application.Quit ();
+			a.RetVal = true;
+		}
+
+		protected virtual void OnExitActivated(object sender, System.EventArgs e)
+		{
+			Application.Quit();
+		}
+
+		protected virtual void OnChangeGameSystemActivated(object sender, System.EventArgs e)
+		{
+			ChangeCurrentGameSystem();
+		}
+
+		protected virtual void OnCreateArmyActivated(object sender, System.EventArgs e)
+		{
+			CreateNewArmy();
+		}
+
+		protected virtual void OnReloadFilesActivated(object sender, System.EventArgs e)
+		{
+		}
+
+		protected virtual void OnSaveArmyAsActivated(object sender, System.EventArgs e)
+		{
+			SaveCurrentArmyAs();
+		}
+
+		protected virtual void OnCloseArmyActivated(object sender, System.EventArgs e)
+		{
+			CloseCurrentArmy();
+		}
+
+		protected virtual void OnOpenArmyActivated(object sender, System.EventArgs e)
+		{
+			OpenArmy();
+		}
+
+		protected virtual void OnSaveArmyActivated(object sender, System.EventArgs e)
+		{
+			SaveCurrentArmy();
+		}
+		
+		protected virtual void OnAddUnitActivated(object sender, System.EventArgs e)
+		{
+			if (sender is ToolButton)
+			{
+				Category cat = null;
+				categoryMap.TryGetValue((ToolButton)sender, out cat);
+				
+				if (cat!=null)
+				{
+					logger.DebugFormat("Show FrmNewUnit for {0}", cat.Name);
+					FrmNewUnit newUnit = new FrmNewUnit(WarFoundryCore.CurrentArmy.Race, cat, WarFoundryCore.CurrentArmy);
+					ResponseType response = (ResponseType)newUnit.Run();
+					newUnit.Hide();
+					
+					if (response==ResponseType.Ok)
+					{
+						CreateAndAddUnitCommand cmd = new CreateAndAddUnitCommand(newUnit.SelectedUnit, cat, WarFoundryCore.CurrentArmy);
+						commandStack.Execute(cmd);
+					}
+					
+					newUnit.Dispose();
+				}
+			}
+		}
+		
+		public CommandStack CommandStack
+		{
+			get { return commandStack; }
+		}
+		
+		private void SetAppTitle()
+		{
+			if (WarFoundryCore.CurrentArmy!=null)
+			{
+				Title = AppTitle + " - " + WarFoundryCore.CurrentGameSystem.Name + " - " + WarFoundryCore.CurrentArmy.Name;
+			}
+			else if (WarFoundryCore.CurrentGameSystem!=null)
+			{
+				Title = AppTitle + " - " + WarFoundryCore.CurrentGameSystem.Name;
+			}
+			else
+			{
+				Title = AppTitle;
+			}
+		}
+		
+		private void OnGameSystemChanged(GameSystem oldSys, GameSystem newSys)
+		{
+			system = newSys;
+			SetAppTitle();
+			miCreateArmy.Sensitive = system!=null;
+			newArmyButton.Sensitive = system!=null;
+			RemoveCategoryButtons();
+			
+			if (system!=null)
+			{
+				AddCategoryButtons(system.Categories);
+			}
+		}
+		
+		private void OnArmyChanged(Army oldArmy, Army newArmy)
+		{
+			loadedArmyPath = null;
+			SetAppTitle();
+			SetArmyTree(newArmy);
+						
+			if (oldArmy!=null)
+			{
+				oldArmy.UnitAdded-= UnitAddedMethod;
+				oldArmy.UnitRemoved-= UnitRemovedMethod;
+				oldArmy.PointsValueChanged-= PointsValueChangedMethod;
+				oldArmy.FailedRequirement-=FailedUnitRequirementMethod;				
+			}
+			
+			unitToWidgetMap.Clear();
+			
+			while (unitsNotebook.NPages > 0)
+			{
+				unitsNotebook.RemovePage(0);
+			}
+			
+			if (newArmy==null)
+			{
+				DisableCategoryButtons();
+			}
+			else
+			{
+				newArmy.UnitAdded+= UnitAddedMethod;
+				newArmy.UnitRemoved+= UnitRemovedMethod;
+				newArmy.PointsValueChanged+= PointsValueChangedMethod;
+				newArmy.FailedRequirement+=FailedUnitRequirementMethod;
+				//TODO: Clear all buttons
+				EnableCategoryButtons();
+
+				if (newArmy.Race.HasCategoryOverrides())
+				{
+					RemoveCategoryButtons();
+					AddCategoryButtons(newArmy.Race.Categories);
+				}
+			}
+			
+			miCloseArmy.Sensitive = newArmy!=null;
+			miSaveArmyAs.Sensitive = newArmy!=null;
+			//New army has no changes, so we can't save it
+			miSaveArmy.Sensitive = false;
+			saveArmyButton.Sensitive = false;
+
+			CommandStack.Reset();
+			SetPointsPanelText();
+		}
+		
+		private void SetArmyTree(Army army)
+		{
+			logger.Debug("Resetting tree");
+			TreeStore store = (TreeStore)treeUnits.Model;
+			store.Clear();
+			TreeIter iter;
+			
+			if (army!=null)
+			{
+				logger.Debug("Loading in categories to tree");
+								
+				foreach (ArmyCategory cat in army.Categories)
+				{
+					logger.DebugFormat("Append category {0}", cat.Name);
+					iter = store.AppendValues(cat);
+					
+					foreach (IBBoard.WarFoundry.API.Objects.Unit unit in cat.GetUnits())
+					{
+						store.AppendValues(iter, unit);
+					} 
+				}
+				
+				logger.Debug("Finished loading tree categories");
+			}
+		}
+		
+		private void DisableCategoryButtons()
+		{
+			SetCategoryButtonsSensitive(false);
+		}
+		
+		private void EnableCategoryButtons()
+		{
+			SetCategoryButtonsSensitive(true);
+		}
+		
+		private void SetCategoryButtonsSensitive(bool state)
+		{
+			int toolbarButtonCount = toolbar.Children.Length - 1;
+			logger.Debug("Last button index: "+toolbarButtonCount);
+			
+			for (int i = toolbarButtonCount; i > CATEGORY_BUTTON_SEPARATOR_INDEX; i--)
+			{
+				logger.DebugFormat("Setting button {0} state to {1}", i, state);
+				toolbar.Children[i].Sensitive = state;
+			}
+		}
+		
+		private void RemoveCategoryButtons()
+		{
+			int toolbarButtonCount = toolbar.Children.Length - 1;
+			
+			for (int i = toolbarButtonCount; i > CATEGORY_BUTTON_SEPARATOR_INDEX; i--)
+			{
+				toolbar.Remove(toolbar.Children[i]);
+			}
+			
+			categoryMap.Clear();
+		}
+		
+		private void AddCategoryButtons(Category[] cats)
+		{
+			if (cats!=null && cats.Length > 0)
+			{
+				logger.DebugFormat("Toolbar button count: {0}. Adding {1} categories.", toolbar.Children.Length, cats.Length);
+				
+				foreach (Category cat in cats)
+				{
+					ToolButton button = new ToolButton("gtk-add");
+					button.Label = cat.Name;
+					button.SetTooltip(new Tooltips(), "Add unit from "+cat.Name, "");
+					//TODO: See if we can associate data in some way, the same as we can with SWF. For now we just use the map.
+					categoryMap.Add(button, cat);
+					button.Clicked+= new System.EventHandler(OnAddUnitActivated);
+					toolbar.Insert(button, -1);
+				}
+			}
+			
+			toolbar.Children[CATEGORY_BUTTON_SEPARATOR_INDEX].Visible = cats!=null && cats.Length>0;
+			
+			toolbar.ShowAll();
+		}
+		
+		private void SetPointsPanelText()
+		{
+			//TODO: Set the points value in the status bar
+		}
+		
+		private void commandStack_CommandStackUpdated()
+		{
+			undoMenuButton.Sensitive = commandStack.CanUndo();
+			miUndo.Sensitive = undoMenuButton.Sensitive;
+			redoMenuButton.Sensitive = commandStack.CanRedo();
+			miRedo.Sensitive = redoMenuButton.Sensitive;
+			int redoLength = commandStack.RedoLength;
+			//TODO: Build menus for undo/redo and find way of adding tooltips
+			/*int maxRedo = Math.Min(10, redoLength);
+			MenuItem[] menuItems = null;
+		
+			if (redoLength > 0)
+			{
+				menuItems = new MenuItem[maxRedo];
+				Command com;
+				MenuItem mi;
+
+				for (int i = 0; i < maxRedo; i++)
+				{
+					com = commandStack.PeekRedoCommand(i+1);
+
+					if (com == null)
+					{
+						break; 
+					}
+
+					mi = new MenuItem(com.Description);
+					mi.Click+=new EventHandler(redoMenu_Click);
+					menuItems[i] = mi;
+				}
+			}
+
+			redoMenu.MenuItems.Clear();
+
+			if (menuItems!=null && menuItems[0]!=null)
+			{
+				bttnRedo.ToolTipText = menuItems[0].Text;
+				redoMenu.MenuItems.AddRange(menuItems);
+			}*/
+			//TODO: Put above code back when we have a dropdown version of the redo button
+			if (redoLength > 0)
+			{
+				//redoMenuButton.Tooltip = CommandStack.PeekRedoCommand().Description;
+			}
+
+			int undoLength = commandStack.UndoLength;
+			/*int maxUndo = Math.Min(10, undoLength);
+			MenuItem[] menuItemsUndo = null;
+			
+			if (undoLength > 0)
+			{
+				menuItemsUndo = new MenuItem[maxUndo];
+				Command com;
+				MenuItem mi;
+
+				for (int i = 0; i < maxUndo; i++)
+				{
+					com = commandStack.PeekUndoCommand(i+1);
+
+					if (com == null)
+					{
+						break; 
+					}
+
+					mi = new MenuItem(com.UndoDescription);
+					mi.Click+=new EventHandler(undoMenu_Click);
+					menuItemsUndo[i] = mi;
+				}
+			}
+
+			undoMenu.MenuItems.Clear();
+
+			if (menuItemsUndo!=null && menuItemsUndo[0]!=null)
+			{
+				bttnUndo.ToolTipText = menuItemsUndo[0].Text;
+				undoMenu.MenuItems.AddRange(menuItemsUndo);
+			}*/			
+			//TODO: Put above code back when we have a dropdown version of the undo button
+			if (undoLength > 0)
+			{
+				//undoMenuButton.Tooltip = CommandStack.PeekUndoCommand().UndoDescription;
+			}
+			
+			saveArmyButton.Sensitive = commandStack.IsDirty() && WarFoundryCore.CurrentArmy!=null && CanSave();
+			miSaveArmy.Sensitive = commandStack.IsDirty() && WarFoundryCore.CurrentArmy!=null && CanSave();
+		}	
+		
+		private bool CanSave()
+		{
+			return loadedArmyPath!=null && WarFoundryCore.CurrentArmy!=null && WarFoundrySaver.GetSaver()!=null;
+		}
+
+		private bool SaveCurrentArmyOrSaveAs()
+		{
+			if (CanSave())
+			{
+				return SaveCurrentArmy();
+			}
+			else 
+			{
+				return SaveCurrentArmyAs();
+			}
+		}
+		
+		private bool OpenArmy()
+		{
+			//TODO: Open dialog for file selection then open army
+			bool success = false;
+			loadedArmyPath = null;//TODO: Set loaded file path
+			return success;
+		}
+
+		private bool SaveCurrentArmy()
+		{
+			bool success = false;
+			
+			if (CanSave())
+			{
+				try
+				{
+					if (WarFoundrySaver.GetSaver().Save(WarFoundryCore.CurrentArmy, loadedArmyPath))
+					{
+						saveArmyButton.Sensitive = false;
+						miSaveArmy.Sensitive = false;
+						CommandStack.setCleanMark();
+						success = true;
+					}
+				}
+				catch (IOException ex)
+				{
+					logger.Error("Saving army failed", ex);
+					MessageDialog md = new MessageDialog(this, DialogFlags.Modal, MessageType.Error, ButtonsType.Ok, "An error occured while saving the army. Please check the logs for details on what failed");
+					md.Show();
+				}
+			}
+			
+			return success;
+		}
+
+		private bool SaveCurrentArmyAs()
+		{
+			/*if (saveArmyDialog.Filter == "")
+			{
+				string savePath = UserDataPath+Constants.DirectoryString+"armies"+Constants.DirectoryString;
+				
+				if (!Directory.Exists(savePath))
+				{
+					Directory.CreateDirectory(savePath);
+				}
+
+				saveArmyDialog.InitialDirectory = savePath;
+				saveArmyDialog.Filter = Translation.GetTranslation("armyFileFilter")+"|*.army";
+				saveArmyDialog.Title = Translation.GetTranslation("saveArmyDialog");
+			}
+
+			DialogResult dr = saveArmyDialog.ShowDialog(this);
+
+			if (dr == DialogResult.OK)
+			{
+				if (WarFoundrySaver.GetSaver().Save(WarFoundryCore.CurrentArmy, saveArmyDialog.FileName))
+				{
+					miSaveArmy.Enabled = false;
+					bttnSaveArmy.Enabled = false;
+					CommandStack.setCleanMark();
+					loadedArmyPath = saveArmyDialog.FileName;
+					return true;
+				}
+				else
+				{
+					MessageBox.Show(this, Translation.GetTranslation("SaveFailed"), Translation.GetTranslation("SaveFailedTitle"), MessageBoxButtons.OK, MessageBoxIcon.Error);
+					return false;
+				}
+			}
+			else
+			{
+				return false;
+			}*/
+			return false;
+		}
+		
+		private bool CloseCurrentArmy()
+		{
+			if (WarFoundryCore.CurrentArmy!=null)
+			{
+				bool canClose = false;
+
+				if (CommandStack.IsDirty())
+				{
+					MessageDialog dia  = new MessageDialog(this, DialogFlags.DestroyWithParent, MessageType.Question, ButtonsType.YesNo | ButtonsType.Cancel, "The army \""+WarFoundryCore.CurrentArmy.Name+"\" has been modified.\r\nSave changes before closing army?");   
+					ResponseType dr = (ResponseType)dia.Run();
+
+					if (dr == ResponseType.Yes)
+					{
+						//They want to save so try to save it or prompt for save as
+						//If they cancel the save as then assume they don't want to close
+						canClose = SaveCurrentArmyOrSaveAs();
+					}
+					else if (dr == ResponseType.No)
+					{
+						//They don't care about their changes
+						canClose = true;
+					}
+					else
+					{
+						//Assume cancel or close with the X button
+						canClose = false;
+					}
+					
+					dia.Dispose();
+				}
+				else
+				{
+					//Nothing has changed so we can safely close
+					canClose = true;
+				}
+
+				if (canClose)
+				{
+					//do close
+					WarFoundryCore.CurrentArmy = null;
+					return true;
+				}
+				else
+				{
+					return false;
+				}
+			}
+			else
+			{
+				//pretend we succeeded
+				return true;
+			}
+		}
+
+		private void CreateNewArmy()
+		{
+			logger.Debug("Create new army");
+			FrmNewArmy newArmy = new FrmNewArmy(WarFoundryCore.CurrentGameSystem);
+			ResponseType type = (ResponseType)newArmy.Run();
+			newArmy.Hide();
+		
+			if (type == ResponseType.Ok)
+			{
+				if (CloseCurrentArmy())
+				{
+					WarFoundryCore.CurrentArmy = new Army(newArmy.SelectedRace, newArmy.ArmyName, newArmy.ArmySize);
+				}
+			}
+			else
+			{
+				logger.Debug("Create new army cancelled");
+			}
+			
+			newArmy.Destroy();
+		}
+		
+		private void ChangeCurrentGameSystem()
+		{				
+			logger.Debug("Changing game system");
+			FrmChangeGameSystem dialog = new FrmChangeGameSystem(this);
+			ResponseType type = (ResponseType)dialog.Run();
+			dialog.Hide();
+			
+			if (type == ResponseType.Ok)
+			{
+				WarFoundryCore.CurrentGameSystem = dialog.SelectedSystem;
+			}
+			else
+			{
+				logger.Debug("Game system change cancelled");
+			}
+			
+			dialog.Destroy();
+		}
+
+		protected virtual void undoTBButtonActivated (object sender, System.EventArgs e)
+		{
+			CommandStack.Undo();
+		}
+
+		protected virtual void redoTBButtonActivated (object sender, System.EventArgs e)
+		{
+			CommandStack.Redo();
+		}
+
+		protected virtual void saveTBButtonActivated (object sender, System.EventArgs e)
+		{
+			SaveCurrentArmy();
+		}
+
+		protected virtual void openTBButtonActivated (object sender, System.EventArgs e)
+		{
+			OpenArmy();
+		}
+
+		protected virtual void newTBButtonActivated (object sender, System.EventArgs e)
+		{
+			CreateNewArmy();
+		}
+
+		protected virtual void ArmyRowActivated (object o, Gtk.RowActivatedArgs args)
+		{
+			TreeModel model = treeUnits.Model;
+			TreeIter iter;
+			model.GetIter(out iter, args.Path);
+			object obj = model.GetValue(iter, 0);
+			
+			if (obj is IBBoard.WarFoundry.API.Objects.Unit)
+			{
+				IBBoard.WarFoundry.API.Objects.Unit unit = (IBBoard.WarFoundry.API.Objects.Unit)obj;
+				
+				UnitDisplayWidget widget;
+				unitToWidgetMap.TryGetValue(unit, out widget);
+				
+				if (widget!=null)
+				{
+					logger.DebugFormat("Selecting existing page for "+unit.Name);
+					unitsNotebook.Page = unitsNotebook.PageNum(widget);
+				}
+				else
+				{
+					widget = new UnitDisplayWidget(unit, CommandStack);
+					Label label = new Label(unit.Name);
+					logger.Debug("Adding page for "+unit.Name);
+					unitToWidgetMap[unit] = widget;
+					int pageNum = unitsNotebook.AppendPage(widget, label);
+					logger.Debug("Page added at index "+pageNum);
+					unitsNotebook.ShowAll();
+					unitsNotebook.Page = pageNum;
+				}
+			}
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FrmNewArmy.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,129 @@
+// FrmNewArmy.cs
+//
+//  Copyright (C) 2007 IBBoard
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License version 2.1 of the License as published by the Free
+// Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+//
+//
+
+using System;
+using Gtk;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API;
+using IBBoard.WarFoundry.API.Objects;
+using log4net;
+
+namespace IBBoard.WarFoundry
+{	
+	public partial class FrmNewArmy : Dialog, ITranslatable
+	{
+		private ILog logger = LogManager.GetLogger(typeof(FrmNewArmy));
+		private GameSystem system;
+		private Race race;
+		private string armyName;
+		private int pointsValue;
+		
+		public FrmNewArmy(GameSystem gameSystem)
+		{
+			this.Build();
+			
+			system = gameSystem;
+			lstRaces.Selection.Changed+= new EventHandler(OnSelectionChanged);
+			TreeViewColumn raceColumn = new TreeViewColumn ();
+			raceColumn.Title = "Race";
+			CellRendererText raceCell = new CellRendererText ();
+			raceColumn.PackStart (raceCell, true);
+			lstRaces.AppendColumn(raceColumn);
+			raceColumn.SetCellDataFunc(raceCell, new TreeCellDataFunc(RenderRaceName));
+			ListStore store = new ListStore(typeof(Race));
+			
+			foreach (Race r in WarFoundryLoader.GetDefault().GetRaces(system))
+			{
+				store.AppendValues(r);
+			}
+			
+			lstRaces.Model = store;
+		}
+		
+		public string Text
+		{
+			get { return Title; }
+			set { Title = value; }
+		}
+		
+		private void RenderRaceName(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
+		{
+			Race r = (Race)model.GetValue(iter, 0);
+			(cell as CellRendererText).Text = r.Name;
+		}
+
+		protected virtual void OnSelectionChanged(object o, EventArgs e)
+		{
+			logger.Debug("Selection changed");
+			setOkayButtonState();
+		}
+		
+		private void setOkayButtonState()
+		{
+			bttnCreate.Sensitive = (lstRaces.Selection.CountSelectedRows() > 0 && txtArmyName.Text!="" && sbPointsValue.Value > 0);
+		}
+
+		protected virtual void OnCreateClicked (object sender, System.EventArgs e)
+		{
+			TreeModel model;
+			TreeIter iter;
+			lstRaces.Selection.GetSelected (out model, out iter);
+			race = (Race) model.GetValue(iter, 0);
+			armyName = txtArmyName.Text;
+			pointsValue = (int)sbPointsValue.Value;
+			Respond(ResponseType.Ok);
+		}
+
+		protected virtual void OnCancelClicked (object sender, System.EventArgs e)
+		{
+			Respond(ResponseType.Cancel);
+		}
+
+		protected virtual void OnTextChanged (object sender, System.EventArgs e)
+		{
+			setOkayButtonState();
+		}
+
+		protected virtual void OnSpinChangeValue (object o, Gtk.ChangeValueArgs args)
+		{
+			setOkayButtonState();
+		}
+
+		protected virtual void OnSpinValueChanged (object sender, System.EventArgs e)
+		{
+			setOkayButtonState();
+		}
+		
+		public Race SelectedRace
+		{
+			get { return race; }
+		}
+		
+		public string ArmyName
+		{
+			get { return armyName; }
+		}
+		
+		public int ArmySize 
+		{
+			get { return pointsValue; }
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FrmNewUnit.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,133 @@
+// FrmNewUnit.cs
+//
+//  Copyright (C) 2007 IBBoard
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License version 2.1 of the License as published by the Free
+// Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+//
+//
+
+using System;
+using System.Collections.Generic;
+using IBBoard.WarFoundry.API.Objects;
+using IBBoard.WarFoundry.API.Requirements;
+using Gtk;
+using log4net;
+
+namespace IBBoard.WarFoundry
+{
+	public partial class FrmNewUnit : Gtk.Dialog
+	{
+		private ILog logger = LogManager.GetLogger(typeof(FrmNewUnit));
+		
+		private UnitType unitType;
+		private Army unitArmy;
+		
+		public FrmNewUnit(Race race, Category cat, Army army)
+		{
+			this.Build();
+			unitArmy = army;
+			
+			TreeViewColumn unitTypeColumn = new TreeViewColumn ();
+			unitTypeColumn.Title = "Unit Type";
+			CellRendererText unitTypeCell = new CellRendererText ();
+			unitTypeColumn.PackStart(unitTypeCell, true);
+			lstUnitTypes.AppendColumn(unitTypeColumn);
+			unitTypeColumn.SetCellDataFunc (unitTypeCell, new TreeCellDataFunc(RenderUnitTypeName));
+			ListStore store = new ListStore(typeof(UnitType));
+			UnitType[] types = race.GetUnitTypes(cat);
+			logger.DebugFormat("Listing {0} unit types in {1}", types.Length, cat.Name);
+			
+			foreach (UnitType type in types)
+			{
+				logger.DebugFormat("Adding unit type {0}", type.Name);
+				store.AppendValues(type);
+			}
+			
+			lstUnitTypes.Model = store;
+			lstUnitTypes.Selection.Changed+= new EventHandler(OnSelectionChanged);
+		}
+		
+		private void RenderUnitTypeName(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
+		{
+			UnitType type = (UnitType)model.GetValue(iter, 0);
+			(cell as CellRendererText).Text = type.Name;
+		}
+		
+		protected virtual void OnSelectionChanged(object o, EventArgs e)
+		{
+			SetSelectUnitEnabledVal();
+		}
+		
+		public UnitType SelectedUnit
+		{
+			get { return unitType; }
+		}
+		
+		private UnitType GetSelectedUnitType()
+		{		
+			TreeModel model;
+			TreeIter iter;
+			lstUnitTypes.Selection.GetSelected (out model, out iter);
+			UnitType toReturn = null;
+			
+			if (model!=null)
+			{
+				toReturn = (UnitType) model.GetValue(iter, 0);
+			}
+			
+			return toReturn;
+		}
+		
+		private void SetSelectUnitEnabledVal()
+		{
+			UnitType type = GetSelectedUnitType();
+			
+			if (type!=null)
+			{
+				buttonOk.Sensitive = true;
+				List<FailedUnitRequirement> fails = unitArmy.CanAddUnitType(type);
+				lblNewUnitWarning.Visible = (fails != null);
+
+				if (fails.Count > 0)
+				{
+					//FIXME: currently only show the first error
+					lblNewUnitWarning.Text = fails[0].Description;
+				}
+			}
+			else
+			{
+				buttonOk.Sensitive = false;
+				lblNewUnitWarning.Visible = false;
+			}
+		}
+
+		protected virtual void OnButtonCancelActivated (object sender, System.EventArgs e)
+		{
+			Respond(ResponseType.Cancel);
+		}
+
+		protected virtual void OnRowActivated (object o, Gtk.RowActivatedArgs args)
+		{
+			unitType = GetSelectedUnitType();
+			Respond(ResponseType.Ok);
+		}
+
+		protected virtual void OnButtonOkClicked (object sender, System.EventArgs e)
+		{
+			unitType = GetSelectedUnitType();
+			Respond(ResponseType.Ok);
+		}
+	}
+}
Binary file WarFoundry GTK# GUI.pidb has changed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WarFoundryGUI.exe.log4net	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- This section contains the log4net configuration settings -->
+<log4net>
+    <!-- Define some output appenders -->	
+    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
+        <layout type="log4net.Layout.PatternLayout">
+            <param name="ConversionPattern" value="%-5p [%d{HH:MM:ss}]: %C{1}.%M() - Line: %L - %m%n" />
+        </layout>
+    </appender>
+    <!-- Setup the root category, add the appenders and set the default priority -->
+    <root>
+        <level value="DEBUG" />
+        <appender-ref ref="ConsoleAppender" />
+    </root>
+</log4net>
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WarFoundryGUI.mdp	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,55 @@
+<Project name="WarFoundry GTK# GUI" fileversion="2.0" language="C#" DefaultNamespace="IBBoard.WarFoundry" clr-version="Net_2_0" Description="A GTK# GUI for the WarFoundry army builder application." ctype="DotNetProject">
+  <Configurations active="Debug">
+    <Configuration name="Debug" ctype="DotNetProjectConfiguration">
+      <Output directory="bin/Debug" assemblyKeyFile="." assembly="WarFoundryGTK" />
+      <Build debugmode="True" target="Exe" />
+      <Execution runwithwarnings="True" consolepause="True" runtime="MsNet" clr-version="Net_2_0" />
+      <CodeGeneration compiler="Mcs" warninglevel="4" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="IBBoard.WarFoundry.FrmMainWindow" generatexmldocumentation="False" win32Icon="App.ico" ctype="CSharpCompilerParameters" />
+    </Configuration>
+    <Configuration name="Release" ctype="DotNetProjectConfiguration">
+      <Output directory="bin/Release" assembly="WarFoundryGTK" />
+      <Build debugmode="False" target="Exe" />
+      <Execution runwithwarnings="True" consolepause="True" runtime="MsNet" clr-version="Net_2_0" />
+      <CodeGeneration compiler="Mcs" warninglevel="4" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" generatexmldocumentation="False" ctype="CSharpCompilerParameters" />
+    </Configuration>
+  </Configurations>
+  <Contents>
+    <File name="gtk-gui/gui.stetic" subtype="Code" buildaction="EmbedAsResource" />
+    <File name="gtk-gui/generated.cs" subtype="Code" buildaction="Compile" />
+    <File name="FrmMainWindow.cs" subtype="Code" buildaction="Compile" />
+    <File name="AssemblyInfo.cs" subtype="Code" buildaction="Compile" />
+    <File name="FrmNewArmy.cs" subtype="Code" buildaction="Compile" />
+    <File name="gtk-gui/IBBoard.WarFoundry.FrmNewArmy.cs" subtype="Code" buildaction="Compile" />
+    <File name="App.png" subtype="Code" buildaction="Nothing" />
+    <File name="App.ico" subtype="Code" buildaction="EmbedAsResource" />
+    <File name="gtk-gui/IBBoard.WarFoundry.FrmMainWindow.cs" subtype="Code" buildaction="Compile" />
+    <File name="libs/log4net.dll" subtype="Code" buildaction="Nothing" />
+    <File name="libs/log4net.xml" subtype="Code" buildaction="Nothing" />
+    <File name="WarFoundryGUI.exe.log4net" subtype="Code" buildaction="Nothing" />
+    <File name="FrmChangeGameSystem.cs" subtype="Code" buildaction="Compile" />
+    <File name="gtk-gui/IBBoard.WarFoundry.FrmChangeGameSystem.cs" subtype="Code" buildaction="Compile" />
+    <File name="FrmNewUnit.cs" subtype="Code" buildaction="Compile" />
+    <File name="gtk-gui/IBBoard.WarFoundry.FrmNewUnit.cs" subtype="Code" buildaction="Compile" />
+    <File name="Widgets" subtype="Directory" buildaction="Compile" />
+    <File name="Widgets/UnitDisplayWidget.cs" subtype="Code" buildaction="Compile" />
+    <File name="gtk-gui/objects.xml" subtype="Code" buildaction="EmbedAsResource" />
+    <File name="gtk-gui/IBBoard.WarFoundry.Widgets.UnitDisplayWidget.cs" subtype="Code" buildaction="Compile" />
+  </Contents>
+  <References>
+    <ProjectReference type="Gac" localcopy="True" refto="System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+    <ProjectReference type="Gac" localcopy="True" refto="Mono.Posix, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756" />
+    <ProjectReference type="Project" localcopy="True" refto="IBBoard" />
+    <ProjectReference type="Project" localcopy="True" refto="IBBoard.WarFoundry.API" />
+    <ProjectReference type="Gac" localcopy="True" refto="gtk-sharp, Version=2.10.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
+    <ProjectReference type="Gac" localcopy="True" refto="gdk-sharp, Version=2.10.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
+    <ProjectReference type="Assembly" localcopy="True" refto="libs/log4net.dll" />
+    <ProjectReference type="Project" localcopy="True" refto="IBBoard.WarFoundry.Plugin.Rollcall" />
+    <ProjectReference type="Project" localcopy="True" refto="IBBoard.Log4Net" />
+  </References>
+  <Deployment.LinuxDeployData scriptName="warfoundry_gui" />
+  <GtkDesignInfo isWidgetLibrary="True" gtkVersion="2.12.1">
+    <ExportedWidgets>
+      <Widget>IBBoard.WarFoundry.Widgets.UnitDisplayWidget</Widget>
+    </ExportedWidgets>
+  </GtkDesignInfo>
+</Project>
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Widgets/UnitDisplayWidget.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,157 @@
+// UnitDisplayWidget.cs
+//
+//  Copyright (C) 2008 IBBoard
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License version 2.1 of the License as published by the Free
+// Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
+//
+//
+
+using System;
+using Gtk;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API;
+using IBBoard.WarFoundry.API.Objects;
+using IBBoard.WarFoundry.API.Commands;
+
+namespace IBBoard.WarFoundry.Widgets
+{
+	public partial class UnitDisplayWidget : Gtk.Bin
+	{		
+		private IBBoard.WarFoundry.API.Objects.Unit unit;
+		private CommandStack stack;
+		
+		public UnitDisplayWidget(IBBoard.WarFoundry.API.Objects.Unit sourceUnit, CommandStack commandStack)
+		{
+			this.Build();
+			stack = commandStack;
+			unit = sourceUnit;
+			unitName.Text = unit.Name;
+			unitSize.Value = unit.Size;
+			double max = unit.UnitType.MaxSize;
+			
+			if (max == -1)
+			{
+				max = double.MaxValue;
+			}
+			
+			unitSize.SetRange(unit.UnitType.MinSize, max);
+			unit.NameChanged+= new StringValChangedDelegate(UnitNameChanged);
+			unit.UnitSizeChanged+= new IntValChangedDelegate(UnitSizeChanged);
+			SetStats();
+		}
+
+		private void SetStats()
+		{
+            //GameSystem system = unit.Army.GameSystem;
+            //SystemStats stats = system.StandardSystemStats;
+            Stats stats = unit.UnitType.UnitStats;
+            CellRendererText renderer = new CellRendererText();
+            unitStats.AppendColumn(Translation.GetTranslation("UnitNameColumn", "Unit Type", null), renderer, new TreeCellDataFunc(RenderUnitName));
+            
+            TreeCellDataFunc statFunc = new TreeCellDataFunc(RenderUnitStat);
+			
+			int length = stats.StatCount;
+
+			for (int i = 0; i < length; i++)
+			{
+	            unitStats.AppendColumn(stats[i].ParentSlot.Name, renderer, statFunc);
+			}
+
+			TreeStore model = new TreeStore(typeof(IBBoard.WarFoundry.API.Objects.Unit));
+			model.AppendValues(unit);
+			unitStats.Model = model;
+		}
+		
+		private void RenderUnitName(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
+		{
+			object o = model.GetValue(iter, 0);
+			
+			if (o is IBBoard.WarFoundry.API.Objects.Unit)
+			{
+				IBBoard.WarFoundry.API.Objects.Unit u = (IBBoard.WarFoundry.API.Objects.Unit)o;				
+				(cell as CellRendererText).Text = u.UnitType.Name;
+			}
+		}
+		
+		private void RenderUnitStat(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
+		{
+			object o = model.GetValue(iter, 0);
+			
+			if (o is IBBoard.WarFoundry.API.Objects.Unit)
+			{
+				IBBoard.WarFoundry.API.Objects.Unit u = (IBBoard.WarFoundry.API.Objects.Unit)o;
+				//TODO Check for correct value based on the column
+				(cell as CellRendererText).Text = u.UnitStats[column.Title].SlotValueString;
+			}
+		}
+		
+		private void UnitNameChanged(WarFoundryObject obj, string oldValue, string newValue)
+		{
+			unitName.Text = newValue;
+		}
+		
+		private void UnitSizeChanged(WarFoundryObject obj, int oldValue, int newValue)
+		{
+			unitSize.Value = newValue;
+		}
+
+		protected virtual void OnUnitSizeFocusOut (object o, Gtk.FocusOutEventArgs args)
+		{
+			SetNewUnitSize();
+		}
+
+		[GLib.ConnectBefore ()]
+		protected virtual void OnUnitSizeKeyPress (object o, Gtk.KeyPressEventArgs args)
+		{
+			if (args.Event.Key == Gdk.Key.Return)
+			{
+				SetNewUnitSize();
+			}
+		}
+		
+		private void SetNewUnitSize()
+		{
+			if (unitSize.Value!=unit.Size)
+			{
+				SetUnitSizeCommand cmd = new SetUnitSizeCommand(unit, (int)Math.Round(unitSize.Value));
+				stack.Execute(cmd);
+			}
+		}
+
+		protected virtual void OnUnitNameFocusOut (object o, Gtk.FocusOutEventArgs args)
+		{
+			SetNewUnitName();
+		}
+
+		[GLib.ConnectBefore ()]
+		protected virtual void OnUnitNameKeyPress (object o, Gtk.KeyPressEventArgs args)
+		{
+			if (args.Event.Key == Gdk.Key.Return)
+			{
+				SetNewUnitName();
+			}
+		}
+		
+		private void SetNewUnitName()
+		{
+			if (unitName.Text!=unit.Name)
+			{
+				SetNameCommand cmd = new SetNameCommand(unit, unitName.Text);
+				stack.Execute(cmd);
+			}
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/IBBoard.WarFoundry.FrmChangeGameSystem.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,122 @@
+// ------------------------------------------------------------------------------
+//  <autogenerated>
+//      This code was generated by a tool.
+//      Mono Runtime Version: 2.0.50727.42
+// 
+//      Changes to this file may cause incorrect behavior and will be lost if 
+//      the code is regenerated.
+//  </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace IBBoard.WarFoundry {
+    
+    
+    public partial class FrmChangeGameSystem {
+        
+        private Gtk.HBox hbox1;
+        
+        private Gtk.Label lblGameSystem;
+        
+        private Gtk.ScrolledWindow GtkScrolledWindow;
+        
+        private Gtk.TreeView lstGameSystems;
+        
+        private Gtk.Button buttonCancel;
+        
+        private Gtk.Button buttonOk;
+        
+        protected virtual void Build() {
+            Stetic.Gui.Initialize(this);
+            // Widget IBBoard.WarFoundry.FrmChangeGameSystem
+            this.Name = "IBBoard.WarFoundry.FrmChangeGameSystem";
+            this.Title = Mono.Unix.Catalog.GetString("Change Game System");
+            this.Icon = Gdk.Pixbuf.LoadFromResource("App.ico");
+            this.TypeHint = ((Gdk.WindowTypeHint)(1));
+            this.WindowPosition = ((Gtk.WindowPosition)(4));
+            this.Modal = true;
+            this.Resizable = false;
+            this.AllowGrow = false;
+            this.DefaultWidth = 400;
+            this.DefaultHeight = 300;
+            this.SkipPagerHint = true;
+            this.SkipTaskbarHint = true;
+            this.HasSeparator = false;
+            // Internal child IBBoard.WarFoundry.FrmChangeGameSystem.VBox
+            Gtk.VBox w1 = this.VBox;
+            w1.Name = "dialog1_VBox";
+            w1.Spacing = 6;
+            w1.BorderWidth = ((uint)(2));
+            // Container child dialog1_VBox.Gtk.Box+BoxChild
+            this.hbox1 = new Gtk.HBox();
+            this.hbox1.Name = "hbox1";
+            this.hbox1.Spacing = 6;
+            // Container child hbox1.Gtk.Box+BoxChild
+            this.lblGameSystem = new Gtk.Label();
+            this.lblGameSystem.Name = "lblGameSystem";
+            this.lblGameSystem.LabelProp = Mono.Unix.Catalog.GetString("Game System");
+            this.hbox1.Add(this.lblGameSystem);
+            Gtk.Box.BoxChild w2 = ((Gtk.Box.BoxChild)(this.hbox1[this.lblGameSystem]));
+            w2.Position = 0;
+            w2.Expand = false;
+            w2.Fill = false;
+            // Container child hbox1.Gtk.Box+BoxChild
+            this.GtkScrolledWindow = new Gtk.ScrolledWindow();
+            this.GtkScrolledWindow.Name = "GtkScrolledWindow";
+            this.GtkScrolledWindow.ShadowType = ((Gtk.ShadowType)(1));
+            // Container child GtkScrolledWindow.Gtk.Container+ContainerChild
+            this.lstGameSystems = new Gtk.TreeView();
+            this.lstGameSystems.WidthRequest = 250;
+            this.lstGameSystems.HeightRequest = 125;
+            this.lstGameSystems.CanFocus = true;
+            this.lstGameSystems.Name = "lstGameSystems";
+            this.lstGameSystems.HeadersVisible = false;
+            this.lstGameSystems.HeadersClickable = true;
+            this.GtkScrolledWindow.Add(this.lstGameSystems);
+            this.hbox1.Add(this.GtkScrolledWindow);
+            Gtk.Box.BoxChild w4 = ((Gtk.Box.BoxChild)(this.hbox1[this.GtkScrolledWindow]));
+            w4.Position = 1;
+            w1.Add(this.hbox1);
+            Gtk.Box.BoxChild w5 = ((Gtk.Box.BoxChild)(w1[this.hbox1]));
+            w5.Position = 0;
+            // Internal child IBBoard.WarFoundry.FrmChangeGameSystem.ActionArea
+            Gtk.HButtonBox w6 = this.ActionArea;
+            w6.Name = "dialog1_ActionArea";
+            w6.Spacing = 6;
+            w6.BorderWidth = ((uint)(5));
+            w6.LayoutStyle = ((Gtk.ButtonBoxStyle)(4));
+            // Container child dialog1_ActionArea.Gtk.ButtonBox+ButtonBoxChild
+            this.buttonCancel = new Gtk.Button();
+            this.buttonCancel.CanDefault = true;
+            this.buttonCancel.CanFocus = true;
+            this.buttonCancel.Name = "buttonCancel";
+            this.buttonCancel.UseStock = true;
+            this.buttonCancel.UseUnderline = true;
+            this.buttonCancel.Label = "gtk-cancel";
+            this.AddActionWidget(this.buttonCancel, -6);
+            Gtk.ButtonBox.ButtonBoxChild w7 = ((Gtk.ButtonBox.ButtonBoxChild)(w6[this.buttonCancel]));
+            w7.Expand = false;
+            w7.Fill = false;
+            // Container child dialog1_ActionArea.Gtk.ButtonBox+ButtonBoxChild
+            this.buttonOk = new Gtk.Button();
+            this.buttonOk.Sensitive = false;
+            this.buttonOk.CanDefault = true;
+            this.buttonOk.CanFocus = true;
+            this.buttonOk.Name = "buttonOk";
+            this.buttonOk.UseStock = true;
+            this.buttonOk.UseUnderline = true;
+            this.buttonOk.Label = "gtk-ok";
+            this.AddActionWidget(this.buttonOk, -5);
+            Gtk.ButtonBox.ButtonBoxChild w8 = ((Gtk.ButtonBox.ButtonBoxChild)(w6[this.buttonOk]));
+            w8.Position = 1;
+            w8.Expand = false;
+            w8.Fill = false;
+            if ((this.Child != null)) {
+                this.Child.ShowAll();
+            }
+            this.Show();
+            this.lstGameSystems.RowActivated += new Gtk.RowActivatedHandler(this.lstGameSystemsRowActivated);
+            this.buttonCancel.Clicked += new System.EventHandler(this.OnCancel);
+            this.buttonOk.Clicked += new System.EventHandler(this.OnGameSystemOkayClicked);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/IBBoard.WarFoundry.FrmMainWindow.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,234 @@
+// ------------------------------------------------------------------------------
+//  <autogenerated>
+//      This code was generated by a tool.
+//      Mono Runtime Version: 2.0.50727.42
+// 
+//      Changes to this file may cause incorrect behavior and will be lost if 
+//      the code is regenerated.
+//  </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace IBBoard.WarFoundry {
+    
+    
+    public partial class FrmMainWindow {
+        
+        private Gtk.Action menuFile;
+        
+        private Gtk.Action miCreateArmy;
+        
+        private Gtk.Action miOpenArmy;
+        
+        private Gtk.Action miSaveArmy;
+        
+        private Gtk.Action miSaveArmyAs;
+        
+        private Gtk.Action miCloseArmy;
+        
+        private Gtk.Action miChangeGameSystem;
+        
+        private Gtk.Action miReloadFiles;
+        
+        private Gtk.Action miExit;
+        
+        private Gtk.Action menuEdit;
+        
+        private Gtk.Action miUndo;
+        
+        private Gtk.Action miRedo;
+        
+        private Gtk.Action menuHelp;
+        
+        private Gtk.Action miAbout;
+        
+        private Gtk.Action miDebugInformation;
+        
+        private Gtk.Action newArmyButton;
+        
+        private Gtk.Action openArmyButton;
+        
+        private Gtk.Action saveArmyButton;
+        
+        private Gtk.Action undoActionButton;
+        
+        private Gtk.Action redoActionButton;
+        
+        private Gtk.Action goDown;
+        
+        private Gtk.Action add;
+        
+        private Gtk.VBox vbox1;
+        
+        private Gtk.MenuBar menubar1;
+        
+        private Gtk.Toolbar toolbar;
+        
+        private Gtk.HPaned hpaned2;
+        
+        private Gtk.TreeView treeUnits;
+        
+        private Gtk.Notebook unitsNotebook;
+        
+        private Gtk.Statusbar statusbar1;
+        
+        protected virtual void Build() {
+            Stetic.Gui.Initialize(this);
+            // Widget IBBoard.WarFoundry.FrmMainWindow
+            Gtk.UIManager w1 = new Gtk.UIManager();
+            Gtk.ActionGroup w2 = new Gtk.ActionGroup("Default");
+            this.menuFile = new Gtk.Action("menuFile", Mono.Unix.Catalog.GetString("File"), null, null);
+            this.menuFile.ShortLabel = Mono.Unix.Catalog.GetString("File");
+            w2.Add(this.menuFile, null);
+            this.miCreateArmy = new Gtk.Action("miCreateArmy", Mono.Unix.Catalog.GetString("Create army"), null, null);
+            this.miCreateArmy.Sensitive = false;
+            this.miCreateArmy.ShortLabel = Mono.Unix.Catalog.GetString("Create army");
+            w2.Add(this.miCreateArmy, null);
+            this.miOpenArmy = new Gtk.Action("miOpenArmy", Mono.Unix.Catalog.GetString("Open army"), null, null);
+            this.miOpenArmy.Sensitive = false;
+            this.miOpenArmy.ShortLabel = Mono.Unix.Catalog.GetString("Open army");
+            w2.Add(this.miOpenArmy, null);
+            this.miSaveArmy = new Gtk.Action("miSaveArmy", Mono.Unix.Catalog.GetString("Save army"), null, null);
+            this.miSaveArmy.Sensitive = false;
+            this.miSaveArmy.ShortLabel = Mono.Unix.Catalog.GetString("Save army");
+            w2.Add(this.miSaveArmy, null);
+            this.miSaveArmyAs = new Gtk.Action("miSaveArmyAs", Mono.Unix.Catalog.GetString("Save army as"), null, null);
+            this.miSaveArmyAs.Sensitive = false;
+            this.miSaveArmyAs.ShortLabel = Mono.Unix.Catalog.GetString("Save army as");
+            w2.Add(this.miSaveArmyAs, null);
+            this.miCloseArmy = new Gtk.Action("miCloseArmy", Mono.Unix.Catalog.GetString("Close army"), null, null);
+            this.miCloseArmy.Sensitive = false;
+            this.miCloseArmy.ShortLabel = Mono.Unix.Catalog.GetString("Close army");
+            w2.Add(this.miCloseArmy, null);
+            this.miChangeGameSystem = new Gtk.Action("miChangeGameSystem", Mono.Unix.Catalog.GetString("Change game system"), null, null);
+            this.miChangeGameSystem.ShortLabel = Mono.Unix.Catalog.GetString("Change game system");
+            w2.Add(this.miChangeGameSystem, null);
+            this.miReloadFiles = new Gtk.Action("miReloadFiles", Mono.Unix.Catalog.GetString("Reload files"), null, null);
+            this.miReloadFiles.Sensitive = false;
+            this.miReloadFiles.ShortLabel = Mono.Unix.Catalog.GetString("Reload files");
+            w2.Add(this.miReloadFiles, null);
+            this.miExit = new Gtk.Action("miExit", Mono.Unix.Catalog.GetString("Exit"), null, null);
+            this.miExit.ShortLabel = Mono.Unix.Catalog.GetString("Exit");
+            w2.Add(this.miExit, null);
+            this.menuEdit = new Gtk.Action("menuEdit", Mono.Unix.Catalog.GetString("Edit"), null, null);
+            this.menuEdit.ShortLabel = Mono.Unix.Catalog.GetString("Edit");
+            w2.Add(this.menuEdit, null);
+            this.miUndo = new Gtk.Action("miUndo", Mono.Unix.Catalog.GetString("Undo"), null, null);
+            this.miUndo.Sensitive = false;
+            this.miUndo.ShortLabel = Mono.Unix.Catalog.GetString("Undo");
+            w2.Add(this.miUndo, null);
+            this.miRedo = new Gtk.Action("miRedo", Mono.Unix.Catalog.GetString("Redo"), null, null);
+            this.miRedo.Sensitive = false;
+            this.miRedo.ShortLabel = Mono.Unix.Catalog.GetString("Redo");
+            w2.Add(this.miRedo, null);
+            this.menuHelp = new Gtk.Action("menuHelp", Mono.Unix.Catalog.GetString("Help"), null, null);
+            this.menuHelp.ShortLabel = Mono.Unix.Catalog.GetString("Help");
+            w2.Add(this.menuHelp, null);
+            this.miAbout = new Gtk.Action("miAbout", Mono.Unix.Catalog.GetString("About"), null, null);
+            this.miAbout.ShortLabel = Mono.Unix.Catalog.GetString("About");
+            w2.Add(this.miAbout, null);
+            this.miDebugInformation = new Gtk.Action("miDebugInformation", Mono.Unix.Catalog.GetString("Debug Information"), null, null);
+            this.miDebugInformation.ShortLabel = Mono.Unix.Catalog.GetString("Debug Information");
+            w2.Add(this.miDebugInformation, null);
+            this.newArmyButton = new Gtk.Action("newArmyButton", null, null, "gtk-new");
+            this.newArmyButton.Sensitive = false;
+            w2.Add(this.newArmyButton, null);
+            this.openArmyButton = new Gtk.Action("openArmyButton", null, null, "gtk-open");
+            this.openArmyButton.Sensitive = false;
+            w2.Add(this.openArmyButton, null);
+            this.saveArmyButton = new Gtk.Action("saveArmyButton", null, null, "gtk-save");
+            this.saveArmyButton.Sensitive = false;
+            w2.Add(this.saveArmyButton, null);
+            this.undoActionButton = new Gtk.Action("undoActionButton", null, null, "gtk-undo");
+            this.undoActionButton.Sensitive = false;
+            w2.Add(this.undoActionButton, null);
+            this.redoActionButton = new Gtk.Action("redoActionButton", null, null, "gtk-redo");
+            this.redoActionButton.Sensitive = false;
+            w2.Add(this.redoActionButton, null);
+            this.goDown = new Gtk.Action("goDown", null, null, null);
+            w2.Add(this.goDown, null);
+            this.add = new Gtk.Action("add", null, null, "gtk-add");
+            w2.Add(this.add, null);
+            w1.InsertActionGroup(w2, 0);
+            this.AddAccelGroup(w1.AccelGroup);
+            this.Name = "IBBoard.WarFoundry.FrmMainWindow";
+            this.Title = Mono.Unix.Catalog.GetString("MainWindow");
+            this.Icon = Gdk.Pixbuf.LoadFromResource("App.ico");
+            // Container child IBBoard.WarFoundry.FrmMainWindow.Gtk.Container+ContainerChild
+            this.vbox1 = new Gtk.VBox();
+            this.vbox1.Name = "vbox1";
+            // Container child vbox1.Gtk.Box+BoxChild
+            w1.AddUiFromString("<ui><menubar name='menubar1'><menu action='menuFile'><menuitem action='miCreateArmy'/><menuitem action='miOpenArmy'/><menuitem action='miSaveArmy'/><menuitem action='miSaveArmyAs'/><menuitem action='miCloseArmy'/><separator/><menuitem action='miChangeGameSystem'/><separator/><menuitem action='miReloadFiles'/><separator/><menuitem action='miExit'/></menu><menu action='menuEdit'><menuitem action='miUndo'/><menuitem action='miRedo'/></menu><menu action='menuHelp'><menuitem action='miAbout'/><menuitem action='miDebugInformation'/></menu></menubar></ui>");
+            this.menubar1 = ((Gtk.MenuBar)(w1.GetWidget("/menubar1")));
+            this.menubar1.Name = "menubar1";
+            this.vbox1.Add(this.menubar1);
+            Gtk.Box.BoxChild w3 = ((Gtk.Box.BoxChild)(this.vbox1[this.menubar1]));
+            w3.Position = 0;
+            w3.Expand = false;
+            w3.Fill = false;
+            // Container child vbox1.Gtk.Box+BoxChild
+            w1.AddUiFromString("<ui><toolbar name='toolbar'><toolitem action='newArmyButton'/><toolitem action='openArmyButton'/><toolitem action='saveArmyButton'/><separator/><toolitem action='undoActionButton'/><toolitem action='redoActionButton'/><separator/></toolbar></ui>");
+            this.toolbar = ((Gtk.Toolbar)(w1.GetWidget("/toolbar")));
+            this.toolbar.HeightRequest = 36;
+            this.toolbar.Name = "toolbar";
+            this.toolbar.ShowArrow = false;
+            this.toolbar.ToolbarStyle = ((Gtk.ToolbarStyle)(0));
+            this.vbox1.Add(this.toolbar);
+            Gtk.Box.BoxChild w4 = ((Gtk.Box.BoxChild)(this.vbox1[this.toolbar]));
+            w4.Position = 1;
+            w4.Expand = false;
+            w4.Fill = false;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.hpaned2 = new Gtk.HPaned();
+            this.hpaned2.CanFocus = true;
+            this.hpaned2.Name = "hpaned2";
+            this.hpaned2.Position = 178;
+            // Container child hpaned2.Gtk.Paned+PanedChild
+            this.treeUnits = new Gtk.TreeView();
+            this.treeUnits.CanFocus = true;
+            this.treeUnits.Name = "treeUnits";
+            this.treeUnits.HeadersClickable = true;
+            this.hpaned2.Add(this.treeUnits);
+            Gtk.Paned.PanedChild w5 = ((Gtk.Paned.PanedChild)(this.hpaned2[this.treeUnits]));
+            w5.Resize = false;
+            // Container child hpaned2.Gtk.Paned+PanedChild
+            this.unitsNotebook = new Gtk.Notebook();
+            this.unitsNotebook.CanFocus = true;
+            this.unitsNotebook.Name = "unitsNotebook";
+            this.unitsNotebook.CurrentPage = -1;
+            this.hpaned2.Add(this.unitsNotebook);
+            this.vbox1.Add(this.hpaned2);
+            Gtk.Box.BoxChild w7 = ((Gtk.Box.BoxChild)(this.vbox1[this.hpaned2]));
+            w7.Position = 2;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.statusbar1 = new Gtk.Statusbar();
+            this.statusbar1.Name = "statusbar1";
+            this.statusbar1.Spacing = 2;
+            this.vbox1.Add(this.statusbar1);
+            Gtk.Box.BoxChild w8 = ((Gtk.Box.BoxChild)(this.vbox1[this.statusbar1]));
+            w8.Position = 3;
+            w8.Expand = false;
+            w8.Fill = false;
+            this.Add(this.vbox1);
+            if ((this.Child != null)) {
+                this.Child.ShowAll();
+            }
+            this.DefaultWidth = 832;
+            this.DefaultHeight = 659;
+            this.Show();
+            this.miCreateArmy.Activated += new System.EventHandler(this.OnCreateArmyActivated);
+            this.miOpenArmy.Activated += new System.EventHandler(this.OnOpenArmyActivated);
+            this.miSaveArmy.Activated += new System.EventHandler(this.OnSaveArmyActivated);
+            this.miSaveArmyAs.Activated += new System.EventHandler(this.OnSaveArmyAsActivated);
+            this.miCloseArmy.Activated += new System.EventHandler(this.OnCloseArmyActivated);
+            this.miChangeGameSystem.Activated += new System.EventHandler(this.OnChangeGameSystemActivated);
+            this.miReloadFiles.Activated += new System.EventHandler(this.OnReloadFilesActivated);
+            this.miExit.Activated += new System.EventHandler(this.OnExitActivated);
+            this.newArmyButton.Activated += new System.EventHandler(this.newTBButtonActivated);
+            this.openArmyButton.Activated += new System.EventHandler(this.openTBButtonActivated);
+            this.saveArmyButton.Activated += new System.EventHandler(this.saveTBButtonActivated);
+            this.undoActionButton.Activated += new System.EventHandler(this.undoTBButtonActivated);
+            this.redoActionButton.Activated += new System.EventHandler(this.redoTBButtonActivated);
+            this.treeUnits.RowActivated += new Gtk.RowActivatedHandler(this.ArmyRowActivated);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/IBBoard.WarFoundry.FrmNewArmy.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,210 @@
+// ------------------------------------------------------------------------------
+//  <autogenerated>
+//      This code was generated by a tool.
+//      Mono Runtime Version: 2.0.50727.42
+// 
+//      Changes to this file may cause incorrect behavior and will be lost if 
+//      the code is regenerated.
+//  </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace IBBoard.WarFoundry {
+    
+    
+    public partial class FrmNewArmy {
+        
+        private Gtk.Table table1;
+        
+        private Gtk.ScrolledWindow GtkScrolledWindow;
+        
+        private Gtk.TreeView lstRaces;
+        
+        private Gtk.HBox hbox2;
+        
+        private Gtk.SpinButton sbPointsValue;
+        
+        private Gtk.Label label1;
+        
+        private Gtk.Label label2;
+        
+        private Gtk.Label label3;
+        
+        private Gtk.Entry txtArmyName;
+        
+        private Gtk.Button bttnCancel;
+        
+        private Gtk.Button bttnCreate;
+        
+        protected virtual void Build() {
+            Stetic.Gui.Initialize(this);
+            // Widget IBBoard.WarFoundry.FrmNewArmy
+            this.Events = ((Gdk.EventMask)(256));
+            this.Name = "IBBoard.WarFoundry.FrmNewArmy";
+            this.Title = Mono.Unix.Catalog.GetString("Create new army");
+            this.Icon = Stetic.IconLoader.LoadIcon(this, "gtk-new", Gtk.IconSize.Menu, 16);
+            this.WindowPosition = ((Gtk.WindowPosition)(4));
+            this.SkipPagerHint = true;
+            this.SkipTaskbarHint = true;
+            this.HasSeparator = false;
+            // Internal child IBBoard.WarFoundry.FrmNewArmy.VBox
+            Gtk.VBox w1 = this.VBox;
+            w1.CanFocus = true;
+            w1.Events = ((Gdk.EventMask)(256));
+            w1.Name = "dialog_VBox";
+            w1.BorderWidth = ((uint)(2));
+            // Container child dialog_VBox.Gtk.Box+BoxChild
+            this.table1 = new Gtk.Table(((uint)(3)), ((uint)(2)), false);
+            this.table1.Name = "table1";
+            this.table1.RowSpacing = ((uint)(6));
+            this.table1.ColumnSpacing = ((uint)(6));
+            // Container child table1.Gtk.Table+TableChild
+            this.GtkScrolledWindow = new Gtk.ScrolledWindow();
+            this.GtkScrolledWindow.Name = "GtkScrolledWindow";
+            this.GtkScrolledWindow.ShadowType = ((Gtk.ShadowType)(1));
+            // Container child GtkScrolledWindow.Gtk.Container+ContainerChild
+            this.lstRaces = new Gtk.TreeView();
+            this.lstRaces.HeightRequest = 150;
+            this.lstRaces.CanFocus = true;
+            this.lstRaces.Name = "lstRaces";
+            this.lstRaces.HeadersVisible = false;
+            this.lstRaces.RulesHint = true;
+            this.lstRaces.HeadersClickable = true;
+            this.GtkScrolledWindow.Add(this.lstRaces);
+            this.table1.Add(this.GtkScrolledWindow);
+            Gtk.Table.TableChild w3 = ((Gtk.Table.TableChild)(this.table1[this.GtkScrolledWindow]));
+            w3.LeftAttach = ((uint)(1));
+            w3.RightAttach = ((uint)(2));
+            w3.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.hbox2 = new Gtk.HBox();
+            this.hbox2.Name = "hbox2";
+            // Container child hbox2.Gtk.Box+BoxChild
+            this.sbPointsValue = new Gtk.SpinButton(0, 2000000000, 100);
+            this.sbPointsValue.WidthRequest = 150;
+            this.sbPointsValue.CanFocus = true;
+            this.sbPointsValue.Name = "sbPointsValue";
+            this.sbPointsValue.Adjustment.PageIncrement = 1000;
+            this.sbPointsValue.ClimbRate = 100;
+            this.sbPointsValue.Numeric = true;
+            this.sbPointsValue.Value = 1000;
+            this.hbox2.Add(this.sbPointsValue);
+            Gtk.Box.BoxChild w4 = ((Gtk.Box.BoxChild)(this.hbox2[this.sbPointsValue]));
+            w4.Position = 0;
+            w4.Expand = false;
+            w4.Fill = false;
+            this.table1.Add(this.hbox2);
+            Gtk.Table.TableChild w5 = ((Gtk.Table.TableChild)(this.table1[this.hbox2]));
+            w5.TopAttach = ((uint)(2));
+            w5.BottomAttach = ((uint)(3));
+            w5.LeftAttach = ((uint)(1));
+            w5.RightAttach = ((uint)(2));
+            w5.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.label1 = new Gtk.Label();
+            this.label1.Name = "label1";
+            this.label1.LabelProp = Mono.Unix.Catalog.GetString("Race");
+            this.table1.Add(this.label1);
+            Gtk.Table.TableChild w6 = ((Gtk.Table.TableChild)(this.table1[this.label1]));
+            w6.XOptions = ((Gtk.AttachOptions)(4));
+            w6.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.label2 = new Gtk.Label();
+            this.label2.Name = "label2";
+            this.label2.LabelProp = Mono.Unix.Catalog.GetString("Army name");
+            this.table1.Add(this.label2);
+            Gtk.Table.TableChild w7 = ((Gtk.Table.TableChild)(this.table1[this.label2]));
+            w7.TopAttach = ((uint)(1));
+            w7.BottomAttach = ((uint)(2));
+            w7.XOptions = ((Gtk.AttachOptions)(4));
+            w7.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.label3 = new Gtk.Label();
+            this.label3.Name = "label3";
+            this.label3.LabelProp = Mono.Unix.Catalog.GetString("Points value");
+            this.table1.Add(this.label3);
+            Gtk.Table.TableChild w8 = ((Gtk.Table.TableChild)(this.table1[this.label3]));
+            w8.TopAttach = ((uint)(2));
+            w8.BottomAttach = ((uint)(3));
+            w8.XOptions = ((Gtk.AttachOptions)(4));
+            w8.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.txtArmyName = new Gtk.Entry();
+            this.txtArmyName.CanFocus = true;
+            this.txtArmyName.Name = "txtArmyName";
+            this.txtArmyName.IsEditable = true;
+            this.txtArmyName.InvisibleChar = '•';
+            this.table1.Add(this.txtArmyName);
+            Gtk.Table.TableChild w9 = ((Gtk.Table.TableChild)(this.table1[this.txtArmyName]));
+            w9.TopAttach = ((uint)(1));
+            w9.BottomAttach = ((uint)(2));
+            w9.LeftAttach = ((uint)(1));
+            w9.RightAttach = ((uint)(2));
+            w9.YOptions = ((Gtk.AttachOptions)(4));
+            w1.Add(this.table1);
+            Gtk.Box.BoxChild w10 = ((Gtk.Box.BoxChild)(w1[this.table1]));
+            w10.Position = 0;
+            w10.Expand = false;
+            w10.Fill = false;
+            w10.Padding = ((uint)(6));
+            // Internal child IBBoard.WarFoundry.FrmNewArmy.ActionArea
+            Gtk.HButtonBox w11 = this.ActionArea;
+            w11.CanFocus = true;
+            w11.Events = ((Gdk.EventMask)(256));
+            w11.Name = "WarFoundrySharp.FrmNewArmy_ActionArea";
+            w11.Spacing = 6;
+            w11.BorderWidth = ((uint)(5));
+            w11.LayoutStyle = ((Gtk.ButtonBoxStyle)(4));
+            // Container child WarFoundrySharp.FrmNewArmy_ActionArea.Gtk.ButtonBox+ButtonBoxChild
+            this.bttnCancel = new Gtk.Button();
+            this.bttnCancel.CanFocus = true;
+            this.bttnCancel.Name = "bttnCancel";
+            this.bttnCancel.UseStock = true;
+            this.bttnCancel.UseUnderline = true;
+            this.bttnCancel.Label = "gtk-cancel";
+            this.AddActionWidget(this.bttnCancel, -6);
+            Gtk.ButtonBox.ButtonBoxChild w12 = ((Gtk.ButtonBox.ButtonBoxChild)(w11[this.bttnCancel]));
+            w12.Expand = false;
+            w12.Fill = false;
+            // Container child WarFoundrySharp.FrmNewArmy_ActionArea.Gtk.ButtonBox+ButtonBoxChild
+            this.bttnCreate = new Gtk.Button();
+            this.bttnCreate.Sensitive = false;
+            this.bttnCreate.CanDefault = true;
+            this.bttnCreate.CanFocus = true;
+            this.bttnCreate.Name = "bttnCreate";
+            this.bttnCreate.UseUnderline = true;
+            // Container child bttnCreate.Gtk.Container+ContainerChild
+            Gtk.Alignment w13 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+            // Container child GtkAlignment1.Gtk.Container+ContainerChild
+            Gtk.HBox w14 = new Gtk.HBox();
+            w14.Spacing = 2;
+            // Container child GtkHBox1.Gtk.Container+ContainerChild
+            Gtk.Image w15 = new Gtk.Image();
+            w15.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-ok", Gtk.IconSize.Menu, 16);
+            w14.Add(w15);
+            // Container child GtkHBox1.Gtk.Container+ContainerChild
+            Gtk.Label w17 = new Gtk.Label();
+            w17.LabelProp = Mono.Unix.Catalog.GetString("C_reate");
+            w17.UseUnderline = true;
+            w14.Add(w17);
+            w13.Add(w14);
+            this.bttnCreate.Add(w13);
+            this.AddActionWidget(this.bttnCreate, -5);
+            Gtk.ButtonBox.ButtonBoxChild w21 = ((Gtk.ButtonBox.ButtonBoxChild)(w11[this.bttnCreate]));
+            w21.Position = 1;
+            w21.Expand = false;
+            w21.Fill = false;
+            if ((this.Child != null)) {
+                this.Child.ShowAll();
+            }
+            this.DefaultWidth = 400;
+            this.DefaultHeight = 322;
+            this.Show();
+            this.txtArmyName.Changed += new System.EventHandler(this.OnTextChanged);
+            this.sbPointsValue.ChangeValue += new Gtk.ChangeValueHandler(this.OnSpinChangeValue);
+            this.sbPointsValue.ValueChanged += new System.EventHandler(this.OnSpinValueChanged);
+            this.sbPointsValue.Changed += new System.EventHandler(this.OnSpinValueChanged);
+            this.bttnCancel.Clicked += new System.EventHandler(this.OnCancelClicked);
+            this.bttnCreate.Clicked += new System.EventHandler(this.OnCreateClicked);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/IBBoard.WarFoundry.FrmNewUnit.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,143 @@
+// ------------------------------------------------------------------------------
+//  <autogenerated>
+//      This code was generated by a tool.
+//      Mono Runtime Version: 2.0.50727.42
+// 
+//      Changes to this file may cause incorrect behavior and will be lost if 
+//      the code is regenerated.
+//  </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace IBBoard.WarFoundry {
+    
+    
+    public partial class FrmNewUnit {
+        
+        private Gtk.VBox vbox2;
+        
+        private Gtk.HBox hbox1;
+        
+        private Gtk.Label label1;
+        
+        private Gtk.ScrolledWindow GtkScrolledWindow;
+        
+        private Gtk.TreeView lstUnitTypes;
+        
+        private Gtk.Label lblNewUnitWarning;
+        
+        private Gtk.Button buttonCancel;
+        
+        private Gtk.Button buttonOk;
+        
+        protected virtual void Build() {
+            Stetic.Gui.Initialize(this);
+            // Widget IBBoard.WarFoundry.FrmNewUnit
+            this.Name = "IBBoard.WarFoundry.FrmNewUnit";
+            this.Title = Mono.Unix.Catalog.GetString("Add new unit");
+            this.Icon = Stetic.IconLoader.LoadIcon(this, "gtk-new", Gtk.IconSize.Menu, 16);
+            this.WindowPosition = ((Gtk.WindowPosition)(4));
+            this.Modal = true;
+            this.SkipPagerHint = true;
+            this.SkipTaskbarHint = true;
+            this.HasSeparator = false;
+            // Internal child IBBoard.WarFoundry.FrmNewUnit.VBox
+            Gtk.VBox w1 = this.VBox;
+            w1.Name = "dialog1_VBox";
+            w1.BorderWidth = ((uint)(2));
+            // Container child dialog1_VBox.Gtk.Box+BoxChild
+            this.vbox2 = new Gtk.VBox();
+            this.vbox2.Name = "vbox2";
+            this.vbox2.Spacing = 6;
+            // Container child vbox2.Gtk.Box+BoxChild
+            this.hbox1 = new Gtk.HBox();
+            this.hbox1.Name = "hbox1";
+            this.hbox1.Spacing = 6;
+            // Container child hbox1.Gtk.Box+BoxChild
+            this.label1 = new Gtk.Label();
+            this.label1.Name = "label1";
+            this.label1.LabelProp = Mono.Unix.Catalog.GetString("Unit Type:");
+            this.hbox1.Add(this.label1);
+            Gtk.Box.BoxChild w2 = ((Gtk.Box.BoxChild)(this.hbox1[this.label1]));
+            w2.Position = 0;
+            w2.Expand = false;
+            w2.Fill = false;
+            // Container child hbox1.Gtk.Box+BoxChild
+            this.GtkScrolledWindow = new Gtk.ScrolledWindow();
+            this.GtkScrolledWindow.Name = "GtkScrolledWindow";
+            this.GtkScrolledWindow.ShadowType = ((Gtk.ShadowType)(1));
+            // Container child GtkScrolledWindow.Gtk.Container+ContainerChild
+            this.lstUnitTypes = new Gtk.TreeView();
+            this.lstUnitTypes.HeightRequest = 150;
+            this.lstUnitTypes.CanFocus = true;
+            this.lstUnitTypes.Name = "lstUnitTypes";
+            this.lstUnitTypes.HeadersVisible = false;
+            this.lstUnitTypes.HeadersClickable = true;
+            this.GtkScrolledWindow.Add(this.lstUnitTypes);
+            this.hbox1.Add(this.GtkScrolledWindow);
+            Gtk.Box.BoxChild w4 = ((Gtk.Box.BoxChild)(this.hbox1[this.GtkScrolledWindow]));
+            w4.Position = 1;
+            this.vbox2.Add(this.hbox1);
+            Gtk.Box.BoxChild w5 = ((Gtk.Box.BoxChild)(this.vbox2[this.hbox1]));
+            w5.Position = 0;
+            w5.Expand = false;
+            w5.Fill = false;
+            // Container child vbox2.Gtk.Box+BoxChild
+            this.lblNewUnitWarning = new Gtk.Label();
+            this.lblNewUnitWarning.Name = "lblNewUnitWarning";
+            this.lblNewUnitWarning.Xalign = 0F;
+            this.lblNewUnitWarning.Yalign = 0F;
+            this.lblNewUnitWarning.LabelProp = "";
+            this.vbox2.Add(this.lblNewUnitWarning);
+            Gtk.Box.BoxChild w6 = ((Gtk.Box.BoxChild)(this.vbox2[this.lblNewUnitWarning]));
+            w6.Position = 1;
+            w6.Expand = false;
+            w6.Fill = false;
+            w1.Add(this.vbox2);
+            Gtk.Box.BoxChild w7 = ((Gtk.Box.BoxChild)(w1[this.vbox2]));
+            w7.Position = 0;
+            w7.Expand = false;
+            w7.Fill = false;
+            // Internal child IBBoard.WarFoundry.FrmNewUnit.ActionArea
+            Gtk.HButtonBox w8 = this.ActionArea;
+            w8.Name = "dialog1_ActionArea";
+            w8.Spacing = 6;
+            w8.BorderWidth = ((uint)(5));
+            w8.LayoutStyle = ((Gtk.ButtonBoxStyle)(4));
+            // Container child dialog1_ActionArea.Gtk.ButtonBox+ButtonBoxChild
+            this.buttonCancel = new Gtk.Button();
+            this.buttonCancel.CanDefault = true;
+            this.buttonCancel.CanFocus = true;
+            this.buttonCancel.Name = "buttonCancel";
+            this.buttonCancel.UseStock = true;
+            this.buttonCancel.UseUnderline = true;
+            this.buttonCancel.Label = "gtk-cancel";
+            this.AddActionWidget(this.buttonCancel, -6);
+            Gtk.ButtonBox.ButtonBoxChild w9 = ((Gtk.ButtonBox.ButtonBoxChild)(w8[this.buttonCancel]));
+            w9.Expand = false;
+            w9.Fill = false;
+            // Container child dialog1_ActionArea.Gtk.ButtonBox+ButtonBoxChild
+            this.buttonOk = new Gtk.Button();
+            this.buttonOk.Sensitive = false;
+            this.buttonOk.CanDefault = true;
+            this.buttonOk.CanFocus = true;
+            this.buttonOk.Name = "buttonOk";
+            this.buttonOk.UseStock = true;
+            this.buttonOk.UseUnderline = true;
+            this.buttonOk.Label = "gtk-ok";
+            this.AddActionWidget(this.buttonOk, -5);
+            Gtk.ButtonBox.ButtonBoxChild w10 = ((Gtk.ButtonBox.ButtonBoxChild)(w8[this.buttonOk]));
+            w10.Position = 1;
+            w10.Expand = false;
+            w10.Fill = false;
+            if ((this.Child != null)) {
+                this.Child.ShowAll();
+            }
+            this.DefaultWidth = 400;
+            this.DefaultHeight = 318;
+            this.Show();
+            this.lstUnitTypes.RowActivated += new Gtk.RowActivatedHandler(this.OnRowActivated);
+            this.buttonCancel.Activated += new System.EventHandler(this.OnButtonCancelActivated);
+            this.buttonOk.Clicked += new System.EventHandler(this.OnButtonOkClicked);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/IBBoard.WarFoundry.Widgets.UnitDisplayWidget.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,276 @@
+// ------------------------------------------------------------------------------
+//  <autogenerated>
+//      This code was generated by a tool.
+//      Mono Runtime Version: 2.0.50727.42
+// 
+//      Changes to this file may cause incorrect behavior and will be lost if 
+//      the code is regenerated.
+//  </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace IBBoard.WarFoundry.Widgets {
+    
+    
+    public partial class UnitDisplayWidget {
+        
+        private Gtk.VBox vbox1;
+        
+        private Gtk.HBox hbox1;
+        
+        private Gtk.Entry unitName;
+        
+        private Gtk.SpinButton unitSize;
+        
+        private Gtk.ScrolledWindow GtkScrolledWindow;
+        
+        private Gtk.NodeView unitStats;
+        
+        private Gtk.HSeparator hseparator1;
+        
+        private Gtk.Table table1;
+        
+        private Gtk.ScrolledWindow GtkScrolledWindow1;
+        
+        private Gtk.NodeView optionalEquipment;
+        
+        private Gtk.ScrolledWindow GtkScrolledWindow2;
+        
+        private Gtk.NodeView requiredEquipment;
+        
+        private Gtk.Label optionalEquipmentLabel;
+        
+        private Gtk.Label requiredEquipmentLabel;
+        
+        private Gtk.VBox vbox2;
+        
+        private Gtk.Button bttnReplaceRequired;
+        
+        private Gtk.Button bttnEditRequired;
+        
+        private Gtk.VBox vbox3;
+        
+        private Gtk.Button bttnAddOptional;
+        
+        private Gtk.Button bttnEditOptional;
+        
+        private Gtk.Button bttnRemove;
+        
+        private Gtk.HBox hbox2;
+        
+        protected virtual void Build() {
+            Stetic.Gui.Initialize(this);
+            // Widget IBBoard.WarFoundry.Widgets.UnitDisplayWidget
+            Stetic.BinContainer.Attach(this);
+            this.Name = "IBBoard.WarFoundry.Widgets.UnitDisplayWidget";
+            // Container child IBBoard.WarFoundry.Widgets.UnitDisplayWidget.Gtk.Container+ContainerChild
+            this.vbox1 = new Gtk.VBox();
+            this.vbox1.Name = "vbox1";
+            this.vbox1.Spacing = 6;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.hbox1 = new Gtk.HBox();
+            this.hbox1.Name = "hbox1";
+            this.hbox1.Spacing = 6;
+            // Container child hbox1.Gtk.Box+BoxChild
+            this.unitName = new Gtk.Entry();
+            this.unitName.CanFocus = true;
+            this.unitName.Name = "unitName";
+            this.unitName.IsEditable = true;
+            this.unitName.InvisibleChar = '•';
+            this.hbox1.Add(this.unitName);
+            Gtk.Box.BoxChild w1 = ((Gtk.Box.BoxChild)(this.hbox1[this.unitName]));
+            w1.Position = 0;
+            // Container child hbox1.Gtk.Box+BoxChild
+            this.unitSize = new Gtk.SpinButton(0, 100, 1);
+            this.unitSize.CanFocus = true;
+            this.unitSize.Name = "unitSize";
+            this.unitSize.Adjustment.PageIncrement = 10;
+            this.unitSize.ClimbRate = 1;
+            this.unitSize.Numeric = true;
+            this.hbox1.Add(this.unitSize);
+            Gtk.Box.BoxChild w2 = ((Gtk.Box.BoxChild)(this.hbox1[this.unitSize]));
+            w2.Position = 1;
+            w2.Expand = false;
+            w2.Fill = false;
+            this.vbox1.Add(this.hbox1);
+            Gtk.Box.BoxChild w3 = ((Gtk.Box.BoxChild)(this.vbox1[this.hbox1]));
+            w3.Position = 0;
+            w3.Expand = false;
+            w3.Fill = false;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.GtkScrolledWindow = new Gtk.ScrolledWindow();
+            this.GtkScrolledWindow.Name = "GtkScrolledWindow";
+            this.GtkScrolledWindow.ShadowType = ((Gtk.ShadowType)(1));
+            // Container child GtkScrolledWindow.Gtk.Container+ContainerChild
+            this.unitStats = new Gtk.NodeView();
+            this.unitStats.HeightRequest = 75;
+            this.unitStats.CanFocus = true;
+            this.unitStats.Name = "unitStats";
+            this.unitStats.HeadersClickable = true;
+            this.GtkScrolledWindow.Add(this.unitStats);
+            this.vbox1.Add(this.GtkScrolledWindow);
+            Gtk.Box.BoxChild w5 = ((Gtk.Box.BoxChild)(this.vbox1[this.GtkScrolledWindow]));
+            w5.Position = 1;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.hseparator1 = new Gtk.HSeparator();
+            this.hseparator1.Name = "hseparator1";
+            this.vbox1.Add(this.hseparator1);
+            Gtk.Box.BoxChild w6 = ((Gtk.Box.BoxChild)(this.vbox1[this.hseparator1]));
+            w6.Position = 2;
+            w6.Expand = false;
+            w6.Fill = false;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.table1 = new Gtk.Table(((uint)(2)), ((uint)(3)), false);
+            this.table1.Name = "table1";
+            this.table1.RowSpacing = ((uint)(6));
+            this.table1.ColumnSpacing = ((uint)(6));
+            // Container child table1.Gtk.Table+TableChild
+            this.GtkScrolledWindow1 = new Gtk.ScrolledWindow();
+            this.GtkScrolledWindow1.Name = "GtkScrolledWindow1";
+            this.GtkScrolledWindow1.ShadowType = ((Gtk.ShadowType)(1));
+            // Container child GtkScrolledWindow1.Gtk.Container+ContainerChild
+            this.optionalEquipment = new Gtk.NodeView();
+            this.optionalEquipment.CanFocus = true;
+            this.optionalEquipment.Name = "optionalEquipment";
+            this.optionalEquipment.HeadersClickable = true;
+            this.GtkScrolledWindow1.Add(this.optionalEquipment);
+            this.table1.Add(this.GtkScrolledWindow1);
+            Gtk.Table.TableChild w8 = ((Gtk.Table.TableChild)(this.table1[this.GtkScrolledWindow1]));
+            w8.TopAttach = ((uint)(1));
+            w8.BottomAttach = ((uint)(2));
+            w8.LeftAttach = ((uint)(1));
+            w8.RightAttach = ((uint)(2));
+            w8.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.GtkScrolledWindow2 = new Gtk.ScrolledWindow();
+            this.GtkScrolledWindow2.Name = "GtkScrolledWindow2";
+            this.GtkScrolledWindow2.ShadowType = ((Gtk.ShadowType)(1));
+            // Container child GtkScrolledWindow2.Gtk.Container+ContainerChild
+            this.requiredEquipment = new Gtk.NodeView();
+            this.requiredEquipment.CanFocus = true;
+            this.requiredEquipment.Name = "requiredEquipment";
+            this.requiredEquipment.HeadersClickable = true;
+            this.GtkScrolledWindow2.Add(this.requiredEquipment);
+            this.table1.Add(this.GtkScrolledWindow2);
+            Gtk.Table.TableChild w10 = ((Gtk.Table.TableChild)(this.table1[this.GtkScrolledWindow2]));
+            w10.LeftAttach = ((uint)(1));
+            w10.RightAttach = ((uint)(2));
+            w10.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.optionalEquipmentLabel = new Gtk.Label();
+            this.optionalEquipmentLabel.Name = "optionalEquipmentLabel";
+            this.optionalEquipmentLabel.LabelProp = Mono.Unix.Catalog.GetString("Optional Equipment:");
+            this.table1.Add(this.optionalEquipmentLabel);
+            Gtk.Table.TableChild w11 = ((Gtk.Table.TableChild)(this.table1[this.optionalEquipmentLabel]));
+            w11.TopAttach = ((uint)(1));
+            w11.BottomAttach = ((uint)(2));
+            w11.XOptions = ((Gtk.AttachOptions)(4));
+            w11.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.requiredEquipmentLabel = new Gtk.Label();
+            this.requiredEquipmentLabel.Name = "requiredEquipmentLabel";
+            this.requiredEquipmentLabel.LabelProp = Mono.Unix.Catalog.GetString("Required Equipment:");
+            this.table1.Add(this.requiredEquipmentLabel);
+            Gtk.Table.TableChild w12 = ((Gtk.Table.TableChild)(this.table1[this.requiredEquipmentLabel]));
+            w12.XOptions = ((Gtk.AttachOptions)(4));
+            w12.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.vbox2 = new Gtk.VBox();
+            this.vbox2.Name = "vbox2";
+            this.vbox2.Spacing = 6;
+            // Container child vbox2.Gtk.Box+BoxChild
+            this.bttnReplaceRequired = new Gtk.Button();
+            this.bttnReplaceRequired.CanFocus = true;
+            this.bttnReplaceRequired.Name = "bttnReplaceRequired";
+            this.bttnReplaceRequired.UseUnderline = true;
+            this.bttnReplaceRequired.Label = Mono.Unix.Catalog.GetString("Replace");
+            this.vbox2.Add(this.bttnReplaceRequired);
+            Gtk.Box.BoxChild w13 = ((Gtk.Box.BoxChild)(this.vbox2[this.bttnReplaceRequired]));
+            w13.Position = 0;
+            w13.Expand = false;
+            w13.Fill = false;
+            // Container child vbox2.Gtk.Box+BoxChild
+            this.bttnEditRequired = new Gtk.Button();
+            this.bttnEditRequired.CanFocus = true;
+            this.bttnEditRequired.Name = "bttnEditRequired";
+            this.bttnEditRequired.UseUnderline = true;
+            this.bttnEditRequired.Label = Mono.Unix.Catalog.GetString("Edit");
+            this.vbox2.Add(this.bttnEditRequired);
+            Gtk.Box.BoxChild w14 = ((Gtk.Box.BoxChild)(this.vbox2[this.bttnEditRequired]));
+            w14.Position = 1;
+            w14.Expand = false;
+            w14.Fill = false;
+            this.table1.Add(this.vbox2);
+            Gtk.Table.TableChild w15 = ((Gtk.Table.TableChild)(this.table1[this.vbox2]));
+            w15.LeftAttach = ((uint)(2));
+            w15.RightAttach = ((uint)(3));
+            w15.XOptions = ((Gtk.AttachOptions)(4));
+            w15.YOptions = ((Gtk.AttachOptions)(4));
+            // Container child table1.Gtk.Table+TableChild
+            this.vbox3 = new Gtk.VBox();
+            this.vbox3.Name = "vbox3";
+            this.vbox3.Spacing = 6;
+            // Container child vbox3.Gtk.Box+BoxChild
+            this.bttnAddOptional = new Gtk.Button();
+            this.bttnAddOptional.CanFocus = true;
+            this.bttnAddOptional.Name = "bttnAddOptional";
+            this.bttnAddOptional.UseUnderline = true;
+            this.bttnAddOptional.Label = Mono.Unix.Catalog.GetString("Add");
+            this.vbox3.Add(this.bttnAddOptional);
+            Gtk.Box.BoxChild w16 = ((Gtk.Box.BoxChild)(this.vbox3[this.bttnAddOptional]));
+            w16.Position = 0;
+            w16.Expand = false;
+            w16.Fill = false;
+            // Container child vbox3.Gtk.Box+BoxChild
+            this.bttnEditOptional = new Gtk.Button();
+            this.bttnEditOptional.CanFocus = true;
+            this.bttnEditOptional.Name = "bttnEditOptional";
+            this.bttnEditOptional.UseUnderline = true;
+            this.bttnEditOptional.Label = Mono.Unix.Catalog.GetString("Edit");
+            this.vbox3.Add(this.bttnEditOptional);
+            Gtk.Box.BoxChild w17 = ((Gtk.Box.BoxChild)(this.vbox3[this.bttnEditOptional]));
+            w17.Position = 1;
+            w17.Expand = false;
+            w17.Fill = false;
+            // Container child vbox3.Gtk.Box+BoxChild
+            this.bttnRemove = new Gtk.Button();
+            this.bttnRemove.CanFocus = true;
+            this.bttnRemove.Name = "bttnRemove";
+            this.bttnRemove.UseUnderline = true;
+            this.bttnRemove.Label = Mono.Unix.Catalog.GetString("Remove");
+            this.vbox3.Add(this.bttnRemove);
+            Gtk.Box.BoxChild w18 = ((Gtk.Box.BoxChild)(this.vbox3[this.bttnRemove]));
+            w18.Position = 2;
+            w18.Expand = false;
+            w18.Fill = false;
+            this.table1.Add(this.vbox3);
+            Gtk.Table.TableChild w19 = ((Gtk.Table.TableChild)(this.table1[this.vbox3]));
+            w19.TopAttach = ((uint)(1));
+            w19.BottomAttach = ((uint)(2));
+            w19.LeftAttach = ((uint)(2));
+            w19.RightAttach = ((uint)(3));
+            w19.XOptions = ((Gtk.AttachOptions)(4));
+            w19.YOptions = ((Gtk.AttachOptions)(4));
+            this.vbox1.Add(this.table1);
+            Gtk.Box.BoxChild w20 = ((Gtk.Box.BoxChild)(this.vbox1[this.table1]));
+            w20.Position = 3;
+            w20.Expand = false;
+            w20.Fill = false;
+            // Container child vbox1.Gtk.Box+BoxChild
+            this.hbox2 = new Gtk.HBox();
+            this.hbox2.Name = "hbox2";
+            this.hbox2.Spacing = 6;
+            this.vbox1.Add(this.hbox2);
+            Gtk.Box.BoxChild w21 = ((Gtk.Box.BoxChild)(this.vbox1[this.hbox2]));
+            w21.Position = 4;
+            this.Add(this.vbox1);
+            if ((this.Child != null)) {
+                this.Child.ShowAll();
+            }
+            this.Show();
+            this.unitName.FocusOutEvent += new Gtk.FocusOutEventHandler(this.OnUnitNameFocusOut);
+            this.unitName.KeyPressEvent += new Gtk.KeyPressEventHandler(this.OnUnitNameKeyPress);
+            this.unitSize.FocusOutEvent += new Gtk.FocusOutEventHandler(this.OnUnitSizeFocusOut);
+            this.unitSize.KeyPressEvent += new Gtk.KeyPressEventHandler(this.OnUnitSizeKeyPress);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/generated.cs	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,115 @@
+// ------------------------------------------------------------------------------
+//  <autogenerated>
+//      This code was generated by a tool.
+//      Mono Runtime Version: 2.0.50727.42
+// 
+//      Changes to this file may cause incorrect behavior and will be lost if 
+//      the code is regenerated.
+//  </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace Stetic {
+    
+    
+    internal class Gui {
+        
+        private static bool initialized;
+        
+        internal static void Initialize(Gtk.Widget iconRenderer) {
+            if ((Stetic.Gui.initialized == false)) {
+                Stetic.Gui.initialized = true;
+            }
+        }
+    }
+    
+    internal class IconLoader {
+        
+        public static Gdk.Pixbuf LoadIcon(Gtk.Widget widget, string name, Gtk.IconSize size, int sz) {
+            Gdk.Pixbuf res = widget.RenderIcon(name, size, null);
+            if ((res != null)) {
+                return res;
+            }
+            else {
+                try {
+                    return Gtk.IconTheme.Default.LoadIcon(name, sz, 0);
+                }
+                catch (System.Exception ) {
+                    if ((name != "gtk-missing-image")) {
+                        return Stetic.IconLoader.LoadIcon(widget, "gtk-missing-image", size, sz);
+                    }
+                    else {
+                        Gdk.Pixmap pmap = new Gdk.Pixmap(Gdk.Screen.Default.RootWindow, sz, sz);
+                        Gdk.GC gc = new Gdk.GC(pmap);
+                        gc.RgbFgColor = new Gdk.Color(255, 255, 255);
+                        pmap.DrawRectangle(gc, true, 0, 0, sz, sz);
+                        gc.RgbFgColor = new Gdk.Color(0, 0, 0);
+                        pmap.DrawRectangle(gc, false, 0, 0, (sz - 1), (sz - 1));
+                        gc.SetLineAttributes(3, Gdk.LineStyle.Solid, Gdk.CapStyle.Round, Gdk.JoinStyle.Round);
+                        gc.RgbFgColor = new Gdk.Color(255, 0, 0);
+                        pmap.DrawLine(gc, (sz / 4), (sz / 4), ((sz - 1) - (sz / 4)), ((sz - 1) - (sz / 4)));
+                        pmap.DrawLine(gc, ((sz - 1) - (sz / 4)), (sz / 4), (sz / 4), ((sz - 1) - (sz / 4)));
+                        return Gdk.Pixbuf.FromDrawable(pmap, pmap.Colormap, 0, 0, 0, 0, sz, sz);
+                    }
+                }
+            }
+        }
+    }
+    
+    internal class BinContainer {
+        
+        private Gtk.Widget child;
+        
+        private Gtk.UIManager uimanager;
+        
+        public static BinContainer Attach(Gtk.Bin bin) {
+            BinContainer bc = new BinContainer();
+            bin.SizeRequested += new Gtk.SizeRequestedHandler(bc.OnSizeRequested);
+            bin.SizeAllocated += new Gtk.SizeAllocatedHandler(bc.OnSizeAllocated);
+            bin.Added += new Gtk.AddedHandler(bc.OnAdded);
+            return bc;
+        }
+        
+        private void OnSizeRequested(object sender, Gtk.SizeRequestedArgs args) {
+            if ((this.child != null)) {
+                args.Requisition = this.child.SizeRequest();
+            }
+        }
+        
+        private void OnSizeAllocated(object sender, Gtk.SizeAllocatedArgs args) {
+            if ((this.child != null)) {
+                this.child.Allocation = args.Allocation;
+            }
+        }
+        
+        private void OnAdded(object sender, Gtk.AddedArgs args) {
+            this.child = args.Widget;
+        }
+        
+        public void SetUiManager(Gtk.UIManager uim) {
+            this.uimanager = uim;
+            this.child.Realized += new System.EventHandler(this.OnRealized);
+        }
+        
+        private void OnRealized(object sender, System.EventArgs args) {
+            if ((this.uimanager != null)) {
+                Gtk.Widget w;
+                w = this.child.Toplevel;
+                if (((w != null) && typeof(Gtk.Window).IsInstanceOfType(w))) {
+                    ((Gtk.Window)(w)).AddAccelGroup(this.uimanager.AccelGroup);
+                    this.uimanager = null;
+                }
+            }
+        }
+    }
+    
+    internal class ActionGroups {
+        
+        public static Gtk.ActionGroup GetActionGroup(System.Type type) {
+            return Stetic.ActionGroups.GetActionGroup(type.FullName);
+        }
+        
+        public static Gtk.ActionGroup GetActionGroup(string name) {
+            return null;
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/gui.stetic	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,1067 @@
+<?xml version="1.0" encoding="utf-8"?>
+<stetic-interface>
+  <configuration>
+    <images-root-path>..</images-root-path>
+    <target-gtk-version>2.12.1</target-gtk-version>
+  </configuration>
+  <import>
+    <widget-library name="../bin/Debug/WarFoundryGTK.exe" internal="true" />
+  </import>
+  <widget class="Gtk.Window" id="IBBoard.WarFoundry.FrmMainWindow" design-size="832 659">
+    <action-group name="Default">
+      <action id="menuFile">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">File</property>
+        <property name="ShortLabel" translatable="yes">File</property>
+      </action>
+      <action id="miCreateArmy">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Create army</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Create army</property>
+        <signal name="Activated" handler="OnCreateArmyActivated" />
+      </action>
+      <action id="miOpenArmy">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Open army</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Open army</property>
+        <signal name="Activated" handler="OnOpenArmyActivated" />
+      </action>
+      <action id="miSaveArmy">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Save army</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Save army</property>
+        <signal name="Activated" handler="OnSaveArmyActivated" />
+      </action>
+      <action id="miSaveArmyAs">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Save army as</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Save army as</property>
+        <signal name="Activated" handler="OnSaveArmyAsActivated" />
+      </action>
+      <action id="miCloseArmy">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Close army</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Close army</property>
+        <signal name="Activated" handler="OnCloseArmyActivated" />
+      </action>
+      <action id="miChangeGameSystem">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Change game system</property>
+        <property name="ShortLabel" translatable="yes">Change game system</property>
+        <signal name="Activated" handler="OnChangeGameSystemActivated" after="yes" />
+      </action>
+      <action id="miReloadFiles">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Reload files</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Reload files</property>
+        <signal name="Activated" handler="OnReloadFilesActivated" />
+      </action>
+      <action id="miExit">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Exit</property>
+        <property name="ShortLabel" translatable="yes">Exit</property>
+        <signal name="Activated" handler="OnExitActivated" />
+      </action>
+      <action id="menuEdit">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Edit</property>
+        <property name="ShortLabel" translatable="yes">Edit</property>
+      </action>
+      <action id="miUndo">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Undo</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Undo</property>
+      </action>
+      <action id="miRedo">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Redo</property>
+        <property name="Sensitive">False</property>
+        <property name="ShortLabel" translatable="yes">Redo</property>
+      </action>
+      <action id="menuHelp">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Help</property>
+        <property name="ShortLabel" translatable="yes">Help</property>
+      </action>
+      <action id="miAbout">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">About</property>
+        <property name="ShortLabel" translatable="yes">About</property>
+      </action>
+      <action id="miDebugInformation">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes">Debug Information</property>
+        <property name="ShortLabel" translatable="yes">Debug Information</property>
+      </action>
+      <action id="newArmyButton">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+        <property name="Sensitive">False</property>
+        <property name="StockId">gtk-new</property>
+        <signal name="Activated" handler="newTBButtonActivated" />
+      </action>
+      <action id="openArmyButton">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+        <property name="Sensitive">False</property>
+        <property name="StockId">gtk-open</property>
+        <signal name="Activated" handler="openTBButtonActivated" />
+      </action>
+      <action id="saveArmyButton">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+        <property name="Sensitive">False</property>
+        <property name="StockId">gtk-save</property>
+        <signal name="Activated" handler="saveTBButtonActivated" />
+      </action>
+      <action id="undoActionButton">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+        <property name="Sensitive">False</property>
+        <property name="StockId">gtk-undo</property>
+        <signal name="Activated" handler="undoTBButtonActivated" />
+      </action>
+      <action id="redoActionButton">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+        <property name="Sensitive">False</property>
+        <property name="StockId">gtk-redo</property>
+        <signal name="Activated" handler="redoTBButtonActivated" />
+      </action>
+      <action id="goDown">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+      </action>
+      <action id="add">
+        <property name="Type">Action</property>
+        <property name="Label" translatable="yes" />
+        <property name="StockId">gtk-add</property>
+      </action>
+    </action-group>
+    <property name="MemberName" />
+    <property name="Title" translatable="yes">MainWindow</property>
+    <property name="Icon">resource:App.ico</property>
+    <child>
+      <widget class="Gtk.VBox" id="vbox1">
+        <property name="MemberName" />
+        <child>
+          <widget class="Gtk.MenuBar" id="menubar1">
+            <property name="MemberName" />
+            <node name="menubar1" type="Menubar">
+              <node type="Menu" action="menuFile">
+                <node type="Menuitem" action="miCreateArmy" />
+                <node type="Menuitem" action="miOpenArmy" />
+                <node type="Menuitem" action="miSaveArmy" />
+                <node type="Menuitem" action="miSaveArmyAs" />
+                <node type="Menuitem" action="miCloseArmy" />
+                <node type="Separator" />
+                <node type="Menuitem" action="miChangeGameSystem" />
+                <node type="Separator" />
+                <node type="Menuitem" action="miReloadFiles" />
+                <node type="Separator" />
+                <node type="Menuitem" action="miExit" />
+              </node>
+              <node type="Menu" action="menuEdit">
+                <node type="Menuitem" action="miUndo" />
+                <node type="Menuitem" action="miRedo" />
+              </node>
+              <node type="Menu" action="menuHelp">
+                <node type="Menuitem" action="miAbout" />
+                <node type="Menuitem" action="miDebugInformation" />
+              </node>
+            </node>
+          </widget>
+          <packing>
+            <property name="Position">0</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.Toolbar" id="toolbar">
+            <property name="MemberName" />
+            <property name="HeightRequest">36</property>
+            <property name="ShowArrow">False</property>
+            <property name="ButtonStyle">Icons</property>
+            <node name="toolbar" type="Toolbar">
+              <node type="Toolitem" action="newArmyButton" />
+              <node type="Toolitem" action="openArmyButton" />
+              <node type="Toolitem" action="saveArmyButton" />
+              <node type="Separator" />
+              <node type="Toolitem" action="undoActionButton" />
+              <node type="Toolitem" action="redoActionButton" />
+              <node type="Separator" />
+            </node>
+          </widget>
+          <packing>
+            <property name="Position">1</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.HPaned" id="hpaned2">
+            <property name="MemberName" />
+            <property name="CanFocus">True</property>
+            <property name="Position">178</property>
+            <child>
+              <widget class="Gtk.TreeView" id="treeUnits">
+                <property name="MemberName" />
+                <property name="CanFocus">True</property>
+                <property name="HeadersClickable">True</property>
+                <signal name="RowActivated" handler="ArmyRowActivated" />
+              </widget>
+              <packing>
+                <property name="Resize">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Notebook" id="unitsNotebook">
+                <property name="MemberName" />
+                <property name="CanFocus">True</property>
+                <property name="CurrentPage">-1</property>
+              </widget>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">2</property>
+            <property name="AutoSize">True</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.Statusbar" id="statusbar1">
+            <property name="MemberName" />
+            <property name="Spacing">2</property>
+            <child>
+              <placeholder />
+            </child>
+            <child>
+              <placeholder />
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">3</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+  <widget class="Gtk.Dialog" id="IBBoard.WarFoundry.FrmNewArmy" design-size="400 322">
+    <property name="MemberName" />
+    <property name="Events">ButtonPressMask</property>
+    <property name="Title" translatable="yes">Create new army</property>
+    <property name="Icon">stock:gtk-new Menu</property>
+    <property name="WindowPosition">CenterOnParent</property>
+    <property name="SkipPagerHint">True</property>
+    <property name="SkipTaskbarHint">True</property>
+    <property name="Buttons">2</property>
+    <property name="HelpButton">False</property>
+    <property name="HasSeparator">False</property>
+    <child internal-child="VBox">
+      <widget class="Gtk.VBox" id="dialog_VBox">
+        <property name="MemberName" />
+        <property name="CanFocus">True</property>
+        <property name="Events">ButtonPressMask</property>
+        <property name="BorderWidth">2</property>
+        <child>
+          <widget class="Gtk.Table" id="table1">
+            <property name="MemberName" />
+            <property name="NRows">3</property>
+            <property name="NColumns">2</property>
+            <property name="RowSpacing">6</property>
+            <property name="ColumnSpacing">6</property>
+            <child>
+              <widget class="Gtk.ScrolledWindow" id="GtkScrolledWindow">
+                <property name="MemberName" />
+                <property name="ShadowType">In</property>
+                <child>
+                  <widget class="Gtk.TreeView" id="lstRaces">
+                    <property name="MemberName" />
+                    <property name="HeightRequest">150</property>
+                    <property name="CanFocus">True</property>
+                    <property name="ShowScrollbars">True</property>
+                    <property name="HeadersVisible">False</property>
+                    <property name="RulesHint">True</property>
+                    <property name="HeadersClickable">True</property>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="LeftAttach">1</property>
+                <property name="RightAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">True</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.HBox" id="hbox2">
+                <property name="MemberName" />
+                <child>
+                  <widget class="Gtk.SpinButton" id="sbPointsValue">
+                    <property name="MemberName" />
+                    <property name="WidthRequest">150</property>
+                    <property name="CanFocus">True</property>
+                    <property name="Upper">2000000000</property>
+                    <property name="PageIncrement">1000</property>
+                    <property name="StepIncrement">100</property>
+                    <property name="ClimbRate">100</property>
+                    <property name="Numeric">True</property>
+                    <property name="Value">1000</property>
+                    <signal name="ChangeValue" handler="OnSpinChangeValue" />
+                    <signal name="ValueChanged" handler="OnSpinValueChanged" />
+                    <signal name="Changed" handler="OnSpinValueChanged" />
+                  </widget>
+                  <packing>
+                    <property name="Position">0</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+                <child>
+                  <placeholder />
+                </child>
+              </widget>
+              <packing>
+                <property name="TopAttach">2</property>
+                <property name="BottomAttach">3</property>
+                <property name="LeftAttach">1</property>
+                <property name="RightAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">True</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Label" id="label1">
+                <property name="MemberName" />
+                <property name="LabelProp" translatable="yes">Race</property>
+              </widget>
+              <packing>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Label" id="label2">
+                <property name="MemberName" />
+                <property name="LabelProp" translatable="yes">Army name</property>
+              </widget>
+              <packing>
+                <property name="TopAttach">1</property>
+                <property name="BottomAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Label" id="label3">
+                <property name="MemberName" />
+                <property name="LabelProp" translatable="yes">Points value</property>
+              </widget>
+              <packing>
+                <property name="TopAttach">2</property>
+                <property name="BottomAttach">3</property>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Entry" id="txtArmyName">
+                <property name="MemberName" />
+                <property name="CanFocus">True</property>
+                <property name="IsEditable">True</property>
+                <property name="InvisibleChar">•</property>
+                <signal name="Changed" handler="OnTextChanged" />
+              </widget>
+              <packing>
+                <property name="TopAttach">1</property>
+                <property name="BottomAttach">2</property>
+                <property name="LeftAttach">1</property>
+                <property name="RightAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">True</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">0</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+            <property name="Padding">6</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+    <child internal-child="ActionArea">
+      <widget class="Gtk.HButtonBox" id="WarFoundrySharp.FrmNewArmy_ActionArea">
+        <property name="MemberName" />
+        <property name="CanFocus">True</property>
+        <property name="Events">ButtonPressMask</property>
+        <property name="Spacing">6</property>
+        <property name="BorderWidth">5</property>
+        <property name="Size">2</property>
+        <property name="LayoutStyle">End</property>
+        <child>
+          <widget class="Gtk.Button" id="bttnCancel">
+            <property name="MemberName" />
+            <property name="CanFocus">True</property>
+            <property name="UseStock">True</property>
+            <property name="Type">StockItem</property>
+            <property name="StockId">gtk-cancel</property>
+            <property name="ResponseId">-6</property>
+            <signal name="Clicked" handler="OnCancelClicked" />
+            <property name="label">gtk-cancel</property>
+          </widget>
+          <packing>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.Button" id="bttnCreate">
+            <property name="MemberName" />
+            <property name="Sensitive">False</property>
+            <property name="CanDefault">True</property>
+            <property name="CanFocus">True</property>
+            <property name="Type">TextAndIcon</property>
+            <property name="Icon">stock:gtk-ok Menu</property>
+            <property name="Label" translatable="yes">C_reate</property>
+            <property name="UseUnderline">True</property>
+            <property name="ResponseId">-5</property>
+            <signal name="Clicked" handler="OnCreateClicked" />
+          </widget>
+          <packing>
+            <property name="Position">1</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+  <widget class="Gtk.Dialog" id="IBBoard.WarFoundry.FrmChangeGameSystem" design-size="527 257">
+    <property name="MemberName" />
+    <property name="Title" translatable="yes">Change Game System</property>
+    <property name="Icon">resource:App.ico</property>
+    <property name="TypeHint">Dialog</property>
+    <property name="WindowPosition">CenterOnParent</property>
+    <property name="Modal">True</property>
+    <property name="Resizable">False</property>
+    <property name="AllowGrow">False</property>
+    <property name="DefaultWidth">400</property>
+    <property name="DefaultHeight">300</property>
+    <property name="SkipPagerHint">True</property>
+    <property name="SkipTaskbarHint">True</property>
+    <property name="Buttons">2</property>
+    <property name="HelpButton">False</property>
+    <property name="HasSeparator">False</property>
+    <child internal-child="VBox">
+      <widget class="Gtk.VBox" id="dialog1_VBox">
+        <property name="MemberName" />
+        <property name="Spacing">6</property>
+        <property name="BorderWidth">2</property>
+        <child>
+          <widget class="Gtk.HBox" id="hbox1">
+            <property name="MemberName" />
+            <property name="Spacing">6</property>
+            <child>
+              <widget class="Gtk.Label" id="lblGameSystem">
+                <property name="MemberName" />
+                <property name="LabelProp" translatable="yes">Game System</property>
+              </widget>
+              <packing>
+                <property name="Position">0</property>
+                <property name="AutoSize">False</property>
+                <property name="Expand">False</property>
+                <property name="Fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.ScrolledWindow" id="GtkScrolledWindow">
+                <property name="MemberName" />
+                <property name="ShadowType">In</property>
+                <child>
+                  <widget class="Gtk.TreeView" id="lstGameSystems">
+                    <property name="MemberName" />
+                    <property name="WidthRequest">250</property>
+                    <property name="HeightRequest">125</property>
+                    <property name="CanFocus">True</property>
+                    <property name="ShowScrollbars">True</property>
+                    <property name="HeadersVisible">False</property>
+                    <property name="HeadersClickable">True</property>
+                    <signal name="RowActivated" handler="lstGameSystemsRowActivated" />
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="Position">1</property>
+                <property name="AutoSize">True</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">0</property>
+            <property name="AutoSize">False</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+    <child internal-child="ActionArea">
+      <widget class="Gtk.HButtonBox" id="dialog1_ActionArea">
+        <property name="MemberName" />
+        <property name="Spacing">6</property>
+        <property name="BorderWidth">5</property>
+        <property name="Size">2</property>
+        <property name="LayoutStyle">End</property>
+        <child>
+          <widget class="Gtk.Button" id="buttonCancel">
+            <property name="MemberName" />
+            <property name="CanDefault">True</property>
+            <property name="CanFocus">True</property>
+            <property name="UseStock">True</property>
+            <property name="Type">StockItem</property>
+            <property name="StockId">gtk-cancel</property>
+            <property name="ResponseId">-6</property>
+            <signal name="Clicked" handler="OnCancel" />
+            <property name="label">gtk-cancel</property>
+          </widget>
+          <packing>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.Button" id="buttonOk">
+            <property name="MemberName" />
+            <property name="Sensitive">False</property>
+            <property name="CanDefault">True</property>
+            <property name="CanFocus">True</property>
+            <property name="UseStock">True</property>
+            <property name="Type">StockItem</property>
+            <property name="StockId">gtk-ok</property>
+            <property name="ResponseId">-5</property>
+            <signal name="Clicked" handler="OnGameSystemOkayClicked" />
+            <property name="label">gtk-ok</property>
+          </widget>
+          <packing>
+            <property name="Position">1</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+  <widget class="Gtk.Dialog" id="IBBoard.WarFoundry.FrmNewUnit" design-size="400 318">
+    <property name="MemberName" />
+    <property name="Title" translatable="yes">Add new unit</property>
+    <property name="Icon">stock:gtk-new Menu</property>
+    <property name="WindowPosition">CenterOnParent</property>
+    <property name="Modal">True</property>
+    <property name="SkipPagerHint">True</property>
+    <property name="SkipTaskbarHint">True</property>
+    <property name="Buttons">2</property>
+    <property name="HelpButton">False</property>
+    <property name="HasSeparator">False</property>
+    <child internal-child="VBox">
+      <widget class="Gtk.VBox" id="dialog1_VBox">
+        <property name="MemberName" />
+        <property name="BorderWidth">2</property>
+        <child>
+          <widget class="Gtk.VBox" id="vbox2">
+            <property name="MemberName" />
+            <property name="Spacing">6</property>
+            <child>
+              <widget class="Gtk.HBox" id="hbox1">
+                <property name="MemberName" />
+                <property name="Spacing">6</property>
+                <child>
+                  <widget class="Gtk.Label" id="label1">
+                    <property name="MemberName" />
+                    <property name="LabelProp" translatable="yes">Unit Type:</property>
+                  </widget>
+                  <packing>
+                    <property name="Position">0</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+                <child>
+                  <widget class="Gtk.ScrolledWindow" id="GtkScrolledWindow">
+                    <property name="MemberName" />
+                    <property name="ShadowType">In</property>
+                    <child>
+                      <widget class="Gtk.TreeView" id="lstUnitTypes">
+                        <property name="MemberName" />
+                        <property name="HeightRequest">150</property>
+                        <property name="CanFocus">True</property>
+                        <property name="ShowScrollbars">True</property>
+                        <property name="HeadersVisible">False</property>
+                        <property name="HeadersClickable">True</property>
+                        <signal name="RowActivated" handler="OnRowActivated" />
+                      </widget>
+                    </child>
+                  </widget>
+                  <packing>
+                    <property name="Position">1</property>
+                    <property name="AutoSize">True</property>
+                  </packing>
+                </child>
+              </widget>
+              <packing>
+                <property name="Position">0</property>
+                <property name="AutoSize">True</property>
+                <property name="Expand">False</property>
+                <property name="Fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Label" id="lblNewUnitWarning">
+                <property name="MemberName" />
+                <property name="Xalign">0</property>
+                <property name="Yalign">0</property>
+                <property name="LabelProp" translatable="yes" />
+              </widget>
+              <packing>
+                <property name="Position">1</property>
+                <property name="AutoSize">True</property>
+                <property name="Expand">False</property>
+                <property name="Fill">False</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">0</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+    <child internal-child="ActionArea">
+      <widget class="Gtk.HButtonBox" id="dialog1_ActionArea">
+        <property name="MemberName" />
+        <property name="Spacing">6</property>
+        <property name="BorderWidth">5</property>
+        <property name="Size">2</property>
+        <property name="LayoutStyle">End</property>
+        <child>
+          <widget class="Gtk.Button" id="buttonCancel">
+            <property name="MemberName" />
+            <property name="CanDefault">True</property>
+            <property name="CanFocus">True</property>
+            <property name="UseStock">True</property>
+            <property name="Type">StockItem</property>
+            <property name="StockId">gtk-cancel</property>
+            <property name="ResponseId">-6</property>
+            <signal name="Activated" handler="OnButtonCancelActivated" />
+            <property name="label">gtk-cancel</property>
+          </widget>
+          <packing>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.Button" id="buttonOk">
+            <property name="MemberName" />
+            <property name="Sensitive">False</property>
+            <property name="CanDefault">True</property>
+            <property name="CanFocus">True</property>
+            <property name="UseStock">True</property>
+            <property name="Type">StockItem</property>
+            <property name="StockId">gtk-ok</property>
+            <property name="ResponseId">-5</property>
+            <signal name="Clicked" handler="OnButtonOkClicked" />
+            <property name="label">gtk-ok</property>
+          </widget>
+          <packing>
+            <property name="Position">1</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+  <widget class="Gtk.Bin" id="IBBoard.WarFoundry.Widgets.UnitDisplayWidget" design-size="649 422">
+    <property name="MemberName" />
+    <child>
+      <widget class="Gtk.VBox" id="vbox1">
+        <property name="MemberName" />
+        <property name="Spacing">6</property>
+        <child>
+          <widget class="Gtk.HBox" id="hbox1">
+            <property name="MemberName" />
+            <property name="Spacing">6</property>
+            <child>
+              <widget class="Gtk.Entry" id="unitName">
+                <property name="MemberName" />
+                <property name="CanFocus">True</property>
+                <property name="IsEditable">True</property>
+                <property name="InvisibleChar">•</property>
+                <signal name="FocusOutEvent" handler="OnUnitNameFocusOut" />
+                <signal name="KeyPressEvent" handler="OnUnitNameKeyPress" />
+              </widget>
+              <packing>
+                <property name="Position">0</property>
+                <property name="AutoSize">True</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.SpinButton" id="unitSize">
+                <property name="MemberName" />
+                <property name="CanFocus">True</property>
+                <property name="Upper">100</property>
+                <property name="PageIncrement">10</property>
+                <property name="StepIncrement">1</property>
+                <property name="ClimbRate">1</property>
+                <property name="Numeric">True</property>
+                <signal name="FocusOutEvent" handler="OnUnitSizeFocusOut" />
+                <signal name="KeyPressEvent" handler="OnUnitSizeKeyPress" />
+              </widget>
+              <packing>
+                <property name="Position">1</property>
+                <property name="AutoSize">True</property>
+                <property name="Expand">False</property>
+                <property name="Fill">False</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">0</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.ScrolledWindow" id="GtkScrolledWindow">
+            <property name="MemberName" />
+            <property name="ShadowType">In</property>
+            <child>
+              <widget class="Gtk.NodeView" id="unitStats">
+                <property name="MemberName" />
+                <property name="HeightRequest">75</property>
+                <property name="CanFocus">True</property>
+                <property name="ShowScrollbars">True</property>
+                <property name="HeadersClickable">True</property>
+              </widget>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">1</property>
+            <property name="AutoSize">True</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.HSeparator" id="hseparator1">
+            <property name="MemberName" />
+          </widget>
+          <packing>
+            <property name="Position">2</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.Table" id="table1">
+            <property name="MemberName" />
+            <property name="NRows">2</property>
+            <property name="NColumns">3</property>
+            <property name="RowSpacing">6</property>
+            <property name="ColumnSpacing">6</property>
+            <child>
+              <widget class="Gtk.ScrolledWindow" id="GtkScrolledWindow1">
+                <property name="MemberName" />
+                <property name="ShadowType">In</property>
+                <child>
+                  <widget class="Gtk.NodeView" id="optionalEquipment">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="ShowScrollbars">True</property>
+                    <property name="HeadersClickable">True</property>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="TopAttach">1</property>
+                <property name="BottomAttach">2</property>
+                <property name="LeftAttach">1</property>
+                <property name="RightAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">True</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.ScrolledWindow" id="GtkScrolledWindow2">
+                <property name="MemberName" />
+                <property name="ShadowType">In</property>
+                <child>
+                  <widget class="Gtk.NodeView" id="requiredEquipment">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="ShowScrollbars">True</property>
+                    <property name="HeadersClickable">True</property>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="LeftAttach">1</property>
+                <property name="RightAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">True</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Label" id="optionalEquipmentLabel">
+                <property name="MemberName" />
+                <property name="LabelProp" translatable="yes">Optional Equipment:</property>
+              </widget>
+              <packing>
+                <property name="TopAttach">1</property>
+                <property name="BottomAttach">2</property>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.Label" id="requiredEquipmentLabel">
+                <property name="MemberName" />
+                <property name="LabelProp" translatable="yes">Required Equipment:</property>
+              </widget>
+              <packing>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.VBox" id="vbox2">
+                <property name="MemberName" />
+                <property name="Spacing">6</property>
+                <child>
+                  <widget class="Gtk.Button" id="bttnReplaceRequired">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="Type">TextOnly</property>
+                    <property name="Label" translatable="yes">Replace</property>
+                    <property name="UseUnderline">True</property>
+                  </widget>
+                  <packing>
+                    <property name="Position">0</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+                <child>
+                  <widget class="Gtk.Button" id="bttnEditRequired">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="Type">TextOnly</property>
+                    <property name="Label" translatable="yes">Edit</property>
+                    <property name="UseUnderline">True</property>
+                  </widget>
+                  <packing>
+                    <property name="Position">1</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+                <child>
+                  <placeholder />
+                </child>
+              </widget>
+              <packing>
+                <property name="LeftAttach">2</property>
+                <property name="RightAttach">3</property>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="Gtk.VBox" id="vbox3">
+                <property name="MemberName" />
+                <property name="Spacing">6</property>
+                <child>
+                  <widget class="Gtk.Button" id="bttnAddOptional">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="Type">TextOnly</property>
+                    <property name="Label" translatable="yes">Add</property>
+                    <property name="UseUnderline">True</property>
+                  </widget>
+                  <packing>
+                    <property name="Position">0</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+                <child>
+                  <widget class="Gtk.Button" id="bttnEditOptional">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="Type">TextOnly</property>
+                    <property name="Label" translatable="yes">Edit</property>
+                    <property name="UseUnderline">True</property>
+                  </widget>
+                  <packing>
+                    <property name="Position">1</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+                <child>
+                  <widget class="Gtk.Button" id="bttnRemove">
+                    <property name="MemberName" />
+                    <property name="CanFocus">True</property>
+                    <property name="Type">TextOnly</property>
+                    <property name="Label" translatable="yes">Remove</property>
+                    <property name="UseUnderline">True</property>
+                  </widget>
+                  <packing>
+                    <property name="Position">2</property>
+                    <property name="AutoSize">True</property>
+                    <property name="Expand">False</property>
+                    <property name="Fill">False</property>
+                  </packing>
+                </child>
+              </widget>
+              <packing>
+                <property name="TopAttach">1</property>
+                <property name="BottomAttach">2</property>
+                <property name="LeftAttach">2</property>
+                <property name="RightAttach">3</property>
+                <property name="AutoSize">True</property>
+                <property name="XOptions">Fill</property>
+                <property name="YOptions">Fill</property>
+                <property name="XExpand">False</property>
+                <property name="XFill">True</property>
+                <property name="XShrink">False</property>
+                <property name="YExpand">False</property>
+                <property name="YFill">True</property>
+                <property name="YShrink">False</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">3</property>
+            <property name="AutoSize">True</property>
+            <property name="Expand">False</property>
+            <property name="Fill">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="Gtk.HBox" id="hbox2">
+            <property name="MemberName" />
+            <property name="Spacing">6</property>
+            <child>
+              <placeholder />
+            </child>
+            <child>
+              <placeholder />
+            </child>
+            <child>
+              <placeholder />
+            </child>
+          </widget>
+          <packing>
+            <property name="Position">4</property>
+            <property name="AutoSize">True</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+</stetic-interface>
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gtk-gui/objects.xml	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,6 @@
+<objects>
+  <object type="IBBoard.WarFoundry.Widgets.UnitDisplayWidget" palette-category="WarFoundry GTK# GUI" allow-children="false" base-type="Gtk.Bin">
+    <itemgroups />
+    <signals />
+  </object>
+</objects>
\ No newline at end of file
Binary file libs/log4net.dll has changed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libs/log4net.xml	Fri Dec 19 15:57:51 2008 +0000
@@ -0,0 +1,27658 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
+            before the call to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseCommand">
+            <summary>
+            Prepares the database command and initialize the parameters.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_usePreparedCommand">
+            <summary>
+            Flag to indicate if we are using a command object
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>true</c> when the appender is to use a prepared
+            statement or stored procedure to insert into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbCommand">
+            <summary>
+            The database command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <see cref="T:log4net.Appender.IAppender"/> array whose elements should be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements should be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>true if access to the ICollection is synchronized (thread-safe); otherwise, false.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.AspNetTraceAppender">
+            <summary>
+            <para>
+            Appends log events to the ASP.NET <see cref="T:System.Web.TraceContext"/> system.
+            </para>
+            </summary>
+            <remarks>
+            <para>
+            Diagnostic information and tracing messages that you specify are appended to the output 
+            of the page that is sent to the requesting browser. Optionally, you can view this information
+            from a separate trace viewer (Trace.axd) that displays trace information for every page in a 
+            given application.
+            </para>
+            <para>
+            Trace statements are processed and displayed only when tracing is enabled. You can control 
+            whether tracing is displayed to a page, to the trace viewer, or both.
+            </para>
+            <para>
+            The logging event is passed to the <see cref="M:System.Web.TraceContext.Write(System.String)"/> or 
+            <see cref="M:System.Web.TraceContext.Warn(System.String)"/> method depending on the level of the logging event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AspNetTraceAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the ASP.NET trace
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the ASP.NET trace
+            <c>HttpContext.Current.Trace</c> 
+            (<see cref="T:System.Web.TraceContext"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(System.String,System.String)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventLogEventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="p"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="p"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative model, <see cref="T:log4net.Appender.FileAppender.MinimalLock"/>, only holds a
+            write lock while the appender is writing a logging event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checked if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            There are two built in locking models, <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> and <see cref="T:log4net.Appender.FileAppender.MinimalLock"/>.
+            The former locks the file from the start of logging to the end and the 
+            later lock only for the minimal amount of time when logging each message.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            The value of this property will be set before <see cref="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)"/> is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:log4net.Appender.MemoryAppender.GetEvents"/> method to get
+            the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:log4net.Appender.MemoryAppender.Clear"/> method to clear the
+            current list of events.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+            <summary>
+            Sends logging events as connectionless UDP datagrams to a remote host or a 
+            multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <remarks>
+            <para>
+            UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+            </para>
+            <para>
+            To view the logging results, a custom application can be developed that listens for logging 
+            events.
+            </para>
+            <para>
+            When decoding events send via this appender remember to use the same encoding
+            to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+            property to specify the encoding to use.
+            </para>
+            </remarks>
+            <example>
+            This example shows how to log receive logging events that are sent 
+            on IP address 244.0.0.1 and port 8080 to the console. The event is 
+            encoded in the packet as a unicode string and it is decoded as such. 
+            <code lang="C#">
+            IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+            UdpClient udpClient;
+            byte[] buffer;
+            string loggingEvent;
+            
+            try 
+            {
+                udpClient = new UdpClient(8080);
+                
+                while(true) 
+                {
+                    buffer = udpClient.Receive(ref remoteEndPoint);
+                    loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                    Console.WriteLine(loggingEvent);
+                }
+            } 
+            catch(Exception e) 
+            {
+                Console.WriteLine(e.ToString());
+            }
+            </code>
+            <code lang="Visual Basic">
+            Dim remoteEndPoint as IPEndPoint
+            Dim udpClient as UdpClient
+            Dim buffer as Byte()
+            Dim loggingEvent as String
+            
+            Try 
+                remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                udpClient = new UdpClient(8080)
+            
+                While True
+                    buffer = udpClient.Receive(ByRef remoteEndPoint)
+                    loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                    Console.WriteLine(loggingEvent)
+                Wend
+            Catch e As Exception
+                Console.WriteLine(e.ToString())
+            End Try
+            </code>
+            <para>
+            An example configuration section to log information using this appender to the 
+            IP 224.0.0.1 on port 8080:
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                <remoteAddress value="224.0.0.1"/>
+                <remotePort value="8080"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+            </appender>
+            </code>
+            </example>
+            <author>Gert Driesen</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">The TCP port number assigned to <see cref="P:log4net.Appender.UdpAppender.LocalPort"/> or <see cref="P:log4net.Appender.UdpAppender.RemotePort"/> is less than <see cref="F:System.Net.IPEndPoint.MinPort"/> or greater than <see cref="F:System.Net.IPEndPoint.MaxPort"/>.</exception>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>